int main() { slong iter; flint_rand_t state; flint_printf("evaluate2_rectangular...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { arb_poly_t f, g; arb_t x, y1, z1, y2, z2; arb_init(x); arb_init(y1); arb_init(z1); arb_init(y2); arb_init(z2); arb_poly_init(f); arb_poly_init(g); arb_randtest(x, state, 2 + n_randint(state, 1000), 5); arb_poly_randtest(f, state, 2 + n_randint(state, 100), 2 + n_randint(state, 1000), 5); arb_poly_derivative(g, f, 2 + n_randint(state, 1000)); arb_poly_evaluate2_rectangular(y1, z1, f, x, 2 + n_randint(state, 1000)); arb_poly_evaluate_horner(y2, f, x, 2 + n_randint(state, 1000)); arb_poly_evaluate_horner(z2, g, x, 2 + n_randint(state, 1000)); if (!arb_overlaps(y1, y2) || !arb_overlaps(z1, z2)) { flint_printf("FAIL\n\n"); 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("x = "); arb_printd(x, 15); flint_printf("\n\n"); flint_printf("y1 = "); arb_printd(y1, 15); flint_printf("\n\n"); flint_printf("z1 = "); arb_printd(z1, 15); flint_printf("\n\n"); flint_printf("y2 = "); arb_printd(y2, 15); flint_printf("\n\n"); flint_printf("z2 = "); arb_printd(z2, 15); flint_printf("\n\n"); abort(); } arb_poly_clear(f); arb_poly_clear(g); arb_clear(x); arb_clear(y1); arb_clear(z1); arb_clear(y2); arb_clear(z2); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int arb_poly_divrem(arb_poly_t Q, arb_poly_t R, const arb_poly_t A, const arb_poly_t B, slong prec) { const slong lenA = A->length, lenB = B->length; if (lenB == 0 || arb_contains_zero(B->coeffs + lenB - 1)) { return 0; } if (lenA < lenB) { arb_poly_set(R, A); arb_poly_zero(Q); return 1; } if (Q == A || Q == B) { arb_poly_t T; arb_poly_init(T); arb_poly_divrem(T, R, A, B, prec); arb_poly_swap(Q, T); arb_poly_clear(T); return 1; } if (R == A || R == B) { arb_poly_t U; arb_poly_init(U); arb_poly_divrem(Q, U, A, B, prec); arb_poly_swap(R, U); arb_poly_clear(U); return 1; } arb_poly_fit_length(Q, lenA - lenB + 1); arb_poly_fit_length(R, lenB - 1); _arb_poly_divrem(Q->coeffs, R->coeffs, A->coeffs, lenA, B->coeffs, lenB, prec); _arb_poly_set_length(Q, lenA - lenB + 1); _arb_poly_set_length(R, lenB - 1); _arb_poly_normalise(R); return 1; }
void acb_poly_set2_fmpq_poly(acb_poly_t poly, const fmpq_poly_t re, const fmpq_poly_t im, slong prec) { arb_poly_t t, u; arb_poly_init(t); arb_poly_init(u); arb_poly_set_fmpq_poly(t, re, prec); arb_poly_set_fmpq_poly(u, im, prec); acb_poly_set2_arb_poly(poly, t, u); arb_poly_clear(t); arb_poly_clear(u); }
void arb_poly_div_series(arb_poly_t Q, const arb_poly_t A, const arb_poly_t B, long n, long prec) { if (n == 0 || B->length == 0) { printf("arb_poly_inv_series: require n > 0 and nonzero input\n"); abort(); } if (A->length == 0) { arb_poly_zero(Q); return; } if (Q == A || Q == B) { arb_poly_t t; arb_poly_init(t); arb_poly_div_series(t, A, B, n, prec); arb_poly_swap(Q, t); arb_poly_clear(t); return; } arb_poly_fit_length(Q, n); _arb_poly_div_series(Q->coeffs, A->coeffs, A->length, B->coeffs, B->length, n, prec); _arb_poly_set_length(Q, n); _arb_poly_normalise(Q); }
void arb_poly_sqrt_series(arb_poly_t g, const arb_poly_t h, long n, long prec) { if (n == 0) { arb_poly_zero(g); return; } if (g == h) { arb_poly_t t; arb_poly_init(t); arb_poly_sqrt_series(t, h, n, prec); arb_poly_swap(g, t); arb_poly_clear(t); return; } arb_poly_fit_length(g, n); if (h->length == 0) _arb_vec_indeterminate(g->coeffs, n); else _arb_poly_sqrt_series(g->coeffs, h->coeffs, h->length, n, prec); _arb_poly_set_length(g, n); _arb_poly_normalise(g); }
void arb_poly_rising_ui_series(arb_poly_t res, const arb_poly_t f, ulong r, slong trunc, slong prec) { slong len; if ((f->length == 0 && r != 0) || trunc == 0) { arb_poly_zero(res); return; } if (r == 0) { arb_poly_one(res); return; } len = poly_pow_length(f->length, r, trunc); if (f == res) { arb_poly_t tmp; arb_poly_init(tmp); arb_poly_rising_ui_series(tmp, f, r, len, prec); arb_poly_swap(tmp, res); arb_poly_clear(tmp); } else { arb_poly_fit_length(res, len); _arb_poly_rising_ui_series(res->coeffs, f->coeffs, f->length, r, len, prec); _arb_poly_set_length(res, len); _arb_poly_normalise(res); } }
void arb_poly_inv_series(arb_poly_t Qinv, const arb_poly_t Q, slong n, slong prec) { if (n == 0) { arb_poly_zero(Qinv); return; } if (Q->length == 0) { arb_poly_fit_length(Qinv, n); _arb_vec_indeterminate(Qinv->coeffs, n); _arb_poly_set_length(Qinv, n); return; } if (Qinv == Q) { arb_poly_t t; arb_poly_init(t); arb_poly_inv_series(t, Q, n, prec); arb_poly_swap(Qinv, t); arb_poly_clear(t); return; } arb_poly_fit_length(Qinv, n); _arb_poly_inv_series(Qinv->coeffs, Q->coeffs, Q->length, n, prec); _arb_poly_set_length(Qinv, n); _arb_poly_normalise(Qinv); }
void acb_poly_set_fmpq_poly(acb_poly_t poly, const fmpq_poly_t re, slong prec) { arb_poly_t t; arb_poly_init(t); arb_poly_set_fmpq_poly(t, re, prec); acb_poly_set_arb_poly(poly, t); arb_poly_clear(t); }
static void bsplit(arb_poly_t pol, const arb_t sqrtD, const slong * qbf, slong a, slong b, slong prec) { if (b - a == 0) { arb_poly_one(pol); } else if (b - a == 1) { acb_t z; acb_init(z); /* j((-b+sqrt(-D))/(2a)) */ arb_set_si(acb_realref(z), -FLINT_ABS(qbf[3 * a + 1])); arb_set(acb_imagref(z), sqrtD); acb_div_si(z, z, 2 * qbf[3 * a], prec); acb_modular_j(z, z, prec); if (qbf[3 * a + 1] < 0) { /* (x^2 - 2re(j) x + |j|^2) */ arb_poly_fit_length(pol, 3); arb_mul(pol->coeffs, acb_realref(z), acb_realref(z), prec); arb_addmul(pol->coeffs, acb_imagref(z), acb_imagref(z), prec); arb_mul_2exp_si(pol->coeffs + 1, acb_realref(z), 1); arb_neg(pol->coeffs + 1, pol->coeffs + 1); arb_one(pol->coeffs + 2); _arb_poly_set_length(pol, 3); } else { /* (x-j) */ arb_poly_fit_length(pol, 2); arb_neg(pol->coeffs, acb_realref(z)); arb_one(pol->coeffs + 1); _arb_poly_set_length(pol, 2); } acb_clear(z); } else { arb_poly_t tmp; arb_poly_init(tmp); bsplit(pol, sqrtD, qbf, a, a + (b - a) / 2, prec); bsplit(tmp, sqrtD, qbf, a + (b - a) / 2, b, prec); arb_poly_mul(pol, pol, tmp, prec); arb_poly_clear(tmp); } }
int main() { slong iter; flint_rand_t state; flint_printf("evaluate_acb_rectangular...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000; iter++) { arb_poly_t f; acb_t x, y1, y2; acb_init(x); acb_init(y1); acb_init(y2); arb_poly_init(f); acb_randtest(x, state, 2 + n_randint(state, 1000), 5); arb_poly_randtest(f, state, 2 + n_randint(state, 100), 2 + n_randint(state, 1000), 5); arb_poly_evaluate_acb_rectangular(y1, f, x, 2 + n_randint(state, 1000)); arb_poly_evaluate_acb_horner(y2, f, x, 2 + n_randint(state, 1000)); if (!acb_overlaps(y1, y2)) { flint_printf("FAIL\n\n"); flint_printf("f = "); arb_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(); } arb_poly_clear(f); acb_clear(x); acb_clear(y1); acb_clear(y2); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
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++) { arb_poly_t A; arb_t a; long n = n_randint(state, 100); arb_poly_init(A); arb_poly_randtest(A, state, n_randint(state, 100), 100, 10); arb_init(a); arb_poly_get_coeff_arb(a, A, n); result = n < arb_poly_length(A) ? arb_equal(a, arb_poly_get_coeff_ptr(A, n)) : arb_poly_get_coeff_ptr(A, n) == NULL; if (!result) { printf("FAIL:\n"); printf("A = "), arb_poly_printd(A, 10), printf("\n\n"); printf("a = "), arb_print(a), printf("\n\n"); printf("n = %ld\n\n", n); abort(); } arb_poly_clear(A); arb_clear(a); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return 0; }
int _acb_modular_hilbert_class_poly(fmpz_poly_t res, slong D, const slong * qbf, slong qbf_len, slong prec) { arb_t sqrtD; arb_poly_t pol; int success; arb_init(sqrtD); arb_poly_init(pol); arb_set_si(sqrtD, -D); arb_sqrt(sqrtD, sqrtD, prec); bsplit(pol, sqrtD, qbf, 0, qbf_len, prec); success = arb_poly_get_unique_fmpz_poly(res, pol); arb_clear(sqrtD); arb_poly_clear(pol); return success; }
void arb_poly_div_series(arb_poly_t Q, const arb_poly_t A, const arb_poly_t B, long n, long prec) { if (n == 0) { arb_poly_zero(Q); return; } if (B->length == 0) { arb_poly_fit_length(Q, n); _arb_vec_indeterminate(Q->coeffs, n); _arb_poly_set_length(Q, n); return; } if (A->length == 0) { arb_poly_zero(Q); return; } if (Q == A || Q == B) { arb_poly_t t; arb_poly_init(t); arb_poly_div_series(t, A, B, n, prec); arb_poly_swap(Q, t); arb_poly_clear(t); return; } arb_poly_fit_length(Q, n); _arb_poly_div_series(Q->coeffs, A->coeffs, A->length, B->coeffs, B->length, n, prec); _arb_poly_set_length(Q, n); _arb_poly_normalise(Q); }
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); }
int main() { slong iter; flint_rand_t state; flint_printf("cos_pi_series...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 1000; iter++) { slong m, n1, n2, bits1, bits2, bits3; arb_poly_t S, A, B, C; arb_t pi; bits1 = 2 + n_randint(state, 200); bits2 = 2 + n_randint(state, 200); bits3 = 2 + n_randint(state, 200); m = 1 + n_randint(state, 30); n1 = 1 + n_randint(state, 30); n2 = 1 + n_randint(state, 30); arb_poly_init(S); arb_poly_init(A); arb_poly_init(B); arb_poly_init(C); arb_init(pi); arb_poly_randtest(S, state, m, bits1, 3); arb_poly_randtest(A, state, m, bits1, 3); arb_poly_randtest(B, state, m, bits1, 3); arb_poly_cos_pi_series(A, S, n1, bits2); arb_const_pi(pi, bits3); arb_poly_set_arb(B, pi); arb_poly_mul(B, S, B, bits3); arb_poly_cos_series(B, B, n2, bits3); arb_poly_set(C, A); arb_poly_truncate(C, FLINT_MIN(n1, n2)); arb_poly_truncate(B, FLINT_MIN(n1, n2)); if (!arb_poly_overlaps(B, C)) { flint_printf("FAIL\n\n"); flint_printf("S = "); arb_poly_printd(S, 15); flint_printf("\n\n"); flint_printf("A = "); arb_poly_printd(A, 15); flint_printf("\n\n"); flint_printf("B = "); arb_poly_printd(B, 15); flint_printf("\n\n"); abort(); } arb_poly_cos_pi_series(S, S, n1, bits2); if (!arb_poly_overlaps(A, S)) { flint_printf("FAIL (aliasing)\n\n"); abort(); } arb_poly_clear(S); arb_poly_clear(A); arb_poly_clear(B); arb_poly_clear(C); arb_clear(pi); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("pow_ui...."); fflush(stdout); flint_randinit(state); /* compare with fmpz_poly */ for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { slong zbits1, rbits1, rbits2; ulong e; fmpz_poly_t A, B; arb_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, 30); fmpz_poly_init(A); fmpz_poly_init(B); arb_poly_init(a); arb_poly_init(b); fmpz_poly_randtest(A, state, 1 + n_randint(state, 8), zbits1); fmpz_poly_pow(B, A, e); arb_poly_set_fmpz_poly(a, A, rbits1); arb_poly_pow_ui(b, a, e, rbits2); if (!arb_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("A = "); fmpz_poly_print(A); flint_printf("\n\n"); flint_printf("B = "); fmpz_poly_print(B); flint_printf("\n\n"); flint_printf("a = "); arb_poly_printd(a, 15); flint_printf("\n\n"); flint_printf("b = "); arb_poly_printd(b, 15); flint_printf("\n\n"); abort(); } arb_poly_pow_ui(a, a, e, rbits2); if (!arb_poly_equal(a, b)) { flint_printf("FAIL (aliasing)\n\n"); abort(); } fmpz_poly_clear(A); fmpz_poly_clear(B); arb_poly_clear(a); arb_poly_clear(b); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { long iter; flint_rand_t state; printf("zeta_series...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 500; iter++) { long m, n1, n2, bits1, bits2, bits3; int deflate; arb_poly_t S, A, B, C, D, E, F; arb_t a, a1; bits1 = 2 + n_randint(state, 300); bits2 = 2 + n_randint(state, 300); bits3 = 2 + n_randint(state, 300); m = 1 + n_randint(state, 30); n1 = 1 + n_randint(state, 30); n2 = 1 + n_randint(state, 30); arb_poly_init(S); arb_poly_init(A); arb_poly_init(B); arb_poly_init(C); arb_poly_init(D); arb_poly_init(E); arb_poly_init(F); arb_init(a); arb_init(a1); deflate = n_randint(state, 2); arb_poly_randtest(S, state, m, bits1, 3); arb_randtest_precise(a, state, bits1, 3); arb_poly_set_coeff_arb(S, 0, a); if (n_randint(state, 2)) arb_randtest(a, state, bits1, 3); else arb_one(a); arb_poly_zeta_series(A, S, a, deflate, n1, bits2); arb_poly_zeta_series(B, S, a, deflate, n2, bits3); arb_poly_set(C, A); arb_poly_truncate(C, FLINT_MIN(n1, n2)); arb_poly_truncate(B, FLINT_MIN(n1, n2)); if (!arb_poly_overlaps(B, C)) { printf("FAIL\n\n"); printf("S = "); arb_poly_printd(S, 15); printf("\n\n"); printf("a = "); arb_printd(a, 15); printf("\n\n"); printf("A = "); arb_poly_printd(A, 15); printf("\n\n"); printf("B = "); arb_poly_printd(B, 15); printf("\n\n"); abort(); } /* check zeta(s,a) = zeta(s,a+1) + a^(-s) */ arb_poly_set_arb(D, a); arb_poly_log_series(D, D, n1, bits2); arb_poly_mullow(D, D, S, n1, bits2); arb_poly_neg(D, D); arb_poly_exp_series(D, D, n1, bits2); arb_add_ui(a1, a, 1, bits2); arb_poly_zeta_series(E, S, a1, deflate, n1, bits2); arb_poly_add(E, E, D, bits2); if (!arb_poly_overlaps(A, E)) { printf("FAIL (functional equation)\n\n"); printf("S = "); arb_poly_printd(S, 15); printf("\n\n"); printf("a = "); arb_printd(a, 15); printf("\n\n"); printf("A = "); arb_poly_printd(A, 15); printf("\n\n"); printf("E = "); arb_poly_printd(A, 15); printf("\n\n"); abort(); } arb_poly_zeta_series(S, S, a, deflate, n1, bits2); if (!arb_poly_overlaps(A, S)) { printf("FAIL (aliasing)\n\n"); abort(); } arb_poly_clear(S); arb_poly_clear(A); arb_poly_clear(B); arb_poly_clear(C); arb_poly_clear(D); arb_poly_clear(E); arb_poly_clear(F); arb_clear(a); arb_clear(a1); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("revert_series_lagrange...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++) { slong qbits1, rbits1, rbits2, n; fmpq_poly_t A, B; arb_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); arb_poly_init(a); arb_poly_init(b); arb_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); arb_poly_set_fmpq_poly(a, A, rbits1); arb_poly_revert_series_lagrange(b, a, n, rbits2); if (!arb_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 = "); arb_poly_printd(a, 15); flint_printf("\n\n"); flint_printf("b = "); arb_poly_printd(b, 15); flint_printf("\n\n"); flint_abort(); } arb_poly_set(c, a); arb_poly_revert_series_lagrange(c, c, n, rbits2); if (!arb_poly_equal(c, b)) { flint_printf("FAIL (aliasing)\n\n"); flint_abort(); } fmpq_poly_clear(A); fmpq_poly_clear(B); arb_poly_clear(a); arb_poly_clear(b); arb_poly_clear(c); } 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() { long iter; flint_rand_t state; printf("interpolate_fast...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000; iter++) { long i, n, qbits1, qbits2, rbits1, rbits2, rbits3; fmpq_poly_t P; arb_poly_t R, S; fmpq_t t, u; arb_ptr xs, ys; fmpq_poly_init(P); arb_poly_init(R); arb_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 = _arb_vec_init(n); ys = _arb_vec_init(n); arb_poly_set_fmpq_poly(R, P, rbits1); if (n > 0) { fmpq_randtest(t, state, qbits2); arb_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); arb_set_fmpq(xs + i, t, rbits2); } } for (i = 0; i < n; i++) arb_poly_evaluate(ys + i, R, xs + i, rbits2); arb_poly_interpolate_fast(S, xs, ys, n, rbits3); if (!arb_poly_contains_fmpq_poly(S, P)) { printf("FAIL:\n"); printf("P = "); fmpq_poly_print(P); printf("\n\n"); printf("R = "); arb_poly_printd(R, 15); printf("\n\n"); printf("S = "); arb_poly_printd(S, 15); printf("\n\n"); abort(); } fmpq_poly_clear(P); arb_poly_clear(R); arb_poly_clear(S); fmpq_clear(t); fmpq_clear(u); _arb_vec_clear(xs, n); _arb_vec_clear(ys, n); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main() { long iter; flint_rand_t state; printf("divrem...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 100000; iter++) { long m, n, qbits1, qbits2, rbits1, rbits2, rbits3; fmpq_poly_t A, B, Q, R; arb_poly_t a, b, q, r; 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); m = 1 + n_randint(state, 20); n = 1 + n_randint(state, 20); fmpq_poly_init(A); fmpq_poly_init(B); fmpq_poly_init(Q); fmpq_poly_init(R); arb_poly_init(a); arb_poly_init(b); arb_poly_init(q); arb_poly_init(r); fmpq_poly_randtest(A, state, m, qbits1); fmpq_poly_randtest_not_zero(B, state, n, qbits2); fmpq_poly_divrem(Q, R, A, B); arb_poly_set_fmpq_poly(a, A, rbits1); arb_poly_set_fmpq_poly(b, B, rbits2); arb_poly_divrem(q, r, a, b, rbits3); if (!arb_poly_contains_fmpq_poly(q, Q) || !arb_poly_contains_fmpq_poly(r, R)) { printf("FAIL\n\n"); printf("A = "); fmpq_poly_print(A); printf("\n\n"); printf("B = "); fmpq_poly_print(B); printf("\n\n"); printf("Q = "); fmpq_poly_print(Q); printf("\n\n"); printf("R = "); fmpq_poly_print(R); printf("\n\n"); printf("a = "); arb_poly_printd(a, 15); printf("\n\n"); printf("b = "); arb_poly_printd(b, 15); printf("\n\n"); printf("q = "); arb_poly_printd(q, 15); printf("\n\n"); printf("r = "); arb_poly_printd(r, 15); printf("\n\n"); abort(); } arb_poly_divrem(a, r, a, b, rbits3); if (!arb_poly_equal(a, q)) { printf("FAIL (aliasing q, a)\n\n"); } arb_poly_set_fmpq_poly(a, A, rbits1); arb_poly_divrem(b, r, a, b, rbits3); if (!arb_poly_equal(b, q)) { printf("FAIL (aliasing q, b)\n\n"); abort(); } arb_poly_set_fmpq_poly(b, B, rbits2); arb_poly_divrem(q, a, a, b, rbits3); if (!arb_poly_equal(a, r)) { printf("FAIL (aliasing r, a)\n\n"); abort(); } arb_poly_set_fmpq_poly(a, A, rbits1); arb_poly_divrem(q, b, a, b, rbits3); if (!arb_poly_equal(b, r)) { printf("FAIL (aliasing r, b)\n\n"); abort(); } fmpq_poly_clear(A); fmpq_poly_clear(B); fmpq_poly_clear(Q); fmpq_poly_clear(R); arb_poly_clear(a); arb_poly_clear(b); arb_poly_clear(q); arb_poly_clear(r); } flint_randclear(state); flint_cleanup(); 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++) { arb_poly_t a, b, c, d; slong len, prec; arb_poly_init(a); arb_poly_init(b); arb_poly_init(c); arb_poly_init(d); arb_poly_randtest(a, state, 1 + n_randint(state, 10), 100, 10); arb_poly_randtest(b, state, 1 + n_randint(state, 10), 100, 10); arb_poly_randtest(c, state, 1 + n_randint(state, 10), 100, 10); arb_poly_randtest(d, state, 1 + n_randint(state, 10), 100, 10); prec = 2 + n_randint(state, 100); len = n_randint(state, 10); arb_poly_add_series(c, a, b, len, prec); arb_poly_add(d, a, b, prec); arb_poly_truncate(d, len); if (!arb_poly_equal(c, d)) { flint_printf("FAIL\n\n"); flint_printf("a = "); arb_poly_printd(a, 15); flint_printf("\n\n"); flint_printf("b = "); arb_poly_printd(b, 15); flint_printf("\n\n"); flint_printf("c = "); arb_poly_printd(c, 15); flint_printf("\n\n"); flint_printf("c = "); arb_poly_printd(c, 15); flint_printf("\n\n"); abort(); } arb_poly_set(d, a); arb_poly_add_series(d, d, b, len, prec); if (!arb_poly_equal(d, c)) { flint_printf("FAIL (aliasing 1)\n\n"); abort(); } arb_poly_set(d, b); arb_poly_add_series(d, a, d, len, prec); if (!arb_poly_equal(d, c)) { flint_printf("FAIL (aliasing 2)\n\n"); abort(); } arb_poly_clear(a); arb_poly_clear(b); arb_poly_clear(c); arb_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("legendre_p_ui_root...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 100 * arb_test_multiplier(); iter++) { ulong n, k; slong prec; arb_ptr roots, weights; arb_poly_t pol; arb_t s; fmpq_poly_t pol2; n = 1 + n_randint(state, 100); prec = 20 + n_randint(state, 500); roots = _arb_vec_init(n); weights = _arb_vec_init(n); arb_poly_init(pol); fmpq_poly_init(pol2); arb_init(s); for (k = 0; k < n; k++) { if (k > n / 2 && n_randint(state, 2)) { arb_neg(roots + k, roots + n - k - 1); arb_set(weights + k, weights + n - k - 1); } else { arb_hypgeom_legendre_p_ui_root(roots + k, weights + k, n, k, prec); } } arb_poly_product_roots(pol, roots, n, prec); /* fmpq_poly_legendre_p(pol2, n); */ arith_legendre_polynomial(pol2, n); arb_set_fmpz(s, pol2->coeffs + n); arb_div_fmpz(s, s, pol2->den, prec); arb_poly_scalar_mul(pol, pol, s, prec); if (!arb_poly_contains_fmpq_poly(pol, pol2)) { flint_printf("FAIL: polynomial containment\n\n"); flint_printf("n = %wu, prec = %wd\n\n", n, prec); flint_printf("pol = "); arb_poly_printd(pol, 30); flint_printf("\n\n"); flint_printf("pol2 = "); fmpq_poly_print(pol2); flint_printf("\n\n"); flint_abort(); } arb_zero(s); for (k = 0; k < n; k++) { arb_add(s, s, weights + k, prec); } if (!arb_contains_si(s, 2)) { flint_printf("FAIL: sum of weights\n\n"); flint_printf("n = %wu, prec = %wd\n\n", n, prec); flint_printf("s = "); arb_printn(s, 30, 0); flint_printf("\n\n"); flint_abort(); } _arb_vec_clear(roots, n); _arb_vec_clear(weights, n); arb_poly_clear(pol); fmpq_poly_clear(pol2); arb_clear(s); } for (iter = 0; iter < 500 * arb_test_multiplier(); iter++) { arb_t x1, x2, w1, w2; ulong n, k; slong prec1, prec2; arb_init(x1); arb_init(x2); arb_init(w1); arb_init(w2); n = 1 + n_randtest(state) % 100000; if (n_randint(state, 2) || n == 1) k = n_randtest(state) % n; else k = n / 2 - (n_randtest(state) % (n / 2)); prec1 = 2 + n_randtest(state) % 2000; prec2 = 2 + n_randtest(state) % 2000; arb_hypgeom_legendre_p_ui_root(x1, w1, n, k, prec1); if (n_randint(state, 10) == 0) arb_hypgeom_legendre_p_ui_root(x1, NULL, n, k, prec1); arb_hypgeom_legendre_p_ui_root(x2, w2, n, k, prec2); if (!arb_overlaps(x1, x2) || !arb_overlaps(w1, w2)) { flint_printf("FAIL: overlap\n\n"); flint_printf("n = %wu, k = %wu, prec1 = %wd, prec2 = %wd\n\n", n, k, prec1, prec2); flint_printf("x1 = "); arb_printn(x1, 100, 0); flint_printf("\n\n"); flint_printf("x2 = "); arb_printn(x2, 100, 0); flint_printf("\n\n"); flint_printf("w1 = "); arb_printn(w1, 100, 0); flint_printf("\n\n"); flint_printf("w2 = "); arb_printn(w2, 100, 0); flint_printf("\n\n"); flint_abort(); } if (arb_rel_accuracy_bits(x1) < prec1 - 3 || arb_rel_accuracy_bits(w1) < prec1 - 3) { flint_printf("FAIL: accuracy\n\n"); flint_printf("n = %wu, k = %wu, prec1 = %wd\n\n", n, k, prec1); flint_printf("acc(x1) = %wd, acc(w1) = %wd\n\n", arb_rel_accuracy_bits(x1), arb_rel_accuracy_bits(w1)); flint_printf("x1 = "); arb_printn(x1, prec1, ARB_STR_CONDENSE * 30); flint_printf("\n\n"); flint_printf("w1 = "); arb_printn(w1, prec1, ARB_STR_CONDENSE * 30); flint_printf("\n\n"); flint_abort(); } if (arb_rel_accuracy_bits(x2) < prec2 - 3 || arb_rel_accuracy_bits(w2) < prec2 - 3) { flint_printf("FAIL: accuracy 2\n\n"); flint_printf("n = %wu, k = %wu, prec2 = %wd\n\n", n, k, prec2); flint_printf("acc(x2) = %wd, acc(w2) = %wd\n\n", arb_rel_accuracy_bits(x2), arb_rel_accuracy_bits(w2)); flint_printf("x2 = "); arb_printn(x2, prec2, ARB_STR_CONDENSE * 30); flint_printf("\n\n"); flint_printf("w2 = "); arb_printn(w2, prec2, ARB_STR_CONDENSE * 30); flint_printf("\n\n"); flint_abort(); } arb_clear(x1); arb_clear(x2); arb_clear(w1); arb_clear(w2); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { int i, result; flint_rand_t state; flint_printf("shift_left/right...."); fflush(stdout); flint_randinit(state); /* Check aliasing of a and b for left shift */ for (i = 0; i < 1000; i++) { arb_poly_t a, b; slong shift = n_randint(state, 100); arb_poly_init(a); arb_poly_init(b); arb_poly_randtest(a, state, n_randint(state, 100), 2 + n_randint(state, 200), 10); arb_poly_shift_left(b, a, shift); arb_poly_shift_left(a, a, shift); result = (arb_poly_equal(a, b)); if (!result) { flint_printf("FAIL:\n"); arb_poly_printd(a, 10), flint_printf("\n\n"); arb_poly_printd(b, 10), flint_printf("\n\n"); abort(); } arb_poly_clear(a); arb_poly_clear(b); } /* Check aliasing of a and b for right shift */ for (i = 0; i < 1000; i++) { arb_poly_t a, b; slong shift = n_randint(state, 100); arb_poly_init(a); arb_poly_init(b); arb_poly_randtest(a, state, n_randint(state, 100), 2 + n_randint(state, 200), 10); arb_poly_shift_right(b, a, shift); arb_poly_shift_right(a, a, shift); result = (arb_poly_equal(a, b)); if (!result) { flint_printf("FAIL:\n"); arb_poly_printd(a, 10), flint_printf("\n\n"); arb_poly_printd(b, 10), flint_printf("\n\n"); abort(); } arb_poly_clear(a); arb_poly_clear(b); } /* Check shift left then right does nothing */ for (i = 0; i < 1000; i++) { arb_poly_t a, b, c; slong shift = n_randint(state, 100); arb_poly_init(a); arb_poly_init(b); arb_poly_init(c); arb_poly_randtest(a, state, n_randint(state, 100), 2 + n_randint(state, 200), 10); arb_poly_shift_left(b, a, shift); arb_poly_shift_right(c, b, shift); result = (arb_poly_equal(c, a)); if (!result) { flint_printf("FAIL:\n"); arb_poly_printd(a, 10), flint_printf("\n\n"); arb_poly_printd(b, 10), flint_printf("\n\n"); arb_poly_printd(c, 10), flint_printf("\n\n"); abort(); } arb_poly_clear(a); arb_poly_clear(b); arb_poly_clear(c); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return 0; }
int main() { slong iter; flint_rand_t state; flint_printf("div_series...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { slong m, n, p, qbits, rbits1, rbits2; fmpq_poly_t A, B, C; arb_poly_t a, b, c, d; 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); p = 1 + n_randint(state, 20); fmpq_poly_init(A); fmpq_poly_init(B); fmpq_poly_init(C); arb_poly_init(a); arb_poly_init(b); arb_poly_init(c); arb_poly_init(d); fmpq_poly_randtest(A, state, m, qbits); do { fmpq_poly_randtest_not_zero(B, state, n, qbits); } while (B->coeffs[0] == 0); fmpq_poly_div_series(C, A, B, p); arb_poly_set_fmpq_poly(a, A, rbits1); arb_poly_set_fmpq_poly(b, B, rbits1); arb_poly_div_series(c, a, b, p, rbits2); if (!arb_poly_contains_fmpq_poly(c, C)) { flint_printf("FAIL\n\n"); flint_printf("bits2 = %wd\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("C = "); fmpq_poly_print(C); flint_printf("\n\n"); flint_printf("a = "); arb_poly_printd(a, 15); flint_printf("\n\n"); flint_printf("b = "); arb_poly_printd(b, 15); flint_printf("\n\n"); flint_printf("c = "); arb_poly_printd(c, 15); flint_printf("\n\n"); flint_abort(); } arb_poly_set(d, a); arb_poly_div_series(d, d, b, p, rbits2); if (!arb_poly_equal(d, c)) { flint_printf("FAIL (aliasing 1)\n\n"); flint_abort(); } arb_poly_set(d, b); arb_poly_div_series(d, a, d, p, rbits2); if (!arb_poly_equal(d, c)) { flint_printf("FAIL (aliasing 2)\n\n"); flint_abort(); } arb_poly_set(d, b); arb_poly_div_series(c, d, d, p, rbits2); arb_poly_div_series(d, d, d, p, rbits2); if (!arb_poly_equal(d, c)) { flint_printf("FAIL (aliasing 3)\n\n"); flint_abort(); } fmpq_poly_clear(A); fmpq_poly_clear(B); fmpq_poly_clear(C); arb_poly_clear(a); arb_poly_clear(b); arb_poly_clear(c); arb_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_horner...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000; iter++) { slong qbits1, qbits2, rbits1, rbits2, rbits3; fmpq_poly_t F; fmpq_t X, Y; arb_poly_t f; arb_t x, y; 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(F); fmpq_init(X); fmpq_init(Y); arb_poly_init(f); arb_init(x); arb_init(y); fmpq_poly_randtest(F, state, 1 + n_randint(state, 20), qbits1); fmpq_randtest(X, state, qbits2); fmpq_poly_evaluate_fmpq(Y, F, X); arb_poly_set_fmpq_poly(f, F, rbits1); arb_set_fmpq(x, X, rbits2); arb_poly_evaluate_horner(y, f, x, rbits3); if (!arb_contains_fmpq(y, Y)) { flint_printf("FAIL\n\n"); flint_printf("F = "); fmpq_poly_print(F); flint_printf("\n\n"); flint_printf("X = "); fmpq_print(X); flint_printf("\n\n"); flint_printf("Y = "); fmpq_print(Y); flint_printf("\n\n"); flint_printf("f = "); arb_poly_printd(f, 15); flint_printf("\n\n"); flint_printf("x = "); arb_printd(x, 15); flint_printf("\n\n"); flint_printf("y = "); arb_printd(y, 15); flint_printf("\n\n"); abort(); } /* aliasing */ arb_poly_evaluate_horner(x, f, x, rbits3); if (!arb_contains_fmpq(x, Y)) { flint_printf("FAIL (aliasing)\n\n"); abort(); } fmpq_poly_clear(F); fmpq_clear(X); fmpq_clear(Y); arb_poly_clear(f); arb_clear(x); arb_clear(y); } 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; arb_poly_t f; arb_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); arb_poly_init(f); x = _arb_vec_init(n); y = _arb_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); arb_poly_set_fmpq_poly(f, F, rbits1); for (i = 0; i < n; i++) arb_set_fmpq(x + i, X + i, rbits2); arb_poly_evaluate_vec_fast(y, f, x, n, rbits3); for (i = 0; i < n; i++) { if (!arb_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 = "); arb_poly_printd(f, 15); flint_printf("\n\n"); flint_printf("x = "); arb_printd(x + i, 15); flint_printf("\n\n"); flint_printf("y = "); arb_printd(y + i, 15); flint_printf("\n\n"); abort(); } } fmpq_poly_clear(F); _fmpq_vec_clear(X, n); _fmpq_vec_clear(Y, n); arb_poly_clear(f); _arb_vec_clear(x, n); _arb_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("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; }
int main() { slong iter; flint_rand_t state; flint_printf("taylor_shift_convolution...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 2000 * arb_test_multiplier(); iter++) { slong prec1, prec2; arb_poly_t f, g; arb_t c, d, e; prec1 = 2 + n_randint(state, 500); prec2 = 2 + n_randint(state, 500); arb_poly_init(f); arb_poly_init(g); arb_init(c); arb_init(d); arb_init(e); arb_poly_randtest(f, state, 1 + n_randint(state, 40), 1 + n_randint(state, 500), 10); arb_poly_randtest(g, state, 1 + n_randint(state, 20), 1 + n_randint(state, 500), 10); if (n_randint(state, 2)) arb_set_si(c, n_randint(state, 5) - 2); else arb_randtest(c, state, 1 + n_randint(state, 500), 1 + n_randint(state, 100)); if (n_randint(state, 2)) arb_set_si(d, n_randint(state, 5) - 2); else arb_randtest(d, state, 1 + n_randint(state, 500), 1 + n_randint(state, 100)); arb_add(e, c, d, prec1); /* check f(x+c)(x+d) = f(x+c+d) */ arb_poly_taylor_shift_convolution(g, f, e, prec2); arb_poly_taylor_shift_convolution(f, f, c, prec1); arb_poly_taylor_shift_convolution(f, f, d, prec1); if (!arb_poly_overlaps(f, g)) { flint_printf("FAIL\n\n"); flint_printf("c = "); arb_printd(c, 15); flint_printf("\n\n"); flint_printf("d = "); arb_printd(d, 15); flint_printf("\n\n"); flint_printf("f = "); arb_poly_printd(f, 15); flint_printf("\n\n"); flint_printf("g = "); arb_poly_printd(g, 15); flint_printf("\n\n"); abort(); } arb_poly_clear(f); arb_poly_clear(g); arb_clear(c); arb_clear(d); arb_clear(e); } 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); }