int main() { long iter; flint_rand_t state; printf("submul_fmpz...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000; iter++) { arb_t a, b, c, d; fmpz_t x; long prec; arb_init(a); arb_init(b); arb_init(c); arb_init(d); fmpz_init(x); arb_randtest_special(a, state, 1 + n_randint(state, 2000), 100); arb_randtest_special(b, state, 1 + n_randint(state, 2000), 100); arb_randtest_special(c, state, 1 + n_randint(state, 2000), 100); fmpz_randtest(x, state, 1 + n_randint(state, 2000)); prec = 2 + n_randint(state, 2000); arb_set_fmpz(b, x); arb_set(d, c); arb_submul_fmpz(c, a, x, prec); arb_submul(d, a, b, prec); if (!arb_equal(c, d)) { printf("FAIL\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"); printf("d = "); arb_print(d); printf("\n\n"); abort(); } arb_clear(a); arb_clear(b); arb_clear(c); arb_clear(d); fmpz_clear(x); } /* aliasing */ for (iter = 0; iter < 10000; iter++) { arb_t a, b, c; fmpz_t x; long prec; arb_init(a); arb_init(b); arb_init(c); fmpz_init(x); arb_randtest_special(a, state, 1 + n_randint(state, 2000), 100); arb_randtest_special(b, state, 1 + n_randint(state, 2000), 100); arb_randtest_special(c, state, 1 + n_randint(state, 2000), 100); fmpz_randtest(x, state, 1 + n_randint(state, 2000)); prec = 2 + n_randint(state, 2000); arb_set_fmpz(b, x); arb_set(c, a); arb_submul_fmpz(c, a, x, prec); arb_submul_fmpz(a, a, x, prec); if (!arb_equal(a, c)) { printf("FAIL (aliasing)\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(x); } flint_randclear(state); flint_cleanup(); 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() { long iter; flint_rand_t state; printf("atan2...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 100000; iter++) { arb_t a, b, c; fmpq_t q, r; mpfr_t t, u; long prec = 2 + n_randint(state, 200); arb_init(a); arb_init(b); arb_init(c); fmpq_init(q); fmpq_init(r); mpfr_init2(t, prec + 100); mpfr_init2(u, prec + 100); arb_randtest(a, state, 1 + n_randint(state, 200), 3); arb_randtest(b, state, 1 + n_randint(state, 200), 3); arb_randtest(c, state, 1 + n_randint(state, 200), 3); arb_get_rand_fmpq(q, state, a, 1 + n_randint(state, 200)); arb_get_rand_fmpq(r, state, b, 1 + n_randint(state, 200)); fmpq_get_mpfr(t, q, MPFR_RNDN); fmpq_get_mpfr(u, r, MPFR_RNDN); mpfr_atan2(t, u, t, MPFR_RNDN); arb_atan2(c, b, a, prec); if (!arb_contains_mpfr(c, t)) { printf("FAIL: containment\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); fmpq_clear(q); fmpq_clear(r); mpfr_clear(t); mpfr_clear(u); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main() { long iter; flint_rand_t state; printf("union...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 100000; iter++) { arb_t x, y, z; long prec; int alias; arb_init(x); arb_init(y); arb_init(z); arb_randtest_special(x, state, 200, 10); arb_randtest_special(y, state, 200, 10); arb_randtest_special(z, state, 200, 10); prec = 2 + n_randint(state, 200); arb_union(z, x, y, prec); if (!arb_contains(z, x) || !arb_contains(z, y)) { printf("FAIL:\n\n"); printf("x = "); arb_print(x); printf("\n\n"); printf("y = "); arb_print(y); printf("\n\n"); printf("z = "); arb_print(z); printf("\n\n"); abort(); } if (n_randint(state, 2)) { arb_union(x, x, y, prec); alias = arb_equal(x, z); } else { arb_union(y, x, y, prec); alias = arb_equal(y, z); } if (!alias) { printf("FAIL (aliasing):\n\n"); printf("x = "); arb_print(x); printf("\n\n"); printf("y = "); arb_print(y); printf("\n\n"); printf("z = "); arb_print(z); printf("\n\n"); abort(); } arb_clear(x); arb_clear(y); arb_clear(z); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
void _arb_poly_rgamma_series(arb_ptr res, arb_srcptr h, long hlen, long len, long prec) { int reflect; long i, rflen, r, n, wp; arb_ptr t, u, v; arb_struct f[2]; hlen = FLINT_MIN(hlen, len); wp = prec + FLINT_BIT_COUNT(prec); t = _arb_vec_init(len); u = _arb_vec_init(len); v = _arb_vec_init(len); arb_init(f); arb_init(f + 1); /* use zeta values at small integers */ if (arb_is_int(h) && (arf_cmpabs_ui(arb_midref(h), prec / 2) < 0)) { r = arf_get_si(arb_midref(h), ARF_RND_DOWN); _arb_poly_lgamma_series_at_one(u, len, wp); _arb_vec_neg(u, u, len); _arb_poly_exp_series(t, u, len, len, wp); if (r == 1) { _arb_vec_swap(v, t, len); } else if (r <= 0) { arb_set(f, h); arb_one(f + 1); rflen = FLINT_MIN(len, 2 - r); _arb_poly_rising_ui_series(u, f, FLINT_MIN(2, len), 1 - r, rflen, wp); _arb_poly_mullow(v, t, len, u, rflen, len, wp); } else { arb_one(f); arb_one(f + 1); rflen = FLINT_MIN(len, r); _arb_poly_rising_ui_series(v, f, FLINT_MIN(2, len), r - 1, rflen, wp); /* TODO: use div_series? */ _arb_poly_inv_series(u, v, rflen, len, wp); _arb_poly_mullow(v, t, len, u, len, len, wp); } } else { /* otherwise use Stirling series */ arb_gamma_stirling_choose_param(&reflect, &r, &n, h, 1, 0, wp); /* rgamma(h) = (gamma(1-h+r) sin(pi h)) / (rf(1-h, r) * pi), h = h0 + t*/ if (reflect) { /* u = gamma(r+1-h) */ arb_sub_ui(f, h, r + 1, wp); arb_neg(f, f); _arb_poly_gamma_stirling_eval(t, f, n, len, wp); _arb_poly_exp_series(u, t, len, len, wp); for (i = 1; i < len; i += 2) arb_neg(u + i, u + i); /* v = sin(pi x) */ arb_const_pi(f + 1, wp); arb_mul(f, h, f + 1, wp); _arb_poly_sin_series(v, f, 2, len, wp); _arb_poly_mullow(t, u, len, v, len, len, wp); /* rf(1-h,r) * pi */ if (r == 0) { arb_const_pi(u, wp); _arb_vec_scalar_div(v, t, len, u, wp); } else { arb_sub_ui(f, h, 1, wp); arb_neg(f, f); arb_set_si(f + 1, -1); rflen = FLINT_MIN(len, r + 1); _arb_poly_rising_ui_series(v, f, FLINT_MIN(2, len), r, rflen, wp); arb_const_pi(u, wp); _arb_vec_scalar_mul(v, v, rflen, u, wp); /* divide by rising factorial */ /* TODO: might better to use div_series, when it has a good basecase */ _arb_poly_inv_series(u, v, rflen, len, wp); _arb_poly_mullow(v, t, len, u, len, len, wp); } } else { /* rgamma(h) = rgamma(h+r) rf(h,r) */ if (r == 0) { arb_add_ui(f, h, r, wp); _arb_poly_gamma_stirling_eval(t, f, n, len, wp); _arb_vec_neg(t, t, len); _arb_poly_exp_series(v, t, len, len, wp); } else { arb_set(f, h); arb_one(f + 1); rflen = FLINT_MIN(len, r + 1); _arb_poly_rising_ui_series(t, f, FLINT_MIN(2, len), r, rflen, wp); arb_add_ui(f, h, r, wp); _arb_poly_gamma_stirling_eval(v, f, n, len, wp); _arb_vec_neg(v, v, len); _arb_poly_exp_series(u, v, len, len, wp); _arb_poly_mullow(v, u, len, t, rflen, len, wp); } } } /* compose with nonconstant part */ arb_zero(t); _arb_vec_set(t + 1, h + 1, hlen - 1); _arb_poly_compose_series(res, v, len, t, hlen, len, prec); arb_clear(f); arb_clear(f + 1); _arb_vec_clear(t, len); _arb_vec_clear(u, len); _arb_vec_clear(v, len); }
int main() { slong iter; flint_rand_t state; flint_printf("rising2_ui...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 1000; iter++) { arb_t a, u, v, u2, v2; fmpz *f; arb_ptr g; ulong n; slong i, prec; arb_init(a); arb_init(u); arb_init(v); arb_init(u2); arb_init(v2); arb_randtest(a, state, 1 + n_randint(state, 4000), 10); arb_randtest(u, state, 1 + n_randint(state, 4000), 10); arb_randtest(v, state, 1 + n_randint(state, 4000), 10); n = n_randint(state, 120); f = _fmpz_vec_init(n + 1); g = _arb_vec_init(n + 1); prec = 2 + n_randint(state, 4000); arb_rising2_ui(u, v, a, n, prec); arith_stirling_number_1u_vec(f, n, n + 1); for (i = 0; i <= n; i++) arb_set_fmpz(g + i, f + i); _arb_poly_evaluate(u2, g, n + 1, a, prec); _arb_poly_derivative(g, g, n + 1, prec); _arb_poly_evaluate(v2, g, n, a, prec); if (!arb_overlaps(u, u2) || !arb_overlaps(v, v2)) { flint_printf("FAIL: overlap\n\n"); flint_printf("n = %wu\n", n); flint_printf("a = "); arb_printd(a, 15); flint_printf("\n\n"); flint_printf("u = "); arb_printd(u, 15); flint_printf("\n\n"); flint_printf("u2 = "); arb_printd(u2, 15); flint_printf("\n\n"); flint_printf("v = "); arb_printd(v, 15); flint_printf("\n\n"); flint_printf("v2 = "); arb_printd(v2, 15); flint_printf("\n\n"); abort(); } arb_set(u2, a); arb_rising2_ui(u2, v, u2, n, prec); if (!arb_equal(u2, u)) { flint_printf("FAIL: aliasing 1\n\n"); flint_printf("a = "); arb_printd(a, 15); flint_printf("\n\n"); flint_printf("u = "); arb_printd(u, 15); flint_printf("\n\n"); flint_printf("u2 = "); arb_printd(u2, 15); flint_printf("\n\n"); flint_printf("n = %wu\n", n); abort(); } arb_set(v2, a); arb_rising2_ui(u, v2, v2, n, prec); if (!arb_equal(v2, v)) { flint_printf("FAIL: aliasing 2\n\n"); flint_printf("a = "); arb_printd(a, 15); flint_printf("\n\n"); flint_printf("v = "); arb_printd(v, 15); flint_printf("\n\n"); flint_printf("v2 = "); arb_printd(v2, 15); flint_printf("\n\n"); flint_printf("n = %wu\n", n); abort(); } arb_clear(a); arb_clear(u); arb_clear(v); arb_clear(u2); arb_clear(v2); _fmpz_vec_clear(f, n + 1); _arb_vec_clear(g, n + 1); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("zeta_nzeros_gram...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 130 + 20 * arb_test_multiplier(); iter++) { arb_t t, x; fmpz_t N, n; slong prec1, prec2; arb_init(t); arb_init(x); fmpz_init(n); fmpz_init(N); if (iter < 130) { fmpz_set_si(n, iter - 1); } else { fmpz_randtest_unsigned(n, state, 20); fmpz_add_ui(n, n, 129); } prec1 = 2 + n_randtest(state) % 100; prec2 = 2 + n_randtest(state) % 100; acb_dirichlet_zeta_nzeros_gram(N, n); acb_dirichlet_gram_point(t, n, NULL, NULL, prec1); acb_dirichlet_zeta_nzeros(x, t, prec2); if (!arb_contains_fmpz(x, N)) { flint_printf("FAIL: containment\n\n"); flint_printf("n = "); fmpz_print(n); flint_printf(" prec1 = %wd prec2 = %wd\n\n", prec1, prec2); flint_printf("N = "); fmpz_print(N); flint_printf("\n\n"); flint_printf("t = "); arb_printn(t, 100, 0); flint_printf("\n\n"); flint_printf("x = "); arb_printn(x, 100, 0); flint_printf("\n\n"); flint_abort(); } arb_clear(t); arb_clear(x); fmpz_clear(n); fmpz_clear(N); } 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("fundamental_domain_approx...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { fmpq_t x, y; psl2z_t g; arf_t one_minus_eps, tol; acb_t z, w, w2; arb_t t; slong prec; fmpq_init(x); fmpq_init(y); psl2z_init(g); acb_init(z); acb_init(w); acb_init(w2); arf_init(one_minus_eps); arf_init(tol); arb_init(t); /* pick an exact point in the upper half plane */ fmpq_randtest(x, state, 1 + n_randint(state, 500)); do { fmpq_randtest(y, state, 1 + n_randint(state, 500)); } while (fmpz_sgn(fmpq_numref(y)) <= 0); /* pick a tolerance */ arf_set_ui_2exp_si(tol, 1, -(slong) n_randint(state, 500)); /* now increase the precision until convergence */ for (prec = 32; ; prec *= 2) { if (prec > 16384) { flint_printf("FAIL (no convergence)\n"); flint_printf("x = "); fmpq_print(x); flint_printf("\n\n"); flint_printf("y = "); fmpq_print(y); flint_printf("\n\n"); flint_printf("z = "); acb_printd(z, 50); flint_printf("\n\n"); flint_printf("w = "); acb_printd(w, 50); flint_printf("\n\n"); flint_printf("w2 = "); acb_printd(w2, 50); flint_printf("\n\n"); flint_printf("g = "); psl2z_print(g); flint_printf("\n\n"); abort(); } arb_set_fmpq(acb_realref(z), x, prec); arb_set_fmpq(acb_imagref(z), y, prec); arf_set_ui_2exp_si(one_minus_eps, 1, -prec / 4); arf_sub_ui(one_minus_eps, one_minus_eps, 1, prec, ARF_RND_DOWN); arf_neg(one_minus_eps, one_minus_eps); acb_modular_fundamental_domain_approx(w, g, z, one_minus_eps, prec); acb_modular_transform(w2, g, z, prec); if (!psl2z_is_correct(g) || !acb_overlaps(w, w2)) { flint_printf("FAIL (incorrect transformation)\n"); flint_printf("x = "); fmpq_print(x); flint_printf("\n\n"); flint_printf("y = "); fmpq_print(y); flint_printf("\n\n"); flint_printf("z = "); acb_printd(z, 50); flint_printf("\n\n"); flint_printf("w = "); acb_printd(w, 50); flint_printf("\n\n"); flint_printf("w2 = "); acb_printd(w2, 50); flint_printf("\n\n"); flint_printf("g = "); psl2z_print(g); flint_printf("\n\n"); abort(); } /* success */ if (acb_modular_is_in_fundamental_domain(w, tol, prec)) break; } /* check that g^(-1) * w contains x+yi */ psl2z_inv(g, g); acb_modular_transform(w2, g, w, 2 + n_randint(state, 1000)); if (!arb_contains_fmpq(acb_realref(w2), x) || !arb_contains_fmpq(acb_imagref(w2), y)) { flint_printf("FAIL (inverse containment)\n"); flint_printf("x = "); fmpq_print(x); flint_printf("\n\n"); flint_printf("y = "); fmpq_print(y); flint_printf("\n\n"); flint_printf("z = "); acb_printd(z, 50); flint_printf("\n\n"); flint_printf("w = "); acb_printd(w, 50); flint_printf("\n\n"); flint_printf("w2 = "); acb_printd(w2, 50); flint_printf("\n\n"); flint_printf("g = "); psl2z_print(g); flint_printf("\n\n"); abort(); } fmpq_clear(x); fmpq_clear(y); psl2z_clear(g); acb_clear(z); acb_clear(w); acb_clear(w2); arf_clear(one_minus_eps); arf_clear(tol); arb_clear(t); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("taylor_shift...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 2000; 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(g, f, e, prec2); arb_poly_taylor_shift(f, f, c, prec1); arb_poly_taylor_shift(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; }
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("sinh_cosh...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 100000; iter++) { arb_t a, b, c; fmpq_t q; mpfr_t t, u; slong prec = 2 + n_randint(state, 200); arb_init(a); arb_init(b); arb_init(c); fmpq_init(q); mpfr_init2(t, prec + 100); mpfr_init2(u, prec + 100); arb_randtest(a, state, 1 + n_randint(state, 200), 3); arb_randtest(b, state, 1 + n_randint(state, 200), 3); arb_randtest(c, state, 1 + n_randint(state, 200), 3); arb_get_rand_fmpq(q, state, a, 1 + n_randint(state, 200)); fmpq_get_mpfr(t, q, MPFR_RNDN); mpfr_sinh_cosh(t, u, t, MPFR_RNDN); arb_sinh_cosh(b, c, a, prec); if (!arb_contains_mpfr(b, t)) { flint_printf("FAIL: containment (sin)\n\n"); flint_printf("a = "); arb_print(a); flint_printf("\n\n"); flint_printf("b = "); arb_print(b); flint_printf("\n\n"); abort(); } if (!arb_contains_mpfr(c, u)) { flint_printf("FAIL: containment (cos)\n\n"); flint_printf("a = "); arb_print(a); flint_printf("\n\n"); flint_printf("c = "); arb_print(c); flint_printf("\n\n"); abort(); } arb_clear(a); arb_clear(b); arb_clear(c); fmpq_clear(q); mpfr_clear(t); mpfr_clear(u); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { long iter; flint_rand_t state; printf("eta...."); fflush(stdout); flint_randinit(state); /* Test functional equation */ for (iter = 0; iter < 10000; iter++) { acb_t tau1, tau2, z1, z2, z3, t; fmpq_t arg; long e0, prec0, prec1, prec2; psl2z_t g; psl2z_init(g); fmpq_init(arg); acb_init(tau1); acb_init(tau2); acb_init(z1); acb_init(z2); acb_init(z3); acb_init(t); e0 = 1 + n_randint(state, 200); prec0 = 2 + n_randint(state, 2000); prec1 = 2 + n_randint(state, 2000); prec2 = 2 + n_randint(state, 2000); acb_randtest(tau1, state, prec0, e0); acb_randtest(tau2, state, prec0, e0); acb_randtest(z1, state, prec0, e0); acb_randtest(z2, state, prec0, e0); psl2z_randtest(g, state, 1 + n_randint(state, 200)); acb_modular_transform(tau2, g, tau1, prec0); acb_modular_eta(z1, tau1, prec1); acb_modular_eta(z2, tau2, prec2); /* apply transformation */ fmpq_set_si(arg, acb_modular_epsilon_arg(g), 12); arb_sin_cos_pi_fmpq(acb_imagref(t), acb_realref(t), arg, prec1); acb_mul(z3, z1, t, prec1); acb_mul_fmpz(t, tau1, &g->c, prec1); acb_add_fmpz(t, t, &g->d, prec1); acb_sqrt(t, t, prec1); acb_mul(z3, z3, t, prec1); if (!acb_overlaps(z3, z2)) { printf("FAIL (overlap)\n"); printf("tau1 = "); acb_printd(tau1, 15); printf("\n\n"); printf("tau2 = "); acb_printd(tau2, 15); printf("\n\n"); printf("g = "); psl2z_print(g); printf("\n\n"); printf("z1 = "); acb_printd(z1, 15); printf("\n\n"); printf("z2 = "); acb_printd(z2, 15); printf("\n\n"); printf("z3 = "); acb_printd(z3, 15); printf("\n\n"); abort(); } acb_modular_eta(tau1, tau1, prec2); if (!acb_overlaps(z1, tau1)) { printf("FAIL (aliasing)\n"); printf("tau1 = "); acb_print(tau1); printf("\n\n"); printf("tau2 = "); acb_print(tau2); printf("\n\n"); printf("z1 = "); acb_print(z1); printf("\n\n"); printf("z2 = "); acb_print(z2); printf("\n\n"); abort(); } acb_clear(tau1); acb_clear(tau2); acb_clear(z1); acb_clear(z2); acb_clear(z3); acb_clear(t); psl2z_clear(g); fmpq_clear(arg); } /* Test special values */ for (iter = 0; iter < 100; iter++) { acb_t tau, z; arb_t t, u; long prec; acb_init(tau); acb_init(z); arb_init(t); arb_init(u); prec = 2 + n_randint(state, 2000); acb_randtest(z, state, prec, 10); acb_onei(tau); acb_modular_eta(z, tau, prec); arb_one(t); arb_mul_2exp_si(t, t, -2); arb_gamma(t, t, prec); arb_const_pi(u, prec); arb_root(u, u, 4, prec); arb_pow_ui(u, u, 3, prec); arb_div(t, t, u, prec); arb_mul_2exp_si(t, t, -1); if (!arb_overlaps(acb_realref(z), t) || !arb_contains_zero(acb_imagref(z))) { printf("FAIL (value 1)\n"); printf("tau = "); acb_print(tau); printf("\n\n"); printf("z = "); acb_print(z); printf("\n\n"); abort(); } acb_clear(tau); acb_clear(z); arb_clear(t); arb_clear(u); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; FLINT_TEST_INIT(state); { ulong k; arb_t a,b; arf_t c,d; fmpq_poly_t p; arb_init(a); arb_init(b); arf_init(c); arf_init(d); /* x+1 */ fmpq_poly_init(p); fmpq_poly_set_coeff_si(p, 0, 1); fmpq_poly_set_coeff_si(p, 1, 1); for (iter = 0; iter < 5000; iter++) { k = n_randint(state, 10000); arb_set_si(a, k); fmpq_poly_evaluate_arb(b, p, a, 30 + n_randint(state, 100)); if (!arb_equal_si(b, k + 1)) { printf("FAIL (fmpq_poly_evaluate_arb):\n"); printf("a = "); arb_print(a); printf("\n"); printf("b = "); arb_print(b); printf("\n"); printf("p = "); fmpq_poly_print(p); printf("\n"); abort(); } arf_set_si(c, k); fmpq_poly_evaluate_arf(d, p, c, 30 + n_randint(state, 100)); if (!arf_equal_si(d, k + 1)) { printf("FAIL (fmpq_poly_evaluate_arf):\n"); printf("c = "); arf_print(c); printf("\n"); printf("d = "); arf_print(d); printf("\n"); printf("p = "); fmpq_poly_print(p); printf("\n"); abort(); } } /* x^2 */ fmpq_poly_zero(p); fmpq_poly_set_coeff_si(p, 2, 1); for (iter = 0; iter < 1000; iter++) { k = n_randint(state, 10000); arb_set_si(a, k); fmpq_poly_evaluate_arb(b, p, a, 30 + n_randint(state, 100)); if (!arb_equal_si(b, k * k)) { printf("Error (test_fmpq_poly_evaluate_arb):\n"); printf("a = "); arb_print(a); printf("\n"); printf("b = "); arb_print(b); printf("\n"); printf("p = "); fmpq_poly_print(p); printf("\n"); abort(); } arf_set_si(c, k); fmpq_poly_evaluate_arf(d, p, c, 30 + n_randint(state, 100)); if (!arf_equal_si(d, k * k)) { printf("Error (test_fmpq_poly_evaluate_arf):\n"); printf("c = "); arf_print(c); printf("\n"); printf("d = "); arf_print(d); printf("\n"); printf("p = "); fmpq_poly_print(p); printf("\n"); abort(); } } fmpq_poly_clear(p); arb_clear(a); arb_clear(b); arf_clear(c); arf_clear(d); } /* check evaluate_arb agains exact evaluate_fmpq */ for (iter = 0; iter < 1000; iter++) { fmpq_poly_t p; fmpq_t x,y; arb_t a,b; fmpq_poly_init(p); fmpq_init(x); fmpq_init(y); arb_init(a); arb_init(b); fmpq_poly_randtest(p, state, 1 + n_randint(state,100), 10); fmpq_randtest(x, state, 10); arb_set_fmpq(a, x, 64); fmpq_poly_evaluate_fmpq(y, p, x); fmpq_poly_evaluate_arb(b, p, a, 60); if (!arb_contains_fmpq(b, y)) { printf("FAIL (y not in b):\n"); printf("p = "); fmpq_poly_print(p); printf("\n"); printf("x = "); fmpq_print(x); printf("\n"); printf("y = "); fmpq_print(y); printf("\n"); printf("a = "); arb_print(a); printf("\n"); printf("b = "); arb_print(b); printf("\n"); abort(); } fmpq_poly_evaluate_arb(a, p, a, 60); if (!arb_equal(a,b)) { printf("FAIL (a not equal b):\n"); printf("p = "); fmpq_poly_print(p); printf("\n"); printf("x = "); fmpq_print(x); printf("\n"); printf("y = "); fmpq_print(y); printf("\n"); printf("a = "); arb_print(a); printf("\n"); printf("b = "); arb_print(b); printf("\n"); abort(); } fmpq_poly_clear(p); fmpq_clear(x); fmpq_clear(y); arb_clear(a); arb_clear(b); } /* test aliasing */ for (iter = 0; iter < 1000; iter++) { fmpq_poly_t p; arb_t a,b; arf_t c,d; fmpq_poly_init(p); arb_init(a); arb_init(b); arf_init(c); arf_init(d); fmpq_poly_randtest(p, state, 1 + n_randint(state,100), 10); arb_randtest(a, state, 60, 10); arb_randtest(b, state, 60, 10); arf_randtest(c, state, 60, 10); arf_randtest(d, state, 60, 10); fmpq_poly_evaluate_arb(b, p, a, 60); fmpq_poly_evaluate_arb(a, p, a, 60); if (!arb_equal(a, b)) { printf("FAIL (a not equal b):\n"); printf("p = "); fmpq_poly_print(p); printf("\n"); printf("a = "); arb_print(a); printf("\n"); printf("b = "); arb_print(b); printf("\n"); abort(); } fmpq_poly_evaluate_arf(d, p, c, 60); fmpq_poly_evaluate_arf(c, p, c, 60); if (!arf_equal(c, d)) { printf("FAIL (c not equal d):\n"); printf("p = "); fmpq_poly_print(p); printf("\n"); printf("c = "); arf_print(c); printf("\n"); printf("d = "); arf_print(d); printf("\n"); } fmpq_poly_clear(p); arb_clear(a); arb_clear(b); arf_clear(c); arf_clear(d); } FLINT_TEST_CLEANUP(state); return 0; }
int main() { slong iter; flint_rand_t state; flint_printf("coth...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { arb_t x, y, a, b, c, d; slong prec1, prec2; prec1 = 2 + n_randint(state, 1000); prec2 = prec1 + 30; arb_init(x); arb_init(y); arb_init(a); arb_init(b); arb_init(c); arb_init(d); arb_randtest_precise(x, state, 1 + n_randint(state, 1000), 100); arb_randtest_precise(y, state, 1 + n_randint(state, 1000), 100); arb_coth(a, x, prec1); arb_coth(b, x, prec2); /* check consistency */ if (!arb_overlaps(a, b)) { flint_printf("FAIL: overlap\n\n"); flint_printf("x = "); arb_print(x); flint_printf("\n\n"); flint_printf("a = "); arb_print(a); flint_printf("\n\n"); flint_printf("b = "); arb_print(b); flint_printf("\n\n"); flint_abort(); } /* check coth(x+y) = (1 + coth(x) coth(y)) / (coth(x) + coth(y)) */ arb_add(b, x, y, prec1); arb_coth(b, b, prec1); arb_coth(c, y, prec1); arb_add(d, a, c, prec1); arb_mul(c, a, c, prec1); arb_add_ui(c, c, 1, prec1); arb_div(d, c, d, prec1); if (!arb_overlaps(b, d)) { flint_printf("FAIL: functional equation\n\n"); flint_printf("x = "); arb_print(x); flint_printf("\n\n"); flint_printf("y = "); arb_print(y); flint_printf("\n\n"); flint_printf("b = "); arb_print(b); flint_printf("\n\n"); flint_printf("d = "); arb_print(d); flint_printf("\n\n"); flint_abort(); } arb_coth(x, x, prec1); if (!arb_overlaps(a, x)) { flint_printf("FAIL: aliasing\n\n"); flint_printf("a = "); arb_print(a); flint_printf("\n\n"); flint_printf("x = "); arb_print(x); flint_printf("\n\n"); flint_abort(); } arb_clear(x); arb_clear(y); arb_clear(a); arb_clear(b); arb_clear(c); arb_clear(d); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("asin...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { arb_t a, b; fmpq_t q; mpfr_t t; slong prec = 2 + n_randint(state, 200); arb_init(a); arb_init(b); fmpq_init(q); mpfr_init2(t, prec + 100); arb_randtest(a, state, 1 + n_randint(state, 200), 3); arb_randtest(b, state, 1 + n_randint(state, 200), 3); arb_get_rand_fmpq(q, state, a, 1 + n_randint(state, 200)); fmpq_get_mpfr(t, q, MPFR_RNDN); mpfr_asin(t, t, MPFR_RNDN); arb_asin(b, a, prec); if (!arb_contains_mpfr(b, t)) { flint_printf("FAIL: containment\n\n"); flint_printf("a = "); arb_print(a); flint_printf("\n\n"); flint_printf("b = "); arb_print(b); flint_printf("\n\n"); flint_abort(); } arb_asin(a, a, prec); if (!arb_equal(a, b)) { flint_printf("FAIL: aliasing\n\n"); flint_abort(); } arb_clear(a); arb_clear(b); fmpq_clear(q); mpfr_clear(t); } /* check large arguments */ for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { arb_t a, b, c; slong prec1, prec2; prec1 = 2 + n_randint(state, 1000); prec2 = prec1 + 30; arb_init(a); arb_init(b); arb_init(c); arb_randtest_precise(a, state, 1 + n_randint(state, 1000), 100); arb_asin(b, a, prec1); arb_asin(c, a, prec2); if (!arb_overlaps(b, c)) { 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_abort(); } /* check sin(asin(x)) = x */ arb_sin(c, b, prec1); if (!arb_contains(c, a)) { 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_abort(); } arb_clear(a); arb_clear(b); arb_clear(c); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
void gc_integrals_precomp(acb_ptr res, acb_srcptr u, slong d1, slong d, slong g, const gc_int_t gc, int flag, slong prec) { slong l; arb_t w, x; acb_t y, yxi; void (*sqrt_pol) (acb_t y, acb_srcptr u, slong d1, slong d, const arb_t x, slong prec); arb_init(w); arb_init(x); acb_init(y); acb_init(yxi); #if DEBUG flint_printf("\ngc integral : d1 = %ld, d = %ld, g = %ld, n = %ld, prec = %ld", d1, d, g, gc->n, prec); #endif sqrt_pol = &sqrt_pol_turn; if (flag & AJ_ROOT_DEF) sqrt_pol = &sqrt_pol_def; else if (flag & AJ_ROOT_TURN) sqrt_pol = &sqrt_pol_turn; /* compute integral */ _acb_vec_zero(res, g); for (l = 0; l < gc->len; l++) { /* compute 1/y(x) */ sqrt_pol(y, u, d1, d, gc->x + l, prec); acb_inv(y, y, prec); /* differentials */ acb_vec_add_geom_arb(res, g, y, gc->x + l, prec); /* now on -x */ arb_neg(x, gc->x + l); sqrt_pol(y, u, d1, d, x, prec); acb_inv(y, y, prec); acb_vec_add_geom_arb(res, g, y, x, prec); } if (gc->n % 2) { arb_zero(x); /* FIXME: pb with turn */ sqrt_pol_def(y, u, d1, d, x, prec); #if DEBUG > 1 flint_printf("\nend integration sum"); _acb_vec_printd(res, g, 30, "\n"); flint_printf("\nroots (d1=%ld, d=%ld)\n",d1,d); _acb_vec_printd(u, d, 30, "\n"); flint_printf("\n -> y = "); acb_printd(y, 30); #endif acb_inv(y, y, prec); acb_add(res + 0, res + 0, y, prec); } /* multiply by weight = Pi / n */ arb_const_pi(w, prec); arb_div_ui(w, w, gc->n, prec); _acb_vec_scalar_mul_arb(res, res, g, w, prec); #if DEBUG > 1 flint_printf("\nend integration "); _acb_vec_printd(res, g, 30, "\n"); #endif arb_clear(x); arb_clear(w); acb_clear(y); acb_clear(yxi); }
int main() { flint_rand_t state; flint_printf("wrappers...."); fflush(stdout); flint_randinit(state); { arb_t a, b, c, d, z, r, u, v; slong prec; prec = 53; arb_init(a); arb_init(b); arb_init(c); arb_init(d); arb_init(z); arb_init(r); arb_init(u); arb_init(v); arb_set_d(a, 0.5); arb_set_d(b, 0.25); arb_set_d(c, 0.125); arb_set_d(z, 0.75); arb_hypgeom_pfq(r, a, 1, b, 1, z, 0, prec); arb_set_str(v, "[3.40725820729608 +/- 6.88e-15]", prec); TEST(r, v, "pfq"); arb_hypgeom_pfq(r, a, 1, b, 1, z, 1, prec); arb_set_str(v, "[0.93977518087904 +/- 3.26e-15]", prec); TEST(r, v, "pfq regularized"); arb_hypgeom_0f1(r, a, z, 0, prec); arb_set_str(v, "[2.91457744017593 +/- 4.17e-15]", prec); TEST(r, v, "0f1"); arb_hypgeom_0f1(r, a, z, 1, prec); arb_set_str(v, "[1.64437423219054 +/- 3.77e-15]", prec); TEST(r, v, "0f1 regularized"); arb_hypgeom_1f1(r, a, b, z, 0, prec); arb_set_str(v, "[3.40725820729608 +/- 6.88e-15]", prec); TEST(r, v, "1f1"); arb_hypgeom_1f1(r, a, b, z, 1, prec); arb_set_str(v, "[0.93977518087904 +/- 3.26e-15]", prec); TEST(r, v, "1f1 regularized"); arb_hypgeom_u(r, a, b, z, prec); arb_set_str(v, "[0.7761320390950 +/- 3.89e-14]", prec); TEST(r, v, "u"); arb_hypgeom_2f1(r, a, b, c, z, 0, prec); arb_set_str(v, "[3.2569394189980 +/- 8.18e-14]", prec); TEST(r, v, "2f1"); arb_hypgeom_2f1(r, a, b, c, z, 1, prec); arb_set_str(v, "[0.4323021855542 +/- 1.67e-14]", prec); TEST(r, v, "2f1 regularized"); arb_hypgeom_erf(r, z, prec); arb_set_str(v, "[0.711155633653515 +/- 2.35e-16]", prec); TEST(r, v, "erf"); arb_hypgeom_erfc(r, z, prec); arb_set_str(v, "[0.288844366346485 +/- 2.34e-16]", prec); TEST(r, v, "erfc"); arb_hypgeom_erfi(r, z, prec); arb_set_str(v, "[1.03575728441196 +/- 3.17e-15]", prec); TEST(r, v, "erfi"); arb_hypgeom_fresnel(r, NULL, z, 0, prec); arb_set_str(v, "[0.137478632382610 +/- 1.79e-16]", prec); TEST(r, v, "fresnel_s"); arb_hypgeom_fresnel(r, NULL, z, 1, prec); arb_set_str(v, "[0.208877111233384 +/- 4.63e-16]", prec); TEST(r, v, "fresnel_s normalized"); arb_hypgeom_fresnel(NULL, r, z, 0, prec); arb_set_str(v, "[0.726614618304550 +/- 2.11e-16]", prec); TEST(r, v, "fresnel_c"); arb_hypgeom_fresnel(NULL, r, z, 1, prec); arb_set_str(v, "[0.693525990787136 +/- 2.76e-16]", prec); TEST(r, v, "fresnel_c normalized"); arb_hypgeom_gamma_lower(r, a, z, 0, prec); arb_set_str(v, "[1.38132404568612 +/- 3.66e-15]", prec); TEST(r, v, "gamma_lower"); arb_hypgeom_gamma_lower(r, a, z, 1, prec); arb_set_str(v, "[0.77932863808015 +/- 4.17e-15]", prec); TEST(r, v, "gamma_lower 1"); arb_hypgeom_gamma_lower(r, a, z, 2, prec); arb_set_str(v, "[0.89989119796552 +/- 2.76e-15]", prec); TEST(r, v, "gamma_lower 2"); arb_hypgeom_gamma_upper(r, a, z, 0, prec); arb_set_str(v, "[0.39112980521940 +/- 4.21e-15]", prec); TEST(r, v, "gamma_upper"); arb_hypgeom_gamma_upper(r, a, z, 1, prec); arb_set_str(v, "[0.22067136191985 +/- 4.08e-15]", prec); TEST(r, v, "gamma_upper 1"); arb_hypgeom_beta_lower(r, a, b, z, 0, prec); arb_set_str(v, "[2.3363313667086 +/- 3.14e-14]", prec); TEST(r, v, "beta_lower"); arb_hypgeom_beta_lower(r, a, b, z, 1, prec); arb_set_str(v, "[0.44551489018313 +/- 6.22e-15]", prec); TEST(r, v, "beta_lower 1"); arb_hypgeom_expint(r, a, z, prec); arb_set_str(v, "[0.45163779666301 +/- 3.10e-15]", prec); TEST(r, v, "expint"); arb_hypgeom_ei(r, z, prec); arb_set_str(v, "[1.20733281600122 +/- 2.72e-15]", prec); TEST(r, v, "ei"); arb_hypgeom_si(r, z, prec); arb_set_str(v, "[0.72695424715009 +/- 3.99e-15]", prec); TEST(r, v, "si"); arb_hypgeom_ci(r, z, prec); arb_set_str(v, "[0.152163600980330 +/- 5.49e-16]", prec); TEST(r, v, "ci"); arb_hypgeom_shi(r, z, prec); arb_set_str(v, "[0.77383681445623 +/- 5.97e-15]", prec); TEST(r, v, "shi"); arb_hypgeom_chi(r, z, prec); arb_set_str(v, "[0.433496001544996 +/- 7.91e-16]", prec); TEST(r, v, "chi"); arb_hypgeom_li(r, z, 0, prec); arb_set_str(v, "[-0.93693001101265 +/- 5.67e-15]", prec); TEST(r, v, "li"); arb_hypgeom_li(r, z, 1, prec); arb_set_str(v, "[-1.98209379113014 +/- 3.56e-15]", prec); TEST(r, v, "li offset"); arb_hypgeom_bessel_j(r, a, z, prec); arb_set_str(v, "[0.62800587637589 +/- 4.06e-15]", prec); TEST(r, v, "bessel_j"); arb_hypgeom_bessel_y(r, a, z, prec); arb_set_str(v, "[-0.67411792914454 +/- 5.27e-15]", prec); TEST(r, v, "bessel_y"); arb_hypgeom_bessel_jy(r, u, a, z, prec); arb_set_str(v, "[0.62800587637589 +/- 4.06e-15]", prec); TEST(r, v, "bessel_jy"); arb_set_str(v, "[-0.67411792914454 +/- 5.27e-15]", prec); TEST(u, v, "bessel_jy"); arb_hypgeom_bessel_i(r, a, z, prec); arb_set_str(v, "[0.75761498638991 +/- 4.63e-15]", prec); TEST(r, v, "bessel_i"); arb_hypgeom_bessel_k(r, a, z, prec); arb_set_str(v, "[0.68361006034952 +/- 7.89e-15]", prec); TEST(r, v, "bessel_k"); arb_hypgeom_airy(r, NULL, NULL, NULL, z, prec); arb_set_str(v, "[0.179336305478645 +/- 2.36e-16]", prec); TEST(r, v, "airy ai"); arb_hypgeom_airy(NULL, r, NULL, NULL, z, prec); arb_set_str(v, "[-0.193175208104376 +/- 4.67e-16]", prec); TEST(r, v, "airy ai'"); arb_hypgeom_airy(NULL, NULL, r, NULL, z, prec); arb_set_str(v, "[1.00693090863322 +/- 3.90e-15]", prec); TEST(r, v, "airy bi"); arb_hypgeom_airy(NULL, NULL, NULL, r, z, prec); arb_set_str(v, "[0.690299702736886 +/- 2.34e-16]", prec); TEST(r, v, "airy bi'"); arb_hypgeom_chebyshev_t(r, a, z, prec); arb_set_str(v, "[0.935414346693485 +/- 7.02e-16]", prec); TEST(r, v, "chebyshev_t"); arb_hypgeom_chebyshev_u(r, a, z, prec); arb_set_str(v, "[1.33630620956212 +/- 3.41e-15]", prec); TEST(r, v, "chebyshev_u"); arb_hypgeom_jacobi_p(r, a, b, c, z, prec); arb_set_str(v, "[1.03224258095454 +/- 6.54e-15]", prec); TEST(r, v, "jacobi_p"); arb_hypgeom_gegenbauer_c(r, a, b, z, prec); arb_set_str(v, "[0.58153237382485 +/- 3.74e-15]", prec); TEST(r, v, "gegenbauer_c"); arb_hypgeom_laguerre_l(r, a, b, z, prec); arb_set_str(v, "[0.76858987769621 +/- 3.19e-15]", prec); TEST(r, v, "laguerre_l"); arb_hypgeom_hermite_h(r, a, z, prec); arb_set_str(v, "[1.31600493243946 +/- 6.52e-15]", prec); TEST(r, v, "hermite_h"); arb_hypgeom_legendre_p(r, a, b, z, 0, prec); arb_set_str(v, "[0.90435295129350 +/- 5.79e-15]", prec); TEST(r, v, "legendre_q"); arb_hypgeom_legendre_q(r, a, b, z, 0, prec); arb_set_str(v, "[-0.3763617490859 +/- 3.83e-14]", prec); TEST(r, v, "legendre_q"); arb_clear(a); arb_clear(b); arb_clear(c); arb_clear(d); arb_clear(z); arb_clear(r); arb_clear(u); arb_clear(v); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
/* derivatives: |8/sqrt(pi) sin(2z^2)|, |8/sqrt(pi) cos(2z^2)| <= 5 exp(4|xy|) */ void acb_hypgeom_fresnel_erf_error(acb_t res1, acb_t res2, const acb_t z, slong prec) { mag_t re; mag_t im; acb_t zmid; mag_init(re); mag_init(im); acb_init(zmid); if (arf_cmpabs_ui(arb_midref(acb_realref(z)), 1000) < 0 && arf_cmpabs_ui(arb_midref(acb_imagref(z)), 1000) < 0) { arb_get_mag(re, acb_realref(z)); arb_get_mag(im, acb_imagref(z)); mag_mul(re, re, im); mag_mul_2exp_si(re, re, 2); mag_exp(re, re); mag_mul_ui(re, re, 5); } else { arb_t t; arb_init(t); arb_mul(t, acb_realref(z), acb_imagref(z), prec); arb_abs(t, t); arb_mul_2exp_si(t, t, 2); arb_exp(t, t, prec); arb_get_mag(re, t); mag_mul_ui(re, re, 5); arb_clear(t); } mag_hypot(im, arb_radref(acb_realref(z)), arb_radref(acb_imagref(z))); mag_mul(re, re, im); if (arb_is_zero(acb_imagref(z))) { mag_set_ui(im, 8); /* For real x, |S(x)| < 4, |C(x)| < 4. */ mag_min(re, re, im); mag_zero(im); } else if (arb_is_zero(acb_realref(z))) { mag_set_ui(im, 8); mag_min(im, re, im); mag_zero(re); } else { mag_set(im, re); } arf_set(arb_midref(acb_realref(zmid)), arb_midref(acb_realref(z))); arf_set(arb_midref(acb_imagref(zmid)), arb_midref(acb_imagref(z))); acb_hypgeom_fresnel_erf(res1, res2, zmid, prec); if (res1 != NULL) { arb_add_error_mag(acb_realref(res1), re); arb_add_error_mag(acb_imagref(res1), im); } if (res2 != NULL) { arb_add_error_mag(acb_realref(res2), re); arb_add_error_mag(acb_imagref(res2), im); } mag_clear(re); mag_clear(im); acb_clear(zmid); }
int main() { slong iter; flint_rand_t state; flint_printf("contains_arf...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { arb_t a; arf_t b; fmpq_t am, ar, bm, t; int c1, c2; arb_init(a); arf_init(b); fmpq_init(am); fmpq_init(ar); fmpq_init(bm); fmpq_init(t); arb_randtest(a, state, 1 + n_randint(state, 500), 14); arf_randtest(b, state, 1 + n_randint(state, 500), 14); arf_get_fmpq(am, arb_midref(a)); mag_get_fmpq(ar, arb_radref(a)); arf_get_fmpq(bm, b); c1 = arb_contains_arf(a, b); fmpq_sub(t, am, ar); c2 = fmpq_cmp(t, bm) <= 0; fmpq_add(t, am, ar); c2 = c2 && (fmpq_cmp(t, bm) >= 0); if (c1 != c2) { flint_printf("FAIL:\n\n"); flint_printf("a = "); arb_print(a); flint_printf("\n\n"); flint_printf("b = "); arf_print(b); flint_printf("\n\n"); flint_printf("am = "); fmpq_print(am); flint_printf("\n\n"); flint_printf("ar = "); fmpq_print(ar); flint_printf("\n\n"); flint_printf("bm = "); fmpq_print(bm); flint_printf("\n\n"); flint_printf("t = "); fmpq_print(t); flint_printf("\n\n"); flint_printf("c1 = %d, c2 = %d\n\n", c1, c2); abort(); } arb_clear(a); arf_clear(b); fmpq_clear(am); fmpq_clear(ar); fmpq_clear(bm); fmpq_clear(t); } 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 main() { slong iter; flint_rand_t state; flint_printf("sin_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_sin_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_sin_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_sin_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("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("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("power_sum_vec...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++) { arb_t a, b, s, t; arb_ptr res; slong aa, bb, k, n, len; slong prec; len = n_randint(state, 30); prec = 2 + n_randint(state, 500); aa = n_randint(state, 50) - 50; bb = aa + n_randint(state, 50); arb_init(a); arb_init(b); arb_init(s); arb_init(t); res = _arb_vec_init(len); arb_set_si(a, aa); arb_set_si(b, bb); arb_power_sum_vec(res, a, b, len, prec); for (n = 0; n < len; n++) { arb_zero(s); for (k = aa; k < bb; k++) { arb_set_si(t, k); arb_pow_ui(t, t, n, prec); arb_add(s, s, t, prec); } if (!arb_overlaps(res + n, s)) { flint_printf("FAIL: overlap\n\n"); flint_printf("a = %wd, b = %wd, n = %wd\n\n", aa, bb, n); flint_printf("res = "); arb_printd(res + n, 30); flint_printf("\n\n"); flint_printf("s = "); arb_printd(s, 30); flint_printf("\n\n"); abort(); } } arb_clear(a); arb_clear(b); arb_clear(s); arb_clear(t); _arb_vec_clear(res, len); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("atanh...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { arb_t x, a, b; slong prec1, prec2; prec1 = 2 + n_randint(state, 1000); prec2 = prec1 + 30; arb_init(x); arb_init(a); arb_init(b); arb_randtest_special(x, state, 1 + n_randint(state, 1000), 2 + n_randint(state, 100)); arb_randtest_special(a, state, 1 + n_randint(state, 1000), 2 + n_randint(state, 100)); arb_randtest_special(b, state, 1 + n_randint(state, 1000), 2 + n_randint(state, 100)); arb_atanh(a, x, prec1); arb_atanh(b, x, prec2); /* check consistency */ if (!arb_overlaps(a, b)) { flint_printf("FAIL: overlap\n\n"); flint_printf("x = "); arb_printd(x, 15); flint_printf("\n\n"); flint_printf("a = "); arb_printd(a, 15); flint_printf("\n\n"); flint_printf("b = "); arb_printd(b, 15); flint_printf("\n\n"); abort(); } /* check tanh(atanh(x)) = x */ arb_tanh(b, b, prec1); if (!arb_contains(b, x)) { flint_printf("FAIL: functional equation\n\n"); flint_printf("x = "); arb_printd(x, 15); flint_printf("\n\n"); flint_printf("b = "); arb_printd(b, 15); flint_printf("\n\n"); abort(); } arb_atanh(x, x, prec1); if (!arb_overlaps(a, x)) { flint_printf("FAIL: aliasing\n\n"); flint_printf("a = "); arb_printd(a, 15); flint_printf("\n\n"); flint_printf("x = "); arb_printd(x, 15); flint_printf("\n\n"); abort(); } arb_clear(x); arb_clear(a); arb_clear(b); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("isolate_roots...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 40; iter++) { slong m, r, a, b, maxdepth, maxeval, maxfound, prec, i, j, num; arf_interval_ptr blocks; int * info; arf_interval_t interval; arb_t t; fmpz_t nn; prec = 2 + n_randint(state, 50); m = n_randint(state, 80); r = 1 + n_randint(state, 80); a = m - r; b = m + r; maxdepth = 1 + n_randint(state, 60); maxeval = 1 + n_randint(state, 5000); maxfound = 1 + n_randint(state, 100); arf_interval_init(interval); arb_init(t); fmpz_init(nn); arf_set_si(&interval->a, a); arf_set_si(&interval->b, b); num = arb_calc_isolate_roots(&blocks, &info, sin_pi2_x, NULL, interval, maxdepth, maxeval, maxfound, prec); /* check that all roots are accounted for */ for (i = a; i <= b; i++) { if (i % 2 == 0) { int found = 0; for (j = 0; j < num; j++) { arf_interval_get_arb(t, blocks + j, ARF_PREC_EXACT); if (arb_contains_si(t, i)) { found = 1; break; } } if (!found) { flint_printf("FAIL: missing root %wd\n", i); flint_printf("a = %wd, b = %wd, maxdepth = %wd, maxeval = %wd, maxfound = %wd, prec = %wd\n", a, b, maxdepth, maxeval, maxfound, prec); for (j = 0; j < num; j++) { arf_interval_printd(blocks + j, 15); flint_printf(" %d \n", info[i]); } abort(); } } } /* check that all reported single roots are good */ for (i = 0; i < num; i++) { if (info[i] == 1) { /* b contains unique 2n -> b/2 contains unique n */ arf_interval_get_arb(t, blocks + i, ARF_PREC_EXACT); arb_mul_2exp_si(t, t, -1); if (!arb_get_unique_fmpz(nn, t)) { flint_printf("FAIL: bad root %wd\n", i); flint_printf("a = %wd, b = %wd, maxdepth = %wd, maxeval = %wd, maxfound = %wd, prec = %wd\n", a, b, maxdepth, maxeval, maxfound, prec); for (j = 0; j < num; j++) { arf_interval_printd(blocks + j, 15); flint_printf(" %d \n", info[i]); } abort(); } } } _arf_interval_vec_clear(blocks, num); flint_free(info); arf_interval_clear(interval); arb_clear(t); fmpz_clear(nn); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("sin...."); fflush(stdout); flint_randinit(state); 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 = 8000; prec = 2 + n_randint(state, prec0); arb_init(a); arb_init(b); fmpq_init(q); mpfr_init2(t, prec0 + 100); arb_randtest(a, state, 1 + n_randint(state, prec0), 6); arb_randtest(b, state, 1 + n_randint(state, prec0), 6); arb_get_rand_fmpq(q, state, a, 1 + n_randint(state, prec0)); fmpq_get_mpfr(t, q, MPFR_RNDN); mpfr_sin(t, t, MPFR_RNDN); arb_sin(b, a, prec); if (!arb_contains_mpfr(b, t)) { flint_printf("FAIL: containment\n\n"); flint_printf("a = "); arb_print(a); flint_printf("\n\n"); flint_printf("b = "); arb_print(b); flint_printf("\n\n"); abort(); } arb_sin(a, a, prec); if (!arb_equal(a, b)) { flint_printf("FAIL: aliasing\n\n"); abort(); } arb_clear(a); arb_clear(b); fmpq_clear(q); mpfr_clear(t); } /* check large arguments */ for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++) { arb_t a, b, c, d; slong prec0, prec1, prec2; 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), prec0); arb_randtest_special(b, state, 1 + n_randint(state, prec0), 100); arb_randtest_special(c, state, 1 + n_randint(state, prec0), 100); arb_randtest_special(d, state, 1 + n_randint(state, prec0), 100); arb_sin(b, a, prec1); arb_sin(c, a, prec2); if (!arb_overlaps(b, c)) { 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"); abort(); } /* check sin(2a) = 2sin(a)cos(a) */ arb_mul_2exp_si(c, a, 1); arb_sin(c, c, prec1); arb_cos(d, a, prec1); arb_mul(b, b, d, prec1); arb_mul_2exp_si(b, b, 1); if (!arb_overlaps(b, c)) { 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"); abort(); } arb_clear(a); arb_clear(b); arb_clear(c); arb_clear(d); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { arf_interval_ptr blocks; arb_calc_func_t function; int * info; long digits, low_prec, high_prec, i, num, found_roots, found_unknown; long maxdepth, maxeval, maxfound; int refine; double a, b; arf_t C; arf_interval_t t, interval; arb_t v, w, z; if (argc < 4) { printf("real_roots function a b [-refine d] [-verbose] " "[-maxdepth n] [-maxeval n] [-maxfound n] [-prec n]\n"); printf("available functions:\n"); printf(" 0 Z(x), Riemann-Siegel Z-function\n"); printf(" 1 sin(x)\n"); printf(" 2 sin(x^2)\n"); printf(" 3 sin(1/x)\n"); return 1; } switch (atoi(argv[1])) { case 0: function = z_function; break; case 1: function = sin_x; break; case 2: function = sin_x2; break; case 3: function = sin_1x; break; default: printf("require a function 0-3\n"); return 1; } a = atof(argv[2]); b = atof(argv[3]); if (a >= b) { printf("require a < b!\n"); return 1; } refine = 0; digits = 0; maxdepth = 30; maxeval = 100000; maxfound = 100000; low_prec = 30; for (i = 4; i < argc; i++) { if (!strcmp(argv[i], "-refine")) { refine = 1; digits = atol(argv[i+1]); } else if (!strcmp(argv[i], "-verbose")) { arb_calc_verbose = 1; } else if (!strcmp(argv[i], "-maxdepth")) { maxdepth = atol(argv[i+1]); } else if (!strcmp(argv[i], "-maxeval")) { maxeval = atol(argv[i+1]); } else if (!strcmp(argv[i], "-maxfound")) { maxfound = atol(argv[i+1]); } else if (!strcmp(argv[i], "-prec")) { low_prec = atol(argv[i+1]); } } high_prec = digits * 3.32192809488736 + 10; found_roots = 0; found_unknown = 0; arf_init(C); arf_interval_init(t); arf_interval_init(interval); arb_init(v); arb_init(w); arb_init(z); arf_set_d(&interval->a, a); arf_set_d(&interval->b, b); printf("interval: "); arf_interval_printd(interval, 15); printf("\n"); printf("maxdepth = %ld, maxeval = %ld, maxfound = %ld, low_prec = %ld\n", maxdepth, maxeval, maxfound, low_prec); TIMEIT_ONCE_START num = arb_calc_isolate_roots(&blocks, &info, function, NULL, interval, maxdepth, maxeval, maxfound, low_prec); for (i = 0; i < num; i++) { if (info[i] != 1) { if (arb_calc_verbose) { printf("unable to count roots in "); arf_interval_printd(blocks + i, 15); printf("\n"); } found_unknown++; continue; } found_roots++; if (!refine) continue; if (arb_calc_refine_root_bisect(t, function, NULL, blocks + i, 5, low_prec) != ARB_CALC_SUCCESS) { printf("warning: some bisection steps failed!\n"); } if (arb_calc_verbose) { printf("after bisection 1: "); arf_interval_printd(t, 15); printf("\n"); } if (arb_calc_refine_root_bisect(blocks + i, function, NULL, t, 5, low_prec) != ARB_CALC_SUCCESS) { printf("warning: some bisection steps failed!\n"); } if (arb_calc_verbose) { printf("after bisection 2: "); arf_interval_printd(blocks + i, 15); printf("\n"); } arf_interval_get_arb(v, t, high_prec); arb_calc_newton_conv_factor(C, function, NULL, v, low_prec); arf_interval_get_arb(w, blocks + i, high_prec); if (arb_calc_refine_root_newton(z, function, NULL, w, v, C, 10, high_prec) != ARB_CALC_SUCCESS) { printf("warning: some newton steps failed!\n"); } printf("refined root:\n"); arb_printd(z, digits + 2); printf("\n\n"); } printf("---------------------------------------------------------------\n"); printf("Found roots: %ld\n", found_roots); printf("Subintervals possibly containing undetected roots: %ld\n", found_unknown); printf("Function evaluations: %ld\n", eval_count); TIMEIT_ONCE_STOP SHOW_MEMORY_USAGE for (i = 0; i < num; i++) arf_interval_clear(blocks + i); flint_free(blocks); flint_free(info); arf_interval_clear(t); arf_interval_clear(interval); arf_clear(C); arb_clear(v); arb_clear(w); arb_clear(z); flint_cleanup(); return 0; }
int main() { slong iter; flint_rand_t state; flint_printf("agm...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++) { arb_t a, b, c; fmpq_t q, r; mpfr_t t, u; slong prec = 2 + n_randint(state, 200); arb_init(a); arb_init(b); arb_init(c); fmpq_init(q); fmpq_init(r); mpfr_init2(t, prec + 100); mpfr_init2(u, prec + 100); arb_randtest(a, state, 1 + n_randint(state, 200), 3); arb_randtest(b, state, 1 + n_randint(state, 200), 3); arb_randtest(c, state, 1 + n_randint(state, 200), 3); arb_agm(c, a, b, prec); if (arb_equal(a, b)) { if (!arb_contains(c, a)) { flint_printf("FAIL: containment (identity)\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"); abort(); } } else { arb_get_rand_fmpq(q, state, a, 1 + n_randint(state, 200)); arb_get_rand_fmpq(r, state, b, 1 + n_randint(state, 200)); fmpq_get_mpfr(t, q, MPFR_RNDN); fmpq_get_mpfr(u, r, MPFR_RNDN); mpfr_agm(t, t, u, MPFR_RNDN); if (!arb_contains_mpfr(c, t)) { flint_printf("FAIL: containment\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"); abort(); } } arb_clear(a); arb_clear(b); arb_clear(c); fmpq_clear(q); fmpq_clear(r); mpfr_clear(t); mpfr_clear(u); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }