int main() { slong iter; flint_rand_t state; flint_printf("root_ui...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++) { acb_t a, b, c; ulong k; slong prec; prec = 2 + n_randint(state, 1000); k = n_randtest_not_zero(state); acb_init(a); acb_init(b); acb_init(c); acb_randtest(a, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100)); acb_randtest(b, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100)); acb_root_ui(b, a, k, prec); acb_pow_ui(c, b, k, prec); if (!acb_contains(c, a)) { flint_printf("FAIL: containment\n\n"); flint_printf("k = %wu\n", k); flint_printf("a = "); acb_print(a); flint_printf("\n\n"); flint_printf("b = "); acb_print(b); flint_printf("\n\n"); flint_printf("c = "); acb_print(c); flint_printf("\n\n"); flint_abort(); } acb_root_ui(a, a, k, prec); if (!acb_equal(a, b)) { flint_printf("FAIL: aliasing\n\n"); flint_abort(); } acb_clear(a); acb_clear(b); acb_clear(c); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("roots...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { acb_t x, y, z; acb_dirichlet_roots_t roots; ulong n, k; slong prec; slong iter2; n = 1 + n_randint(state, 1000); prec = 2 + n_randint(state, 200); acb_init(x); acb_init(y); acb_init(z); acb_dirichlet_roots_init(roots, n, n_randtest(state), prec); acb_unit_root(y, n, prec); for (iter2 = 0; iter2 <= FLINT_MIN(n, 20); iter2++) { k = n_randint(state, 2 * n); acb_dirichlet_root(x, roots, k, prec); acb_pow_ui(z, y, k, prec); if (!acb_overlaps(x, z)) { flint_printf("FAIL: overlap\n\n"); flint_printf("iter = %wd n = %wu k = %wu prec = %wd\n\n", iter, n, k, prec); flint_printf("x = "); acb_printn(x, 30, 0); flint_printf("\n\n"); flint_printf("z = "); acb_printn(z, 30, 0); flint_printf("\n\n"); flint_abort(); } } acb_dirichlet_roots_clear(roots); acb_clear(x); acb_clear(y); acb_clear(z); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
void acb_modular_delta(acb_t z, const acb_t tau, long prec) { psl2z_t g; arf_t one_minus_eps; acb_t tau_prime, t1, t2, t3, t4, q; psl2z_init(g); arf_init(one_minus_eps); acb_init(tau_prime); acb_init(t1); acb_init(t2); acb_init(t3); acb_init(t4); acb_init(q); arf_set_ui_2exp_si(one_minus_eps, 63, -6); acb_modular_fundamental_domain_approx(tau_prime, g, tau, one_minus_eps, prec); acb_exp_pi_i(q, tau_prime, prec); acb_modular_theta_const_sum(t2, t3, t4, q, prec); /* (t2 t3 t4) ^ 8 * q^2 */ acb_mul(t1, t2, t3, prec); acb_mul(t1, t1, t4, prec); acb_mul(t1, t1, t1, prec); acb_mul(t1, t1, t1, prec); acb_mul(t1, t1, q, prec); acb_mul(t1, t1, t1, prec); acb_mul_2exp_si(t1, t1, -8); if (!fmpz_is_zero(&g->c)) { acb_mul_fmpz(t2, tau, &g->c, prec); acb_add_fmpz(t2, t2, &g->d, prec); acb_pow_ui(t2, t2, 12, prec); acb_div(t1, t1, t2, prec); } acb_set(z, t1); psl2z_clear(g); arf_clear(one_minus_eps); acb_clear(tau_prime); acb_clear(t1); acb_clear(t2); acb_clear(t3); acb_clear(t4); acb_clear(q); }
void acb_mat_pow_ui(acb_mat_t B, const acb_mat_t A, ulong exp, long prec) { long d = acb_mat_nrows(A); if (exp <= 2 || d <= 1) { if (exp == 0 || d == 0) { acb_mat_one(B); } else if (d == 1) { acb_pow_ui(acb_mat_entry(B, 0, 0), acb_mat_entry(A, 0, 0), exp, prec); } else if (exp == 1) { acb_mat_set(B, A); } else if (exp == 2) { acb_mat_mul(B, A, A, prec); /* todo: sqr */ } } else { acb_mat_t T, U; long i; acb_mat_init(T, d, d); acb_mat_set(T, A); acb_mat_init(U, d, d); for (i = ((long) FLINT_BIT_COUNT(exp)) - 2; i >= 0; i--) { acb_mat_mul(U, T, T, prec); /* todo: sqr */ if (exp & (1L << i)) acb_mat_mul(T, U, A, prec); else acb_mat_swap(T, U); } acb_mat_swap(B, T); acb_mat_clear(T); acb_mat_clear(U); } }
/* f(z) = exp(-z) (I_0(z/k))^k, from Bruno Salvy */ int f_scaled_bessel(acb_ptr res, const acb_t z, void * param, slong order, slong prec) { acb_t nu; ulong k = ((ulong *) param)[0]; acb_init(nu); acb_div_ui(res, z, k, prec); acb_hypgeom_bessel_i_scaled(res, nu, res, prec); acb_pow_ui(res, res, k, prec); acb_clear(nu); return 0; }
/* f(z) = sech(10(x-0.2))^2 + sech(100(x-0.4))^4 + sech(1000(x-0.6))^6 */ int f_spike(acb_ptr res, const acb_t z, void * param, slong order, slong prec) { acb_t a, b, c; if (order > 1) flint_abort(); /* Would be needed for Taylor method. */ acb_init(a); acb_init(b); acb_init(c); acb_mul_ui(a, z, 10, prec); acb_sub_ui(a, a, 2, prec); acb_sech(a, a, prec); acb_pow_ui(a, a, 2, prec); acb_mul_ui(b, z, 100, prec); acb_sub_ui(b, b, 40, prec); acb_sech(b, b, prec); acb_pow_ui(b, b, 4, prec); acb_mul_ui(c, z, 1000, prec); acb_sub_ui(c, c, 600, prec); acb_sech(c, c, prec); acb_pow_ui(c, c, 6, prec); acb_add(res, a, b, prec); acb_add(res, res, c, prec); acb_clear(a); acb_clear(b); acb_clear(c); return 0; }
/* f(z) = exp(-z) z^1000 */ int f_factorial1000(acb_ptr res, const acb_t z, void * param, slong order, slong prec) { acb_t t; if (order > 1) flint_abort(); /* Would be needed for Taylor method. */ acb_init(t); acb_pow_ui(t, z, 1000, prec); acb_neg(res, z); acb_exp(res, res, prec); acb_mul(res, res, t, prec); acb_clear(t); return 0; }
void integrals_edge_factors_gc(acb_ptr res, const acb_t cab, const acb_t ba2, sec_t c, slong prec) { slong i; acb_t cj, ci; acb_init(cj); acb_init(ci); /* polynomial shift */ acb_vec_polynomial_shift(res, cab, c.g, prec); /* constants cj, j = 1 */ /* c_1 = (1-zeta^-1) ba2^(-d/2) (-I)^i * = 2 / ba2^(d/2) */ acb_pow_ui(cj, ba2, c.d / 2, prec); if (c.d % 2) { acb_t t; acb_init(t); acb_sqrt(t, ba2, prec); acb_mul(cj, cj, t, prec); acb_clear(t); } acb_inv(cj, cj, prec); acb_mul_2exp_si(cj, cj, 1); _acb_vec_scalar_mul(res, res, c.g, cj, prec); /* constant ci = -I * ba2*/ acb_one(ci); for (i = 1; i < c.g; i++) { acb_mul(ci, ci, ba2, prec); acb_div_onei(ci, ci); acb_mul(res + i, res + i, ci, prec); } acb_clear(ci); acb_clear(cj); }
int main() { slong iter; flint_rand_t state; flint_printf("eisenstein...."); fflush(stdout); flint_randinit(state); /* Test functional equation */ for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { acb_t tau1, tau2, t; acb_ptr r1, r2; slong e0, prec0, prec1, prec2, len1, len2, i; psl2z_t g; psl2z_init(g); acb_init(tau1); acb_init(tau2); 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); len1 = n_randint(state, 20); len2 = n_randint(state, 20); r1 = _acb_vec_init(len1); r2 = _acb_vec_init(len2); acb_randtest(tau1, state, prec0, e0); acb_randtest(tau2, state, prec0, e0); psl2z_randtest(g, state, 1 + n_randint(state, 200)); acb_modular_transform(tau2, g, tau1, prec0); acb_modular_eisenstein(r1, tau1, len1, prec1); acb_modular_eisenstein(r2, tau2, len2, prec2); for (i = 0; i < FLINT_MIN(len1, len2); i++) { acb_mul_fmpz(t, tau1, &g->c, prec1); acb_add_fmpz(t, t, &g->d, prec1); acb_pow_ui(t, t, 2 * i + 4, prec1); acb_mul(t, t, r1 + i, prec1); if (!acb_overlaps(t, r2 + i)) { flint_printf("FAIL (overlap)\n"); flint_printf("tau1 = "); acb_printd(tau1, 15); flint_printf("\n\n"); flint_printf("tau2 = "); acb_printd(tau2, 15); flint_printf("\n\n"); flint_printf("g = "); psl2z_print(g); flint_printf("\n\n"); flint_printf("r1 = "); acb_printd(r1 + i, 15); flint_printf("\n\n"); flint_printf("r2 = "); acb_printd(r2 + i, 15); flint_printf("\n\n"); flint_printf("t = "); acb_printd(t, 15); flint_printf("\n\n"); flint_abort(); } } acb_clear(tau1); acb_clear(tau2); acb_clear(t); _acb_vec_clear(r1, len1); _acb_vec_clear(r2, len2); psl2z_clear(g); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { long iter; flint_rand_t state; printf("lambda...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000; iter++) { acb_t tau1, tau2, z1, z2, z3, t; long e0, prec0, prec1, prec2, step; acb_init(tau1); acb_init(tau2); acb_init(z1); acb_init(z2); acb_init(z3); acb_init(t); e0 = 1 + n_randint(state, 100); prec0 = 2 + n_randint(state, 1000); prec1 = 2 + n_randint(state, 1000); prec2 = 2 + n_randint(state, 1000); acb_randtest(tau1, state, prec0, e0); acb_randtest(tau2, state, prec0, e0); acb_randtest(z1, state, prec0, e0); acb_randtest(z2, state, prec0, e0); acb_set(tau2, tau1); step = n_randint(state, 10); /* Test invariance */ while (step --> 0) { if (n_randint(state, 2)) { acb_add_ui(tau2, tau2, 2, prec0); } else { acb_mul_si(z1, tau2, -2, prec0); acb_add_ui(z1, z1, 1, prec0); acb_div(tau2, tau2, z1, prec0); } } acb_modular_lambda(z1, tau1, prec1); acb_modular_lambda(z2, tau2, prec2); /* Compare with eta */ acb_mul_2exp_si(tau1, tau1, -1); acb_modular_eta(z3, tau1, prec2); acb_mul_2exp_si(tau1, tau1, 2); acb_modular_eta(t, tau1, prec2); acb_mul(t, t, t, prec2); acb_mul(z3, z3, t, prec2); acb_mul_2exp_si(tau1, tau1, -1); acb_modular_eta(t, tau1, prec2); acb_pow_ui(t, t, 3, prec2); acb_div(z3, z3, t, prec2); acb_pow_ui(z3, z3, 8, prec2); acb_mul_2exp_si(z3, z3, 4); if (!acb_overlaps(z1, z2) || !acb_overlaps(z1, z3)) { printf("FAIL (overlap)\n"); printf("tau1 = "); acb_printd(tau1, 15); printf("\n\n"); printf("tau2 = "); acb_printd(tau2, 15); 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_lambda(tau1, tau1, prec2); if (!acb_overlaps(z1, tau1)) { printf("FAIL (aliasing)\n"); printf("tau1 = "); acb_printd(tau1, 15); printf("\n\n"); printf("tau2 = "); acb_printd(tau2, 15); printf("\n\n"); printf("z1 = "); acb_printd(z1, 15); printf("\n\n"); printf("z2 = "); acb_printd(z2, 15); printf("\n\n"); abort(); } acb_clear(tau1); acb_clear(tau2); acb_clear(z1); acb_clear(z2); acb_clear(z3); acb_clear(t); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
void acb_hypgeom_m(acb_t res, const acb_t a, const acb_t b, const acb_t z, int regularized, long prec) { long m = LONG_MAX; long n = LONG_MAX; if (acb_is_int(a) && arf_cmpabs_2exp_si(arb_midref(acb_realref(a)), 30) < 0) { m = arf_get_si(arb_midref(acb_realref(a)), ARF_RND_DOWN); } if (acb_is_int(b) && arf_cmpabs_2exp_si(arb_midref(acb_realref(b)), 30) < 0) { n = arf_get_si(arb_midref(acb_realref(b)), ARF_RND_DOWN); } /* terminating */ if (m <= 0 && m < n && m > -10 * prec && (n > 0 || !regularized)) { acb_hypgeom_m_1f1(res, a, b, z, regularized, prec); return; } /* large */ if (acb_hypgeom_u_use_asymp(z, prec)) { acb_hypgeom_m_asymp(res, a, b, z, regularized, prec); return; } /* remove singularity */ if (n <= 0 && n > -10 * prec && regularized) { acb_t c, d, t, u; acb_init(c); acb_init(d); acb_init(t); acb_init(u); acb_sub(c, a, b, prec); acb_add_ui(c, c, 1, prec); acb_neg(d, b); acb_add_ui(d, d, 2, prec); acb_hypgeom_m_1f1(t, c, d, z, 0, prec); acb_pow_ui(u, z, 1 - n, prec); acb_mul(t, t, u, prec); acb_rising_ui(u, a, 1 - n, prec); acb_mul(t, t, u, prec); arb_fac_ui(acb_realref(u), 1 - n, prec); acb_div_arb(res, t, acb_realref(u), prec); acb_clear(c); acb_clear(d); acb_clear(t); acb_clear(u); } else { acb_hypgeom_m_1f1(res, a, b, z, regularized, prec); } }
void _acb_hypgeom_m_1f1(acb_t res, const acb_t a, const acb_t b, const acb_t z, int regularized, slong prec, slong gamma_prec, int kummer) { if (regularized) { /* Remove singularity */ if (acb_is_int(b) && arb_is_nonpositive(acb_realref(b)) && arf_cmpabs_2exp_si(arb_midref(acb_realref(b)), 30) < 0) { acb_t c, d, t, u; slong n; n = arf_get_si(arb_midref(acb_realref(b)), ARF_RND_DOWN); acb_init(c); acb_init(d); acb_init(t); acb_init(u); acb_sub(c, a, b, prec); acb_add_ui(c, c, 1, prec); acb_neg(d, b); acb_add_ui(d, d, 2, prec); _acb_hypgeom_m_1f1(t, c, d, z, 0, prec, gamma_prec, kummer); acb_pow_ui(u, z, 1 - n, prec); acb_mul(t, t, u, prec); acb_rising_ui(u, a, 1 - n, prec); acb_mul(t, t, u, prec); arb_fac_ui(acb_realref(u), 1 - n, prec); acb_div_arb(res, t, acb_realref(u), prec); acb_clear(c); acb_clear(d); acb_clear(t); acb_clear(u); } else { acb_t t; acb_init(t); acb_rgamma(t, b, gamma_prec); _acb_hypgeom_m_1f1(res, a, b, z, 0, prec, gamma_prec, kummer); acb_mul(res, res, t, prec); acb_clear(t); } return; } /* Kummer's transformation */ if (kummer) { acb_t u, v; acb_init(u); acb_init(v); acb_sub(u, b, a, prec); acb_neg(v, z); _acb_hypgeom_m_1f1(u, u, b, v, regularized, prec, gamma_prec, 0); acb_exp(v, z, prec); acb_mul(res, u, v, prec); acb_clear(u); acb_clear(v); return; } if (acb_is_one(a)) { acb_hypgeom_pfq_direct(res, NULL, 0, b, 1, z, -1, prec); } else { acb_struct c[3]; c[0] = *a; c[1] = *b; acb_init(c + 2); acb_one(c + 2); acb_hypgeom_pfq_direct(res, c, 1, c + 1, 2, z, -1, prec); acb_clear(c + 2); } }
void _acb_poly_pow_ui_trunc_binexp(acb_ptr res, acb_srcptr f, long flen, ulong exp, long len, long prec) { acb_ptr v, R, S, T; long rlen; ulong bit; if (exp <= 1) { if (exp == 0) acb_one(res); else if (exp == 1) _acb_vec_set_round(res, f, len, prec); return; } /* (f * x^r)^m = x^(rm) * f^m */ while (flen > 1 && acb_is_zero(f)) { if (((ulong) len) > exp) { _acb_vec_zero(res, exp); len -= exp; res += exp; } else { _acb_vec_zero(res, len); return; } f++; flen--; } if (exp == 2) { _acb_poly_mullow(res, f, flen, f, flen, len, prec); return; } if (flen == 1) { acb_pow_ui(res, f, exp, prec); return; } v = _acb_vec_init(len); bit = 1UL << (FLINT_BIT_COUNT(exp) - 2); if (n_zerobits(exp) % 2) { R = res; S = v; } else { R = v; S = res; } MUL(R, rlen, f, flen, f, flen, len, prec); if (bit & exp) { MUL(S, rlen, R, rlen, f, flen, len, prec); T = R; R = S; S = T; } while (bit >>= 1) { if (bit & exp) { MUL(S, rlen, R, rlen, R, rlen, len, prec); MUL(R, rlen, S, rlen, f, flen, len, prec); } else { MUL(S, rlen, R, rlen, R, rlen, len, prec); T = R; R = S; S = T; } } _acb_vec_clear(v, len); }
void acb_elliptic_p_jet(acb_ptr r, const acb_t z, const acb_t tau, slong len, slong prec) { acb_t t01, t02, t03, t04; acb_ptr tz1, tz2, tz3, tz4; acb_t t; int real; slong k; if (len < 1) return; if (len == 1) { acb_elliptic_p(r, z, tau, prec); return; } real = acb_is_real(z) && arb_is_int_2exp_si(acb_realref(tau), -1) && arb_is_positive(acb_imagref(tau)); acb_init(t); acb_init(t01); acb_init(t02); acb_init(t03); acb_init(t04); tz1 = _acb_vec_init(len); tz2 = _acb_vec_init(len); tz3 = _acb_vec_init(len); tz4 = _acb_vec_init(len); acb_modular_theta_jet(tz1, tz2, tz3, tz4, z, tau, len, prec); /* [theta_4(z) / theta_1(z)]^2 */ _acb_poly_div_series(tz2, tz4, len, tz1, len, len, prec); _acb_poly_mullow(tz1, tz2, len, tz2, len, len, prec); acb_zero(t); acb_modular_theta(t01, t02, t03, t04, t, tau, prec); /* [theta_2(0) * theta_3(0)] ^2 */ acb_mul(t, t02, t03, prec); acb_mul(t, t, t, prec); _acb_vec_scalar_mul(tz1, tz1, len, t, prec); /* - [theta_2(0)^4 + theta_3(0)^4] / 3 */ acb_pow_ui(t02, t02, 4, prec); acb_pow_ui(t03, t03, 4, prec); acb_add(t, t02, t03, prec); acb_div_ui(t, t, 3, prec); acb_sub(tz1, tz1, t, prec); /* times pi^2 */ acb_const_pi(t, prec); acb_mul(t, t, t, prec); _acb_vec_scalar_mul(r, tz1, len, t, prec); if (real) { for (k = 0; k < len; k++) arb_zero(acb_imagref(r + k)); } acb_clear(t); acb_clear(t01); acb_clear(t02); acb_clear(t03); acb_clear(t04); _acb_vec_clear(tz1, len); _acb_vec_clear(tz2, len); _acb_vec_clear(tz3, len); _acb_vec_clear(tz4, len); }
int main() { long iter; flint_rand_t state; printf("det...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000; iter++) { fmpq_mat_t Q; fmpq_t Qdet; acb_mat_t A; acb_t Adet, imagunit; long n, qbits, prec; int imaginary; n = n_randint(state, 8); qbits = 1 + n_randint(state, 100); prec = 2 + n_randint(state, 200); imaginary = n_randint(state, 2); fmpq_mat_init(Q, n, n); fmpq_init(Qdet); acb_mat_init(A, n, n); acb_init(Adet); acb_init(imagunit); fmpq_mat_randtest(Q, state, qbits); fmpq_mat_det(Qdet, Q); acb_mat_set_fmpq_mat(A, Q, prec); if (imaginary) { acb_onei(imagunit); acb_mat_scalar_mul_acb(A, A, imagunit, prec); } acb_mat_det(Adet, A, prec); if (imaginary) { acb_onei(imagunit); acb_inv(imagunit, imagunit, prec); acb_pow_ui(imagunit, imagunit, n, prec); acb_mul(Adet, Adet, imagunit, prec); } if (!acb_contains_fmpq(Adet, Qdet)) { printf("FAIL (containment, iter = %ld)\n", iter); printf("n = %ld, prec = %ld\n", n, prec); printf("\n"); printf("Q = \n"); fmpq_mat_print(Q); printf("\n\n"); printf("Qdet = \n"); fmpq_print(Qdet); printf("\n\n"); printf("A = \n"); acb_mat_printd(A, 15); printf("\n\n"); printf("Adet = \n"); acb_printd(Adet, 15); printf("\n\n"); printf("Adet = \n"); acb_print(Adet); printf("\n\n"); abort(); } fmpq_mat_clear(Q); fmpq_clear(Qdet); acb_mat_clear(A); acb_clear(Adet); acb_clear(imagunit); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main() { long iter; flint_rand_t state; printf("delta...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000; iter++) { acb_t tau, z1, z2; long e0, prec0, prec1, prec2; acb_init(tau); acb_init(z1); acb_init(z2); e0 = 1 + n_randint(state, 10); prec0 = 2 + n_randint(state, 1000); prec1 = 2 + n_randint(state, 1000); prec2 = 2 + n_randint(state, 1000); acb_randtest(tau, state, prec0, e0); acb_randtest(z1, state, prec0, e0); acb_randtest(z2, state, prec0, e0); /* compare with eta */ acb_modular_delta(z1, tau, prec1); acb_modular_eta(z2, tau, prec2); acb_pow_ui(z2, z2, 24, prec2); if (!acb_overlaps(z1, z2)) { printf("FAIL (overlap)\n"); printf("tau = "); acb_printd(tau, 15); printf("\n\n"); printf("z1 = "); acb_printd(z1, 15); printf("\n\n"); printf("z2 = "); acb_printd(z2, 15); printf("\n\n"); abort(); } acb_modular_delta(tau, tau, prec1); if (!acb_overlaps(z1, tau)) { printf("FAIL (aliasing)\n"); printf("tau = "); acb_printd(tau, 15); printf("\n\n"); printf("z1 = "); acb_printd(z1, 15); printf("\n\n"); printf("z2 = "); acb_printd(z2, 15); printf("\n\n"); abort(); } acb_clear(tau); acb_clear(z1); acb_clear(z2); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }