int main() { slong iter; flint_rand_t state; flint_printf("bell_sum_taylor...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++) { arb_t s1, s2; fmpz_t a, b, n; slong prec; arb_init(s1); arb_init(s2); fmpz_init(a); fmpz_init(b); fmpz_init(n); prec = 2 + n_randint(state, 300); fmpz_randtest_unsigned(n, state, 1 + n_randint(state, 100)); fmpz_randtest_unsigned(a, state, 1 + n_randint(state, 100)); fmpz_add_ui(b, a, n_randint(state, 100)); arb_bell_sum_bsplit(s1, n, a, b, NULL, prec); arb_bell_sum_taylor(s2, n, a, b, NULL, prec); if (!arb_overlaps(s1, s2) || (arb_rel_accuracy_bits(s1) < prec - 4) || (arb_rel_accuracy_bits(s2) < prec - 4)) { flint_printf("FAIL: overlap or accuracy\n\n"); flint_printf("prec = %wd\n\n", prec); flint_printf("n = "); fmpz_print(n); flint_printf("\n\n"); flint_printf("a = "); fmpz_print(a); flint_printf("\n\n"); flint_printf("b = "); fmpz_print(b); flint_printf("\n\n"); flint_printf("s1 = "); arb_printn(s1, 100, 0); flint_printf("\n\n"); flint_printf("s2 = "); arb_printn(s2, 100, 0); flint_printf("\n\n"); flint_abort(); } arb_clear(s1); arb_clear(s2); fmpz_clear(a); fmpz_clear(b); fmpz_clear(n); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("log_ui_from_prev...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { arb_t z1, z2, z3; ulong n1, n2; slong prec, accuracy; prec = 2 + n_randint(state, 3000); n1 = n_randint(state, 100000); n2 = n1 + 1 + n_randint(state, 1000); arb_init(z1); arb_init(z2); arb_init(z3); arb_log_ui(z1, n1, prec); arb_log_ui(z2, n2, prec); arb_log_ui_from_prev(z3, n2, z1, n1, prec); if (!arb_overlaps(z2, z3)) { flint_printf("FAIL: overlap\n\n"); flint_printf("prec = %wd, n1 = %wu, n2 = %wu\n\n", prec, n1, n2); flint_printf("z1 = "); arb_printd(z1, prec / 3.33); flint_printf("\n\n"); flint_printf("z2 = "); arb_printd(z2, prec / 3.33); flint_printf("\n\n"); flint_printf("z3 = "); arb_printd(z3, prec / 3.33); flint_printf("\n\n"); abort(); } accuracy = arb_rel_accuracy_bits(z3); if (accuracy < prec - 4) { flint_printf("FAIL: accuracy = %wd, prec = %wd\n\n", accuracy, prec); flint_printf("n1 = %wu, n2 = %wu\n\n", n1, n2); flint_printf("z3 = "); arb_printd(z3, prec / 3.33); flint_printf("\n\n"); abort(); } arb_clear(z1); arb_clear(z2); arb_clear(z3); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { long iter; flint_rand_t state; printf("const_log10...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 250; iter++) { arb_t r; mpfr_t s; long accuracy, prec; prec = 2 + n_randint(state, 1 << n_randint(state, 16)); arb_init(r); mpfr_init2(s, prec + 1000); arb_const_log10(r, prec); mpfr_set_ui(s, 10, MPFR_RNDN); mpfr_log(s, s, MPFR_RNDN); if (!arb_contains_mpfr(r, s)) { printf("FAIL: containment\n\n"); printf("prec = %ld\n", prec); printf("r = "); arb_printd(r, prec / 3.33); printf("\n\n"); abort(); } accuracy = arb_rel_accuracy_bits(r); if (accuracy < prec - 4) { printf("FAIL: poor accuracy\n\n"); printf("prec = %ld\n", prec); printf("r = "); arb_printd(r, prec / 3.33); printf("\n\n"); abort(); } arb_clear(r); mpfr_clear(s); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("zeta_ui_bernoulli...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 1000; iter++) { arb_t r; ulong n; mpfr_t s; slong prec, accuracy; prec = 2 + n_randint(state, 1 << n_randint(state, 14)); arb_init(r); mpfr_init2(s, prec + 100); do { n = n_randint(state, 1 << n_randint(state, 10)); } while (n % 2 || n == 0); arb_zeta_ui_bernoulli(r, n, prec); mpfr_zeta_ui(s, (unsigned long) FLINT_MIN(n, ULONG_MAX), MPFR_RNDN); if (!arb_contains_mpfr(r, s)) { flint_printf("FAIL: containment\n\n"); flint_printf("n = %wu\n\n", n); flint_printf("r = "); arb_printd(r, prec / 3.33); flint_printf("\n\n"); flint_printf("s = "); mpfr_printf("%.275Rf\n", s); flint_printf("\n\n"); abort(); } accuracy = arb_rel_accuracy_bits(r); if (accuracy < prec - 4) { flint_printf("FAIL: accuracy = %wd, prec = %wd\n\n", accuracy, prec); flint_printf("r = "); arb_printd(r, prec / 3.33); flint_printf("\n\n"); abort(); } arb_clear(r); mpfr_clear(s); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("zeta_ui_euler_product...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { arb_t r; ulong n; mpfr_t s; slong prec, accuracy; do { n = n_randint(state, 1 << n_randint(state, 10)); } while (n < 6); prec = 2 + n_randint(state, n * FLINT_BIT_COUNT(n)); arb_init(r); mpfr_init2(s, prec + 100); arb_zeta_ui_euler_product(r, n, prec); mpfr_zeta_ui(s, n, MPFR_RNDN); if (!arb_contains_mpfr(r, s)) { flint_printf("FAIL: containment\n\n"); flint_printf("n = %wu\n\n", n); flint_printf("r = "); arb_printd(r, prec / 3.33); flint_printf("\n\n"); flint_printf("s = "); mpfr_printf("%.275Rf\n", s); flint_printf("\n\n"); flint_abort(); } accuracy = arb_rel_accuracy_bits(r); if (accuracy < prec - 4) { flint_printf("FAIL: accuracy = %wd, prec = %wd\n\n", accuracy, prec); flint_printf("n = %wu\n\n", n); flint_printf("r = "); arb_printd(r, prec / 3.33); flint_printf("\n\n"); flint_abort(); } arb_clear(r); mpfr_clear(s); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { long iter; flint_rand_t state; printf("zeta_ui_borwein_bsplit...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 1000; iter++) { arb_t r; ulong n; mpfr_t s; long prec, accuracy; prec = 2 + n_randint(state, 1 << n_randint(state, 14)); arb_init(r); mpfr_init2(s, prec + 100); do { n = n_randint(state, 1 << n_randint(state, 10)); } while (n == 1); arb_zeta_ui_borwein_bsplit(r, n, prec); mpfr_zeta_ui(s, n, MPFR_RNDN); if (!arb_contains_mpfr(r, s)) { printf("FAIL: containment\n\n"); printf("n = %lu\n\n", n); printf("r = "); arb_printd(r, prec / 3.33); printf("\n\n"); printf("s = "); mpfr_printf("%.275Rf\n", s); printf("\n\n"); abort(); } accuracy = arb_rel_accuracy_bits(r); if (accuracy < prec - 4) { printf("FAIL: accuracy = %ld, prec = %ld\n\n", accuracy, prec); printf("r = "); arb_printd(r, prec / 3.33); printf("\n\n"); abort(); } arb_clear(r); mpfr_clear(s); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int arb_calc_refine_root_newton(arb_t r, arb_calc_func_t func, void * param, const arb_t start, const arb_t conv_region, const arf_t conv_factor, slong eval_extra_prec, slong prec) { slong precs[FLINT_BITS]; slong i, iters, wp, padding, start_prec; int result; start_prec = arb_rel_accuracy_bits(start); if (arb_calc_verbose) flint_printf("newton initial accuracy: %wd\n", start_prec); padding = arf_abs_bound_lt_2exp_si(conv_factor); padding = FLINT_MIN(padding, prec) + 5; padding = FLINT_MAX(0, padding); precs[0] = prec + padding; iters = 1; while ((iters < FLINT_BITS) && (precs[iters-1] + padding > 2*start_prec)) { precs[iters] = (precs[iters-1] / 2) + padding; iters++; if (iters == FLINT_BITS) { return ARB_CALC_IMPRECISE_INPUT; } } arb_set(r, start); for (i = iters - 1; i >= 0; i--) { wp = precs[i] + eval_extra_prec; if (arb_calc_verbose) flint_printf("newton step: wp = %wd + %wd = %wd\n", precs[i], eval_extra_prec, wp); if ((result = arb_calc_newton_step(r, func, param, r, conv_region, conv_factor, wp)) != ARB_CALC_SUCCESS) { return result; } } return ARB_CALC_SUCCESS; }
void _arb_poly_newton_refine_root(arb_t r, arb_srcptr poly, slong len, const arb_t start, const arb_t convergence_interval, const arf_t convergence_factor, slong eval_extra_prec, slong prec) { slong precs[FLINT_BITS]; slong i, iters, wp, padding, start_prec; start_prec = arb_rel_accuracy_bits(start); padding = 5 + _arf_mag(convergence_factor); precs[0] = prec + padding; iters = 1; while ((iters < FLINT_BITS) && (precs[iters-1] + padding > 2*start_prec)) { precs[iters] = (precs[iters-1] / 2) + padding; iters++; if (iters == FLINT_BITS) { flint_printf("newton_refine_root: initial value too imprecise\n"); abort(); } } arb_set(r, start); for (i = iters - 1; i >= 0; i--) { wp = precs[i] + eval_extra_prec; if (!_arb_poly_newton_step(r, poly, len, r, convergence_interval, convergence_factor, wp)) { flint_printf("warning: newton_refine_root: improvement failed\n"); break; } } }
int renf_elem_sgn(renf_elem_t a, renf_t nf) { slong prec; slong cond; if (nf_elem_is_rational(a->elem, nf->nf)) { if (nf->nf->flag & NF_LINEAR) return fmpz_sgn(LNF_ELEM_NUMREF(a->elem)); else if (nf->nf->flag & NF_QUADRATIC) return fmpz_sgn(QNF_ELEM_NUMREF(a->elem)); else if (NF_ELEM(a->elem)->length == 0) return 0; else return fmpz_sgn(NF_ELEM_NUMREF(a->elem)); } if (!arb_contains_zero(a->emb)) return arf_sgn(arb_midref(a->emb)); renf_elem_relative_condition_number_2exp(&cond, a, nf); prec = FLINT_MAX(nf->prec, arb_rel_accuracy_bits(nf->emb)); renf_elem_set_evaluation(a, nf, prec + cond); do { if (!arb_contains_zero(a->emb)) return arf_sgn(arb_midref(a->emb)); prec *= 2; renf_refine_embedding(nf, prec); renf_elem_set_evaluation(a, nf, prec + cond); } while(1); /* we should not get here */ abort(); return -3; }
int main() { slong iter; flint_rand_t state; flint_printf("gamma_fmpq...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { arb_t r, s; fmpq_t q; slong accuracy, prec, pp, qq; prec = 2 + n_randint(state, 1 << n_randint(state, 12)); prec += 20; arb_init(r); arb_init(s); fmpq_init(q); pp = -100 + n_randint(state, 10000); qq = 1 + n_randint(state, 20); fmpq_set_si(q, pp, qq); arb_gamma_fmpq(r, q, prec); arb_set_fmpq(s, q, prec); arb_gamma(s, s, prec); if (!arb_overlaps(r, s)) { flint_printf("FAIL: containment\n\n"); flint_printf("prec = %wd\n", prec); flint_printf("q = "); fmpq_print(q); flint_printf("\n\n"); flint_printf("r = "); arb_printd(r, prec / 3.33); flint_printf("\n\n"); flint_printf("s = "); arb_printd(s, prec / 3.33); flint_printf("\n\n"); abort(); } if (!(fmpz_is_one(fmpq_denref(q)) && fmpz_sgn(fmpq_numref(q)) <= 0) && FLINT_ABS(pp / qq) < 10) { accuracy = arb_rel_accuracy_bits(r); if (accuracy < prec - 6) { flint_printf("FAIL: poor accuracy\n\n"); flint_printf("prec = %wd\n", prec); flint_printf("q = "); fmpq_print(q); flint_printf("\n\n"); flint_printf("r = "); arb_printd(r, prec / 3.33); flint_printf("\n\n"); abort(); } } arb_clear(r); arb_clear(s); fmpq_clear(q); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("cos_pi_fmpq_algebraic...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { arb_t c1, c2; ulong p, q, g; slong prec; prec = 2 + n_randint(state, 5000); q = 1 + n_randint(state, 500); p = n_randint(state, q / 2 + 1); g = n_gcd(q, p); q /= g; p /= g; arb_init(c1); arb_init(c2); _arb_cos_pi_fmpq_algebraic(c1, p, q, prec); arb_const_pi(c2, prec); arb_mul_ui(c2, c2, p, prec); arb_div_ui(c2, c2, q, prec); arb_cos(c2, c2, prec); if (!arb_overlaps(c1, c2)) { flint_printf("FAIL: overlap\n\n"); flint_printf("p/q = %wu/%wu", p, q); flint_printf("\n\n"); flint_printf("c1 = "); arb_printd(c1, 15); flint_printf("\n\n"); flint_printf("c2 = "); arb_printd(c2, 15); flint_printf("\n\n"); abort(); } if (arb_rel_accuracy_bits(c1) < prec - 2) { flint_printf("FAIL: accuracy\n\n"); flint_printf("p/q = %wu/%wu", p, q); flint_printf("\n\n"); flint_printf("prec=%wd eff=%wd\n", prec, arb_rel_accuracy_bits(c1)); flint_printf("c1 = "); arb_printd(c1, 15); flint_printf("\n\n"); flint_printf("c2 = "); arb_printd(c2, 15); flint_printf("\n\n"); abort(); } arb_clear(c1); arb_clear(c2); } 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() { slong iter; flint_rand_t state; flint_printf("euler_product_real_ui...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 3000 * arb_test_multiplier(); iter++) { arb_t res1, res2; ulong s; slong prec1, prec2, accuracy; int choice, reciprocal1, reciprocal2; if (iter % 10 == 0) { s = n_randtest(state); prec1 = 2 + n_randint(state, 300); prec2 = 2 + n_randint(state, 300); } else { s = 6 + n_randint(state, 1 << n_randint(state, 12)); prec1 = 2 + n_randint(state, 12 * s); prec2 = 2 + n_randint(state, 12 * s); } if (n_randint(state, 30) == 0) prec1 = 2 + n_randint(state, 4000); choice = n_randint(state, 7); reciprocal1 = n_randint(state, 2); reciprocal2 = n_randint(state, 2); arb_init(res1); arb_init(res2); arb_randtest(res1, state, 200, 100); _acb_dirichlet_euler_product_real_ui(res1, s, chi[choice] + 1, chi[choice][0], reciprocal1, prec1); _acb_dirichlet_euler_product_real_ui(res2, s, chi[choice] + 1, chi[choice][0], reciprocal2, prec2); if (reciprocal1 != reciprocal2) arb_inv(res2, res2, prec2); if (!arb_overlaps(res1, res2)) { flint_printf("FAIL: overlap\n\n"); flint_printf("s = %wu\n\n", s); flint_printf("chi: %d\n", choice); flint_printf("res1 = "); arb_printd(res1, prec1 / 3.33); flint_printf("\n\n"); flint_printf("res2 = "); arb_printd(res2, prec2 / 3.33); flint_printf("\n\n"); abort(); } if (s >= 6 && prec1 < 2 * s * log(s)) { accuracy = arb_rel_accuracy_bits(res1); if (accuracy < prec1 - 4) { flint_printf("FAIL: accuracy = %wd, prec = %wd\n\n", accuracy, prec1); flint_printf("res1 = "); arb_printd(res1, prec1 / 3.33); flint_printf("\n\n"); abort(); } } if (s == 10) { arf_set_d(arb_midref(res2), L10[choice]); mag_set_d(arb_radref(res2), 1e-15); if (reciprocal1) arb_inv(res2, res2, 53); if (!arb_overlaps(res1, res2)) { flint_printf("FAIL: overlap (2)\n\n"); flint_printf("s = %wu\n\n", s); flint_printf("chi: %d\n", choice); flint_printf("res1 = "); arb_printd(res1, prec1 / 3.33); flint_printf("\n\n"); flint_printf("res2 = "); arb_printd(res2, prec2 / 3.33); flint_printf("\n\n"); abort(); } } arb_clear(res1); arb_clear(res2); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int renf_elem_cmp_fmpq(renf_elem_t a, const fmpq_t b, renf_t nf) { int s; slong prec, cond; arb_t diffball; renf_elem_t diffnf; if (fmpq_is_zero(b)) return renf_elem_sgn(a, nf); if (nf_elem_is_rational(a->elem, nf->nf)) { if (nf->nf->flag & NF_LINEAR) return _fmpq_cmp(LNF_ELEM_NUMREF(a->elem), LNF_ELEM_DENREF(a->elem), fmpq_numref(b), fmpq_denref(b)); else if (nf->nf->flag & NF_QUADRATIC) return _fmpq_cmp(QNF_ELEM_NUMREF(a->elem), QNF_ELEM_DENREF(a->elem), fmpq_numref(b), fmpq_denref(b)); else return _fmpq_cmp(NF_ELEM_NUMREF(a->elem), NF_ELEM_DENREF(a->elem), fmpq_numref(b), fmpq_denref(b)); } arb_init(diffball); arb_set_fmpq(diffball, b, nf->prec); arb_sub(diffball, a->emb, diffball, nf->prec); if (!arb_contains_zero(diffball)) { s = arf_sgn(arb_midref(diffball)); arb_clear(diffball); return s; } renf_elem_relative_condition_number_2exp(&cond, a, nf); prec = FLINT_MAX(nf->prec, arb_rel_accuracy_bits(nf->emb)); renf_elem_set_evaluation(a, nf, prec + cond); arb_set_fmpq(diffball, b, prec); arb_sub(diffball, a->emb, diffball, prec); if (!arb_contains_zero(diffball)) { s = arf_sgn(arb_midref(diffball)); arb_clear(diffball); return s; } arb_clear(diffball); renf_elem_init(diffnf, nf); renf_elem_set(diffnf, a, nf); renf_elem_sub_fmpq(diffnf, diffnf, b, nf); s = renf_elem_sgn(diffnf, nf); renf_elem_clear(diffnf, nf); return s; }
int main() { slong iter; flint_rand_t state; flint_printf("central_bin_ui...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++) { arb_t b1, b2, t; ulong n; slong prec1, prec2, acc1; n = n_randtest(state); prec1 = 2 + n_randint(state, 1000); prec2 = prec1 + 30; arb_init(b1); arb_init(b2); arb_init(t); arb_hypgeom_central_bin_ui(b1, n, prec1); arb_set_ui(t, n); arb_add_ui(t, t, n, prec2); arb_add_ui(t, t, 1, prec2); arb_gamma(t, t, prec2); arb_set_ui(b2, n); arb_add_ui(b2, b2, 1, prec2); arb_rgamma(b2, b2, prec2); arb_mul(b2, b2, b2, prec2); arb_mul(b2, b2, t, prec2); if (!arb_overlaps(b1, b2)) { flint_printf("FAIL: overlap\n\n"); flint_printf("n = %wu\n\n", n); flint_printf("b1 = "); arb_printn(b1, 50, 0); flint_printf("\n\n"); flint_printf("b2 = "); arb_printn(b2, 50, 0); flint_printf("\n\n"); flint_abort(); } acc1 = arb_rel_accuracy_bits(b1); if (acc1 < prec1 - 2) { flint_printf("FAIL: poor accuracy\n\n"); flint_printf("prec1 = %wd, acc1 = %wd\n", prec1, acc1); flint_printf("b1 = "); arb_printn(b1, prec1 / 3.33, 0); flint_printf("\n\n"); flint_printf("b2 = "); arb_printn(b2, prec2 / 3.33, 0); flint_printf("\n\n"); flint_abort(); } arb_clear(b1); arb_clear(b2); arb_clear(t); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
void _arb_bell_sum_taylor(arb_t res, const fmpz_t n, const fmpz_t a, const fmpz_t b, const fmpz_t mmag, long tol) { fmpz_t m, r, R, tmp; mag_t B, C, D, bound; arb_t t, u; long wp, k, N; if (_fmpz_sub_small(b, a) < 5) { arb_bell_sum_bsplit(res, n, a, b, mmag, tol); return; } fmpz_init(m); fmpz_init(r); fmpz_init(R); fmpz_init(tmp); /* r = max(m - a, b - m) */ /* m = a + (b - a) / 2 */ fmpz_sub(r, b, a); fmpz_cdiv_q_2exp(r, r, 1); fmpz_add(m, a, r); fmpz_mul_2exp(R, r, RADIUS_BITS); mag_init(B); mag_init(C); mag_init(D); mag_init(bound); arb_init(t); arb_init(u); if (fmpz_cmp(R, m) >= 0) { mag_inf(C); mag_inf(D); } else { /* C = exp(R * |F'(m)| + (1/2) R^2 * (n/(m-R)^2 + 1/(m-R))) */ /* C = exp(R * (|F'(m)| + (1/2) R * (n/(m-R) + 1)/(m-R))) */ /* D = (1/2) R * (n/(m-R) + 1)/(m-R) */ fmpz_sub(tmp, m, R); mag_set_fmpz(D, n); mag_div_fmpz(D, D, tmp); mag_one(C); mag_add(D, D, C); mag_div_fmpz(D, D, tmp); mag_mul_fmpz(D, D, R); mag_mul_2exp_si(D, D, -1); /* C = |F'(m)| */ wp = 20 + 1.05 * fmpz_bits(n); arb_set_fmpz(t, n); arb_div_fmpz(t, t, m, wp); fmpz_add_ui(tmp, m, 1); arb_set_fmpz(u, tmp); arb_digamma(u, u, wp); arb_sub(t, t, u, wp); arb_get_mag(C, t); /* C = exp(R * (C + D)) */ mag_add(C, C, D); mag_mul_fmpz(C, C, R); mag_exp(C, C); } if (mag_cmp_2exp_si(C, tol / 4 + 2) > 0) { _arb_bell_sum_taylor(res, n, a, m, mmag, tol); _arb_bell_sum_taylor(t, n, m, b, mmag, tol); arb_add(res, res, t, 2 * tol); } else { arb_ptr mx, ser1, ser2, ser3; /* D = T(m) */ wp = 20 + 1.05 * fmpz_bits(n); arb_set_fmpz(t, m); arb_pow_fmpz(t, t, n, wp); fmpz_add_ui(tmp, m, 1); arb_gamma_fmpz(u, tmp, wp); arb_div(t, t, u, wp); arb_get_mag(D, t); /* error bound: (b-a) * C * D * B^N / (1 - B), B = r/R */ /* ((b-a) * C * D * 2) * 2^(-N*RADIUS_BITS) */ /* ((b-a) * C * D * 2) */ mag_mul(bound, C, D); mag_mul_2exp_si(bound, bound, 1); fmpz_sub(tmp, b, a); mag_mul_fmpz(bound, bound, tmp); /* N = (tol + log2((b-a)*C*D*2) - mmag) / RADIUS_BITS */ if (mmag == NULL) { /* estimate D ~= 2^mmag */ fmpz_add_ui(tmp, MAG_EXPREF(C), tol); fmpz_cdiv_q_ui(tmp, tmp, RADIUS_BITS); } else { fmpz_sub(tmp, MAG_EXPREF(bound), mmag); fmpz_add_ui(tmp, tmp, tol); fmpz_cdiv_q_ui(tmp, tmp, RADIUS_BITS); } if (fmpz_cmp_ui(tmp, 5 * tol / 4) > 0) N = 5 * tol / 4; else if (fmpz_cmp_ui(tmp, 2) < 0) N = 2; else N = fmpz_get_ui(tmp); /* multiply by 2^(-N*RADIUS_BITS) */ mag_mul_2exp_si(bound, bound, -N * RADIUS_BITS); mx = _arb_vec_init(2); ser1 = _arb_vec_init(N); ser2 = _arb_vec_init(N); ser3 = _arb_vec_init(N); /* estimate (this should work for moderate n and tol) */ wp = 1.1 * tol + 1.05 * fmpz_bits(n) + 5; /* increase precision until convergence */ while (1) { /* (m+x)^n / gamma(m+1+x) */ arb_set_fmpz(mx, m); arb_one(mx + 1); _arb_poly_log_series(ser1, mx, 2, N, wp); for (k = 0; k < N; k++) arb_mul_fmpz(ser1 + k, ser1 + k, n, wp); arb_add_ui(mx, mx, 1, wp); _arb_poly_lgamma_series(ser2, mx, 2, N, wp); _arb_vec_sub(ser1, ser1, ser2, N, wp); _arb_poly_exp_series(ser3, ser1, N, N, wp); /* t = a - m, u = b - m */ arb_set_fmpz(t, a); arb_sub_fmpz(t, t, m, wp); arb_set_fmpz(u, b); arb_sub_fmpz(u, u, m, wp); arb_power_sum_vec(ser1, t, u, N, wp); arb_zero(res); for (k = 0; k < N; k++) arb_addmul(res, ser3 + k, ser1 + k, wp); if (mmag != NULL) { if (_fmpz_sub_small(MAG_EXPREF(arb_radref(res)), mmag) <= -tol) break; } else { if (arb_rel_accuracy_bits(res) >= tol) break; } wp = 2 * wp; } /* add the series truncation bound */ arb_add_error_mag(res, bound); _arb_vec_clear(mx, 2); _arb_vec_clear(ser1, N); _arb_vec_clear(ser2, N); _arb_vec_clear(ser3, N); } mag_clear(B); mag_clear(C); mag_clear(D); mag_clear(bound); arb_clear(t); arb_clear(u); fmpz_clear(m); fmpz_clear(r); fmpz_clear(R); fmpz_clear(tmp); }
int main() { slong iter; flint_rand_t state; flint_printf("atan_arf_bb...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 5000; iter++) { arb_t x, y, z; slong prec, prec2; arb_init(x); arb_init(y); arb_init(z); prec = 2 + n_randint(state, 8000); arb_randtest(x, state, 1 + n_randint(state, 8000), 3); mag_zero(arb_radref(x)); if (n_randint(state, 2)) arb_mul_2exp_si(x, x, 1 + n_randint(state, 40)); else arb_mul_2exp_si(x, x, -n_randint(state, 1.5 * prec)); if (!arf_is_special(arb_midref(x))) prec2 = prec + 100 + 2 * (-ARF_EXP(arb_midref(x))); else prec2 = prec + 100; arb_atan_arf_via_mpfr(y, arb_midref(x), prec2); arb_atan_arf_bb(z, arb_midref(x), prec); if (!arb_contains(z, y)) { flint_printf("FAIL: containment\n\n"); flint_printf("prec = %wd\n\n", prec); flint_printf("x = "); arb_printd(x, 50); flint_printf("\n\n"); flint_printf("y = "); arb_printd(y, 50); flint_printf("\n\n"); flint_printf("z = "); arb_printd(z, 50); flint_printf("\n\n"); abort(); } if (arb_rel_accuracy_bits(z) < prec - 2) { flint_printf("FAIL: poor accuracy\n\n"); flint_printf("prec = %wd, acc = %wd\n\n", prec, arb_rel_accuracy_bits(z)); flint_printf("x = "); arb_printd(x, 50); flint_printf("\n\n"); flint_printf("y = "); arb_printd(y, 50); flint_printf("\n\n"); flint_printf("z = "); arb_printd(z, 50); flint_printf("\n\n"); abort(); } arb_atan_arf_bb(x, arb_midref(x), prec); if (!arb_overlaps(x, z)) { flint_printf("FAIL: aliasing\n\n"); abort(); } arb_clear(x); arb_clear(y); arb_clear(z); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("exp_arf_bb...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 5000 * arb_test_multiplier(); iter++) { arb_t x, y, z; slong prec = 2 + n_randint(state, 8000); arb_init(x); arb_init(y); arb_init(z); arb_randtest(x, state, 1 + n_randint(state, 8000), 3); mag_zero(arb_radref(x)); if (n_randint(state, 2)) { if ((FLINT_BITS == 64) && (sizeof(mpfr_exp_t) >= sizeof(slong))) arb_mul_2exp_si(x, x, 1 + n_randint(state, 40)); else arb_mul_2exp_si(x, x, 1 + n_randint(state, 20)); } else { arb_mul_2exp_si(x, x, -n_randint(state, 1.5 * prec)); } arb_exp_arf_via_mpfr(y, arb_midref(x), prec + 100); arb_exp_arf_bb(z, arb_midref(x), prec, 0); if (!arb_contains(z, y)) { flint_printf("FAIL: containment\n\n"); flint_printf("prec = %wd\n\n", prec); flint_printf("x = "); arb_printd(x, 50); flint_printf("\n\n"); flint_printf("y = "); arb_printd(y, 50); flint_printf("\n\n"); flint_printf("z = "); arb_printd(z, 50); flint_printf("\n\n"); flint_abort(); } if (arb_rel_accuracy_bits(z) < prec - 2) { flint_printf("FAIL: poor accuracy\n\n"); flint_printf("prec = %wd, acc = %wd\n\n", prec, arb_rel_accuracy_bits(z)); flint_printf("x = "); arb_print(x); flint_printf("\n\n"); flint_printf("y = "); arb_print(y); flint_printf("\n\n"); flint_printf("z = "); arb_print(z); flint_printf("\n\n"); flint_abort(); } arb_exp_arf_bb(x, arb_midref(x), prec, 0); if (!arb_overlaps(x, z)) { flint_printf("FAIL: aliasing\n\n"); flint_abort(); } arb_clear(x); arb_clear(y); arb_clear(z); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("rel_accuracy_bits...."); fflush(stdout); flint_randinit(state); /* test aliasing of c and a */ for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { arb_t x; acb_t z; slong a1, a2; arb_init(x); acb_init(z); arb_randtest_special(x, state, 1 + n_randint(state, 200), 1 + n_randint(state, 200)); acb_set_arb(z, x); a1 = arb_rel_accuracy_bits(x); a2 = acb_rel_accuracy_bits(z); if (a1 != a2) { flint_printf("FAIL: acb != arb\n\n"); flint_printf("x = "); arb_print(x); flint_printf("\n\n"); flint_printf("z = "); acb_print(z); flint_printf("\n\n"); flint_printf("a1 = %wd, a2 = %wd\n\n", a1, a2); abort(); } acb_randtest_special(z, state, 1 + n_randint(state, 200), 1 + n_randint(state, 200)); a1 = acb_rel_accuracy_bits(z); if (n_randint(state, 2)) arf_swap(arb_midref(acb_realref(z)), arb_midref(acb_imagref(z))); if (n_randint(state, 2)) mag_swap(arb_radref(acb_realref(z)), arb_radref(acb_imagref(z))); a2 = acb_rel_accuracy_bits(z); if (a1 != a2) { flint_printf("FAIL: swapping\n\n"); flint_printf("z = "); acb_print(z); flint_printf("\n\n"); flint_printf("a1 = %wd, a2 = %wd\n\n", a1, a2); abort(); } acb_randtest_special(z, state, 1 + n_randint(state, 200), 1 + n_randint(state, 200)); if (arf_cmpabs(arb_midref(acb_realref(z)), arb_midref(acb_imagref(z))) >= 0) arf_set(arb_midref(x), arb_midref(acb_realref(z))); else arf_set(arb_midref(x), arb_midref(acb_imagref(z))); if (mag_cmp(arb_radref(acb_realref(z)), arb_radref(acb_imagref(z))) >= 0) mag_set(arb_radref(x), arb_radref(acb_realref(z))); else mag_set(arb_radref(x), arb_radref(acb_imagref(z))); a1 = acb_rel_accuracy_bits(z); a2 = arb_rel_accuracy_bits(x); if (a1 != a2) { flint_printf("FAIL: acb != arb (2)\n\n"); flint_printf("x = "); arb_print(x); flint_printf("\n\n"); flint_printf("z = "); acb_print(z); flint_printf("\n\n"); flint_printf("a1 = %wd, a2 = %wd\n\n", a1, a2); abort(); } arb_clear(x); acb_clear(z); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("zeta_ui_vec_borwein...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 100; iter++) { arb_ptr r; ulong n; slong i, num, step; mpfr_t s; slong prec, accuracy; prec = 2 + n_randint(state, 1 << n_randint(state, 13)); num = 1 + n_randint(state, 20); step = 1 + n_randint(state, 5); r = _arb_vec_init(num); mpfr_init2(s, prec + 100); do { n = n_randint(state, 1 << n_randint(state, 10)); } while (n < 2); arb_zeta_ui_vec_borwein(r, n, num, step, prec); for (i = 0; i < num; i++) { mpfr_zeta_ui(s, (unsigned long) FLINT_MIN(n + i * step, ULONG_MAX), MPFR_RNDN); if (!arb_contains_mpfr(r + i, s)) { flint_printf("FAIL: containment\n\n"); flint_printf("n = %wu\n\n", n + i * step); flint_printf("r = "); arb_printd(r + i, prec / 3.33); flint_printf("\n\n"); flint_printf("s = "); mpfr_printf("%.275Rf\n", s); flint_printf("\n\n"); abort(); } accuracy = arb_rel_accuracy_bits(r + i); if (accuracy < prec - 4) { flint_printf("FAIL: accuracy = %wd, prec = %wd\n\n", accuracy, prec); flint_printf("n = %wu\n\n", n + i * step); flint_printf("r = "); arb_printd(r + i, prec / 3.33); flint_printf("\n\n"); abort(); } } _arb_vec_clear(r, num); mpfr_clear(s); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
void acb_sqrt(acb_t y, const acb_t x, slong prec) { arb_t r, t, u; slong wp; #define a acb_realref(x) #define b acb_imagref(x) #define c acb_realref(y) #define d acb_imagref(y) if (arb_is_zero(b)) { if (arb_is_nonnegative(a)) { arb_sqrt(c, a, prec); arb_zero(d); return; } else if (arb_is_nonpositive(a)) { arb_neg(d, a); arb_sqrt(d, d, prec); arb_zero(c); return; } } if (arb_is_zero(a)) { if (arb_is_nonnegative(b)) { arb_mul_2exp_si(c, b, -1); arb_sqrt(c, c, prec); arb_set(d, c); return; } else if (arb_is_nonpositive(b)) { arb_mul_2exp_si(c, b, -1); arb_neg(c, c); arb_sqrt(c, c, prec); arb_neg(d, c); return; } } wp = prec + 4; arb_init(r); arb_init(t); arb_init(u); acb_abs(r, x, wp); arb_add(t, r, a, wp); if (arb_rel_accuracy_bits(t) > 8) { /* sqrt(a+bi) = sqrt((r+a)/2) + b/sqrt(2*(r+a))*i, r = |a+bi| */ arb_mul_2exp_si(u, t, 1); arb_sqrt(u, u, wp); arb_div(d, b, u, prec); arb_set_round(c, u, prec); arb_mul_2exp_si(c, c, -1); } else { /* sqrt(a+bi) = sqrt((r+a)/2) + (b/|b|)*sqrt((r-a)/2)*i (sign) */ arb_mul_2exp_si(t, t, -1); arb_sub(u, r, a, wp); arb_mul_2exp_si(u, u, -1); arb_sqrtpos(c, t, prec); if (arb_is_nonnegative(b)) { arb_sqrtpos(d, u, prec); } else if (arb_is_nonpositive(b)) { arb_sqrtpos(d, u, prec); arb_neg(d, d); } else { arb_sqrtpos(t, u, wp); arb_neg(u, t); arb_union(d, t, u, prec); } } arb_clear(r); arb_clear(t); arb_clear(u); #undef a #undef b #undef c #undef d }
int main() { long iter; flint_rand_t state; printf("atan_arf...."); fflush(stdout); flint_randinit(state); /* self-consistency test */ for (iter = 0; iter < 5000; iter++) { arf_t x; arb_t y1, y2; long prec1, prec2, acc1, acc2; prec1 = 2 + n_randint(state, 9000); prec2 = 2 + n_randint(state, 9000); arf_init(x); arb_init(y1); arb_init(y2); arf_randtest_special(x, state, 1 + n_randint(state, 9000), 200); arb_randtest_special(y1, state, 1 + n_randint(state, 9000), 200); arb_randtest_special(y2, state, 1 + n_randint(state, 9000), 200); if (n_randint(state, 2)) arf_add_ui(x, x, 1, 2 + n_randint(state, 9000), ARF_RND_DOWN); arb_atan_arf(y1, x, prec1); arb_atan_arf(y2, x, prec2); if (!arb_overlaps(y1, y2)) { printf("FAIL: overlap\n\n"); printf("prec1 = %ld, prec2 = %ld\n\n", prec1, prec2); printf("x = "); arf_print(x); printf("\n\n"); printf("y1 = "); arb_print(y1); printf("\n\n"); printf("y2 = "); arb_print(y2); printf("\n\n"); abort(); } acc1 = arb_rel_accuracy_bits(y1); acc2 = arb_rel_accuracy_bits(y2); if (!arf_is_nan(x)) { if (acc1 < prec1 - 2 || acc2 < prec2 - 2) { printf("FAIL: accuracy\n\n"); printf("prec1 = %ld, prec2 = %ld\n\n", prec1, prec2); printf("acc1 = %ld, acc2 = %ld\n\n", acc1, acc2); printf("x = "); arf_printd(x, 50); printf("\n\n"); printf("y1 = "); arb_printd(y1, 50); printf("\n\n"); printf("y2 = "); arb_printd(y2, 50); printf("\n\n"); abort(); } } arf_clear(x); arb_clear(y1); arb_clear(y2); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main() { long iter; flint_rand_t state; printf("const_glaisher...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 250; iter++) { arb_t r, s, t; fmpz_t v; long accuracy, prec; prec = 2 + n_randint(state, 2000); arb_init(r); arb_init(s); arb_init(t); fmpz_init(v); arb_const_glaisher(r, prec); arb_const_glaisher(s, prec + 100); if (!arb_overlaps(r, s)) { printf("FAIL: containment\n\n"); printf("prec = %ld\n", prec); printf("r = "); arb_printd(r, prec / 3.33); printf("\n\n"); abort(); } accuracy = arb_rel_accuracy_bits(r); if (accuracy < prec - 4) { printf("FAIL: poor accuracy\n\n"); printf("prec = %ld\n", prec); printf("r = "); arb_printd(r, prec / 3.33); printf("\n\n"); abort(); } if (n_randint(state, 30) == 0) { flint_cleanup(); } fmpz_set_str(v, "128242712910062263687534256886979172776768892732500", 10); arb_set_fmpz(t, v); mag_one(arb_radref(t)); fmpz_ui_pow_ui(v, 10, 50); arb_div_fmpz(t, t, v, 170); if (!arb_overlaps(r, t)) { printf("FAIL: reference value\n\n"); printf("prec = %ld\n", prec); printf("r = "); arb_printd(r, prec / 3.33); printf("\n\n"); abort(); } arb_clear(r); arb_clear(s); arb_clear(t); fmpz_clear(v); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("log_arf...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 5000 * arb_test_multiplier(); iter++) { arf_t x; arb_t y1, y2; slong prec1, prec2, acc1, acc2; prec1 = 2 + n_randint(state, 9000); prec2 = 2 + n_randint(state, 9000); arf_init(x); arb_init(y1); arb_init(y2); arf_randtest_special(x, state, 1 + n_randint(state, 9000), 200); arb_randtest_special(y1, state, 1 + n_randint(state, 9000), 200); arb_randtest_special(y2, state, 1 + n_randint(state, 9000), 200); if (n_randint(state, 2)) arf_add_ui(x, x, 1, 2 + n_randint(state, 9000), ARF_RND_DOWN); arb_log_arf(y1, x, prec1); arb_log_arf(y2, x, prec2); if (!arb_overlaps(y1, y2)) { flint_printf("FAIL: overlap\n\n"); flint_printf("prec1 = %wd, prec2 = %wd\n\n", prec1, prec2); flint_printf("x = "); arf_print(x); flint_printf("\n\n"); flint_printf("y1 = "); arb_print(y1); flint_printf("\n\n"); flint_printf("y2 = "); arb_print(y2); flint_printf("\n\n"); abort(); } acc1 = arb_rel_accuracy_bits(y1); acc2 = arb_rel_accuracy_bits(y2); if (arf_sgn(x) > 0) { if (acc1 < prec1 - 2 || acc2 < prec2 - 2) { flint_printf("FAIL: accuracy\n\n"); flint_printf("prec1 = %wd, prec2 = %wd\n\n", prec1, prec2); flint_printf("acc1 = %wd, acc2 = %wd\n\n", acc1, acc2); flint_printf("x = "); arf_print(x); flint_printf("\n\n"); flint_printf("y1 = "); arb_print(y1); flint_printf("\n\n"); flint_printf("y2 = "); arb_print(y2); flint_printf("\n\n"); abort(); } } arf_clear(x); arb_clear(y1); arb_clear(y2); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { long iter; flint_rand_t state; printf("div_2expm1_ui...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 100000; iter++) { arb_t a, b, c; ulong n; long prec, acc1, acc2; fmpz_t t; arb_init(a); arb_init(b); arb_init(c); fmpz_init(t); prec = 2 + n_randint(state, 10000); arb_randtest(a, state, 1 + n_randint(state, 10000), 10); if (n_randint(state, 2)) n = 1 + (n_randtest(state) % (10 * prec)); else n = n_randtest(state); arb_div_2expm1_ui(b, a, n, prec); arb_one(c); if (n >= (1UL << (FLINT_BITS-1))) { arb_mul_2exp_si(c, c, (1UL << (FLINT_BITS-2))); arb_mul_2exp_si(c, c, (1UL << (FLINT_BITS-2))); arb_mul_2exp_si(c, c, n - (1UL << (FLINT_BITS-1))); } else { arb_mul_2exp_si(c, c, n); } arb_sub_ui(c, c, 1, prec); arb_div(c, a, c, prec); acc1 = arb_rel_accuracy_bits(a); acc2 = arb_rel_accuracy_bits(b); if (!arb_overlaps(b, c)) { printf("FAIL: containment\n\n"); printf("n = %lu\n", n); printf("a = "); arb_print(a); printf("\n\n"); printf("b = "); arb_print(b); printf("\n\n"); printf("c = "); arb_print(c); printf("\n\n"); abort(); } if (n > 0 && (acc2 < FLINT_MIN(prec, acc1) - 10) && !(acc1 == -ARF_PREC_EXACT && acc2 == -ARF_PREC_EXACT)) { printf("FAIL: poor accuracy\n\n"); printf("prec=%ld, acc1=%ld, acc2=%ld\n\n", prec, acc1, acc2); printf("n = %lu\n\n", n); printf("a = "); arb_print(a); printf("\n\n"); printf("b = "); arb_print(b); printf("\n\n"); printf("c = "); arb_print(c); printf("\n\n"); abort(); } arb_clear(a); arb_clear(b); arb_clear(c); fmpz_clear(t); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("exp...."); fflush(stdout); flint_randinit(state); /* check large arguments + compare with exp_simple */ for (iter = 0; iter < 100000 *arb_test_multiplier(); iter++) { arb_t a, b, c, d; slong prec0, prec1, prec2, acc1, acc2; if (iter % 10 == 0) prec0 = 10000; else prec0 = 1000; prec1 = 2 + n_randint(state, prec0); prec2 = 2 + n_randint(state, prec0); arb_init(a); arb_init(b); arb_init(c); arb_init(d); arb_randtest_special(a, state, 1 + n_randint(state, prec0), 100); arb_randtest_special(b, state, 1 + n_randint(state, prec0), 100); arb_exp(b, a, prec1); arb_exp(c, a, prec2); arb_exp_simple(d, a, prec1); if (!arb_overlaps(b, c) || !arb_overlaps(b, d) || !arb_overlaps(c, d)) { flint_printf("FAIL: overlap\n\n"); flint_printf("a = "); arb_print(a); flint_printf("\n\n"); flint_printf("b = "); arb_print(b); flint_printf("\n\n"); flint_printf("c = "); arb_print(c); flint_printf("\n\n"); flint_printf("d = "); arb_print(d); flint_printf("\n\n"); flint_abort(); } /* compare accuracy with exp_simple */ acc1 = arb_rel_accuracy_bits(b); acc2 = arb_rel_accuracy_bits(d); if (acc2 > 0 && acc1 < acc2 - 1) { flint_printf("FAIL: accuracy\n\n"); flint_printf("prec1 = %wd, acc1 = %wd, acc2 = %wd\n\n", prec1, acc1, acc2); flint_printf("a = "); arb_printd(a, 50); flint_printf("\n\n"); flint_printf("b = "); arb_printd(b, 50); flint_printf("\n\n"); flint_printf("d = "); arb_printd(d, 50); flint_printf("\n\n"); flint_abort(); } arb_randtest_special(b, state, 1 + n_randint(state, prec0), 100); /* check exp(a)*exp(b) = exp(a+b) */ arb_exp(c, a, prec1); arb_exp(d, b, prec1); arb_mul(c, c, d, prec1); arb_add(d, a, b, prec1); arb_exp(d, d, prec1); if (!arb_overlaps(c, d)) { flint_printf("FAIL: functional equation\n\n"); flint_printf("a = "); arb_print(a); flint_printf("\n\n"); flint_printf("b = "); arb_print(b); flint_printf("\n\n"); flint_printf("c = "); arb_print(c); flint_printf("\n\n"); flint_printf("d = "); arb_print(d); flint_printf("\n\n"); flint_abort(); } arb_clear(a); arb_clear(b); arb_clear(c); arb_clear(d); } /* test union */ for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { arb_t a, b, c, d, e; slong prec0, prec1, prec2, prec3, prec4; if (iter % 10 == 0) prec0 = 10000; else prec0 = 1000; prec1 = 2 + n_randint(state, prec0); prec2 = 2 + n_randint(state, prec0); prec3 = 2 + n_randint(state, prec0); prec4 = 2 + n_randint(state, prec0); arb_init(a); arb_init(b); arb_init(c); arb_init(d); arb_init(e); arb_randtest_special(a, state, 1 + n_randint(state, prec0), 200); arb_randtest_special(b, state, 1 + n_randint(state, prec0), 200); arb_randtest_special(c, state, 1 + n_randint(state, prec0), 200); arb_randtest_special(d, state, 1 + n_randint(state, prec0), 200); arb_randtest_special(e, state, 1 + n_randint(state, prec0), 200); arb_exp(c, a, prec1); arb_exp(d, b, prec2); arb_union(e, a, b, prec3); arb_exp(e, e, prec4); if (!arb_overlaps(e, c) || !arb_overlaps(e, d)) { flint_printf("FAIL: union\n\n"); flint_printf("a = "); arb_printn(a, 1000, 0); flint_printf("\n\n"); flint_printf("b = "); arb_printn(b, 1000, 0); flint_printf("\n\n"); flint_printf("c = "); arb_printn(c, 1000, 0); flint_printf("\n\n"); flint_printf("d = "); arb_printn(d, 1000, 0); flint_printf("\n\n"); flint_printf("e = "); arb_printn(e, 1000, 0); flint_printf("\n\n"); flint_abort(); } arb_clear(a); arb_clear(b); arb_clear(c); arb_clear(d); arb_clear(e); } /* comparison with mpfr */ for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++) { arb_t a, b; fmpq_t q; mpfr_t t; slong prec0, prec; prec0 = 400; if (iter % 100 == 0) prec0 = 10000; prec = 2 + n_randint(state, prec0); arb_init(a); arb_init(b); fmpq_init(q); mpfr_init2(t, prec + 100); arb_randtest(a, state, 1 + n_randint(state, prec0), 4); arb_randtest(b, state, 1 + n_randint(state, prec0), 4); arb_get_rand_fmpq(q, state, a, 1 + n_randint(state, prec0)); fmpq_get_mpfr(t, q, MPFR_RNDN); mpfr_exp(t, t, MPFR_RNDN); arb_exp(b, a, prec); if (!arb_contains_mpfr(b, t)) { flint_printf("FAIL: containment\n\n"); flint_printf("iter = %wd, prec = %wd\n\n", iter, prec); flint_printf("a = "); arb_print(a); flint_printf("\n\n"); flint_printf("b = "); arb_print(b); flint_printf("\n\n"); flint_abort(); } arb_exp(a, a, prec); if (!arb_equal(a, b)) { flint_printf("FAIL: aliasing\n\n"); flint_printf("iter = %wd, prec = %wd\n\n", iter, prec); flint_printf("a = "); arb_print(a); flint_printf("\n\n"); flint_printf("b = "); arb_print(b); flint_printf("\n\n"); flint_abort(); } arb_clear(a); arb_clear(b); fmpq_clear(q); mpfr_clear(t); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }