/* f(z) = erf(z/sqrt(0.0002)*0.5 +1.5)*exp(-z), example provided by Silviu-Ioan Filip */
int
f_erf_bent(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_set_ui(t, 1250);
acb_sqrt(t, t, prec);
acb_mul(t, t, z, prec);
acb_set_d(res, 1.5);
acb_add(res, res, t, prec);
acb_hypgeom_erf(res, res, prec);
acb_neg(t, z);
acb_exp(t, t, prec);
acb_mul(res, res, t, prec);
acb_clear(t);
return 0;
}
/* REAL: erf(x) = 2x/sqrt(pi) * exp(-x^2) 1F1(1, 3/2, x^2) */
void
acb_hypgeom_erf_1f1b(acb_t res, const acb_t z, slong prec)
{
acb_t a, b, t, w;
acb_init(a);
acb_init(b);
acb_init(t);
acb_init(w);
acb_set_ui(b, 3);
acb_mul_2exp_si(b, b, -1);
acb_mul(w, z, z, prec);
acb_hypgeom_pfq_direct(t, a, 0, b, 1, w, -1, prec);
acb_neg(w, w);
acb_exp(w, w, prec);
acb_mul(t, t, w, prec);
acb_mul(t, t, z, prec);
arb_const_sqrt_pi(acb_realref(w), prec);
acb_div_arb(t, t, acb_realref(w), prec);
acb_mul_2exp_si(res, t, 1);
acb_clear(a);
acb_clear(b);
acb_clear(t);
acb_clear(w);
}
void
_acb_hypgeom_const_li2_eval(arb_t s, long prec)
{
acb_t t;
acb_init(t);
acb_set_ui(t, 2);
_acb_hypgeom_li(t, t, prec);
arb_set(s, acb_realref(t));
acb_clear(t);
}
void
_acb_poly_compose_series_brent_kung(acb_ptr res,
acb_srcptr poly1, long len1,
acb_srcptr poly2, long len2, long n, long prec)
{
acb_mat_t A, B, C;
acb_ptr t, h;
long i, m;
if (n == 1)
{
acb_set(res, poly1);
return;
}
m = n_sqrt(n) + 1;
acb_mat_init(A, m, n);
acb_mat_init(B, m, m);
acb_mat_init(C, m, n);
h = _acb_vec_init(n);
t = _acb_vec_init(n);
/* Set rows of B to the segments of poly1 */
for (i = 0; i < len1 / m; i++)
_acb_vec_set(B->rows[i], poly1 + i*m, m);
_acb_vec_set(B->rows[i], poly1 + i*m, len1 % m);
/* Set rows of A to powers of poly2 */
acb_set_ui(A->rows[0] + 0, 1UL);
_acb_vec_set(A->rows[1], poly2, len2);
for (i = 2; i < m; i++)
_acb_poly_mullow(A->rows[i], A->rows[(i + 1) / 2], n, A->rows[i / 2], n, n, prec);
acb_mat_mul(C, B, A, prec);
/* Evaluate block composition using the Horner scheme */
_acb_vec_set(res, C->rows[m - 1], n);
_acb_poly_mullow(h, A->rows[m - 1], n, poly2, len2, n, prec);
for (i = m - 2; i >= 0; i--)
{
_acb_poly_mullow(t, res, n, h, n, n, prec);
_acb_poly_add(res, t, n, C->rows[i], n, prec);
}
_acb_vec_clear(h, n);
_acb_vec_clear(t, n);
acb_mat_clear(A);
acb_mat_clear(B);
acb_mat_clear(C);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("cauchy_bound....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100; iter++)
{
arb_t b, radius, ans;
acb_t x;
slong r, prec, maxdepth;
arb_init(b);
arb_init(radius);
arb_init(ans);
acb_init(x);
acb_set_ui(x, 5);
r = 1 + n_randint(state, 10);
arb_set_ui(radius, r);
prec = 2 + n_randint(state, 100);
maxdepth = n_randint(state, 10);
acb_calc_cauchy_bound(b, sin_x, NULL, x, radius, maxdepth, prec);
arf_set_d(arb_midref(ans), answers[r-1]);
mag_set_d(arb_radref(ans), 1e-8);
if (!arb_overlaps(b, ans))
{
flint_printf("FAIL\n");
flint_printf("r = %wd, prec = %wd, maxdepth = %wd\n\n", r, prec, maxdepth);
arb_printd(b, 15); flint_printf("\n\n");
arb_printd(ans, 15); flint_printf("\n\n");
abort();
}
arb_clear(b);
arb_clear(radius);
arb_clear(ans);
acb_clear(x);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
acb_hypgeom_ci_2f3(acb_t res, const acb_t z, slong prec)
{
acb_t a, t, u;
acb_struct b[3];
acb_init(a);
acb_init(b);
acb_init(b + 1);
acb_init(b + 2);
acb_init(t);
acb_init(u);
acb_one(a);
acb_set_ui(b, 2);
acb_set(b + 1, b);
acb_set_ui(b + 2, 3);
acb_mul_2exp_si(b + 2, b + 2, -1);
acb_mul(t, z, z, prec);
acb_mul_2exp_si(t, t, -2);
acb_neg(t, t);
acb_hypgeom_pfq_direct(u, a, 1, b, 3, t, -1, prec);
acb_mul(u, u, t, prec);
acb_log(t, z, prec);
acb_add(u, u, t, prec);
arb_const_euler(acb_realref(t), prec);
arb_add(acb_realref(u), acb_realref(u), acb_realref(t), prec);
acb_swap(res, u);
acb_clear(a);
acb_clear(b);
acb_clear(b + 1);
acb_clear(b + 2);
acb_clear(t);
acb_clear(u);
}
void
acb_dirichlet_l(acb_t res, const acb_t s,
const acb_dirichlet_group_t G, ulong m, slong prec)
{
acb_t chi, t, u, a;
ulong k;
acb_init(chi);
acb_init(t);
acb_init(u);
acb_init(a);
acb_zero(t);
for (k = 1; k <= G->q; k++)
{
acb_dirichlet_chi(chi, G, m, k, prec);
if (!acb_is_zero(chi))
{
acb_set_ui(a, k);
acb_div_ui(a, a, G->q, prec);
acb_hurwitz_zeta(u, s, a, prec);
acb_addmul(t, chi, u, prec);
}
}
acb_set_ui(u, G->q);
acb_neg(a, s);
acb_pow(u, u, a, prec);
acb_mul(res, t, u, prec);
acb_clear(chi);
acb_clear(t);
acb_clear(u);
acb_clear(a);
}
acb_t *fft_init(long n,long prec) {
long i,halfn,*base;
acb_t *x,*w;
base = (long *)malloc(2*sizeof(long)+3*n/2*sizeof(acb_t));
if (!base) return (acb_t *)0;
base[0] = n;
base[1] = prec;
x = (acb_t *)&base[2];
w = x+n;
halfn = n>>1;
for (i=0;i<n;i++)
acb_init(x[i]);
for (i=0;i<halfn;i++) {
acb_init(w[i]);
acb_set_ui(w[i],i);
acb_div_ui(w[i],w[i],halfn,prec);
acb_exp_pi_i(w[i],w[i],prec);
}
return x;
}
/* IMAG: erf(z) = 2z/sqrt(pi) * 1F1(1/2, 3/2, -z^2) */
void
acb_hypgeom_erf_1f1a(acb_t res, const acb_t z, slong prec)
{
acb_t a, t, w;
acb_struct b[2];
acb_init(a);
acb_init(b);
acb_init(b + 1);
acb_init(t);
acb_init(w);
acb_one(a);
acb_mul_2exp_si(a, a, -1);
acb_set_ui(b, 3);
acb_mul_2exp_si(b, b, -1);
acb_one(b + 1);
acb_mul(w, z, z, prec);
acb_neg(w, w);
acb_hypgeom_pfq_direct(t, a, 1, b, 2, w, -1, prec);
acb_const_pi(w, prec);
acb_rsqrt(w, w, prec);
acb_mul(t, t, w, prec);
acb_mul(t, t, z, prec);
acb_mul_2exp_si(res, t, 1);
acb_clear(a);
acb_clear(b);
acb_clear(b + 1);
acb_clear(t);
acb_clear(w);
}
void
acb_dirichlet_hurwitz_precomp_init(acb_dirichlet_hurwitz_precomp_t pre,
const acb_t s, int deflate, slong A, slong K, slong N, slong prec)
{
slong i, k;
if (A < 1 || K < 1 || N < 1)
abort();
pre->deflate = deflate;
pre->A = A;
pre->K = K;
pre->N = N;
pre->coeffs = _acb_vec_init(N * K);
mag_init(&pre->err);
acb_init(&pre->s);
acb_set(&pre->s, s);
acb_dirichlet_hurwitz_precomp_bound(&pre->err, s, A, K, N);
if (mag_is_finite(&pre->err))
{
acb_t t, a;
acb_init(t);
acb_init(a);
/* (-1)^k (s)_k / k! */
acb_one(pre->coeffs + 0);
for (k = 1; k < K; k++)
{
acb_add_ui(pre->coeffs + k, s, k - 1, prec);
acb_mul(pre->coeffs + k, pre->coeffs + k, pre->coeffs + k - 1, prec);
acb_div_ui(pre->coeffs + k, pre->coeffs + k, k, prec);
acb_neg(pre->coeffs + k, pre->coeffs + k);
}
for (i = 1; i < N; i++)
_acb_vec_set(pre->coeffs + i * K, pre->coeffs, K);
/* zeta(s+k,a) where a = A + (2*i+1)/(2*N) */
for (i = 0; i < N; i++)
{
acb_set_ui(a, 2 * i + 1);
acb_div_ui(a, a, 2 * N, prec);
acb_add_ui(a, a, A, prec);
for (k = 0; k < K; k++)
{
acb_add_ui(t, s, k, prec);
if (deflate && k == 0)
_acb_poly_zeta_cpx_series(t, t, a, 1, 1, prec);
else
acb_hurwitz_zeta(t, t, a, prec);
acb_mul(pre->coeffs + i * K + k,
pre->coeffs + i * K + k, t, prec);
}
}
acb_clear(t);
acb_clear(a);
}
}
void
acb_hypgeom_pfq_sum_fme(acb_t s, acb_t t,
acb_srcptr a, slong p, acb_srcptr b, slong q,
const acb_t z, slong n, slong prec)
{
acb_poly_t A, B, C;
acb_ptr ks, As, Bs, Cs;
acb_t u, v;
acb_ptr * tree;
slong i, k, m, w;
/* we compute to n-1 instead of n to avoid dividing by 0 in the
denominator when computing a hypergeometric polynomial
that terminates right before a pole */
if (n > 4)
{
m = n_sqrt(n - 1) / 4; /* tuning parameter */
w = (n - 1) / FLINT_MAX(m, 1);
}
else
{
m = w = 0;
}
if (m < 1 || w < 1 || p > 3 || q > 3)
{
acb_hypgeom_pfq_sum_forward(s, t, a, p, b, q, z, n, prec);
return;
}
acb_poly_init(A);
acb_poly_init(B);
acb_poly_init(C);
acb_init(u);
acb_init(v);
ks = _acb_vec_init(w);
As = _acb_vec_init(w);
Bs = _acb_vec_init(w);
Cs = _acb_vec_init(w);
bsplit(A, B, C, a, p, b, q, z, 0, m, prec);
for (i = 0; i < w; i++)
acb_set_ui(ks + i, i * m);
tree = _acb_poly_tree_alloc(w);
_acb_poly_tree_build(tree, ks, w, prec);
_acb_poly_evaluate_vec_fast_precomp(As, A->coeffs, A->length, tree, w, prec);
_acb_poly_evaluate_vec_fast_precomp(Bs, B->coeffs, B->length, tree, w, prec);
_acb_poly_evaluate_vec_fast_precomp(Cs, C->coeffs, C->length, tree, w, prec);
_acb_poly_tree_free(tree, w);
/* todo: use binary splitting here for improved numerical stability */
for (i = 1; i < w; i++)
{
acb_mul(Cs, Cs, Bs + i, prec);
acb_addmul(Cs, As, Cs + i, prec);
acb_mul(As, As, As + i, prec);
acb_mul(Bs, Bs, Bs + i, prec);
}
acb_div(s, Cs, Bs, prec);
acb_div(t, As, Bs, prec);
for (k = w * m; k < n && !acb_is_zero(t); k++)
{
acb_add(s, s, t, prec);
if (p > 0)
{
acb_add_ui(u, a, k, prec);
for (i = 1; i < p; i++)
{
acb_add_ui(v, a + i, k, prec);
acb_mul(u, u, v, prec);
}
acb_mul(t, t, u, prec);
}
if (q > 0)
{
acb_add_ui(u, b, k, prec);
for (i = 1; i < q; i++)
{
acb_add_ui(v, b + i, k, prec);
acb_mul(u, u, v, prec);
}
acb_div(t, t, u, prec);
}
acb_mul(t, t, z, prec);
}
acb_clear(u);
acb_clear(v);
_acb_vec_clear(ks, w);
_acb_vec_clear(As, w);
_acb_vec_clear(Bs, w);
_acb_vec_clear(Cs, w);
acb_poly_clear(A);
acb_poly_clear(B);
acb_poly_clear(C);
}
void
_acb_hypgeom_legendre_q_single(acb_t res, const acb_t n, const acb_t m,
const acb_t z, slong prec)
{
acb_t a, b, c, z2, t, u;
acb_init(a);
acb_init(b);
acb_init(c);
acb_init(z2);
acb_init(t);
acb_init(u);
/* invalid in (-1,0) */
if (!_acb_hypgeom_legendre_q_single_valid(z))
{
acb_indeterminate(res);
return;
}
acb_pow_si(z2, z, -2, prec); /* z2 = 1/z^2 */
/* t = 2F1r((m+n+1)/2, (m+n)/2+1, n+3/2, 1/z^2) */
acb_add(b, m, n, prec);
acb_add_ui(a, b, 1, prec);
acb_mul_2exp_si(a, a, -1);
acb_mul_2exp_si(b, b, -1);
acb_add_ui(b, b, 1, prec);
acb_set_ui(c, 3);
acb_mul_2exp_si(c, c, -1);
acb_add(c, c, n, prec);
acb_hypgeom_2f1(t, a, b, c, z2, 1, prec);
/* prefactor sqrt(pi) 2^-n (z+1)^(m/2) (z-1)^(m/2) exp(i pi m) */
/* (1/2) gamma(m+n+1) z^(-m-n-1) */
if (!acb_is_zero(m))
{
acb_add_ui(z2, z, 1, prec);
acb_mul_2exp_si(c, m, -1);
acb_pow(z2, z2, c, prec);
acb_mul(t, t, z2, prec);
acb_sub_ui(z2, z, 1, prec);
acb_mul_2exp_si(c, m, -1);
acb_pow(z2, z2, c, prec);
acb_mul(t, t, z2, prec);
acb_exp_pi_i(z2, m, prec);
acb_mul(t, t, z2, prec);
}
acb_set_ui(z2, 2);
acb_neg(c, n);
acb_pow(z2, z2, c, prec);
acb_mul(t, t, z2, prec);
acb_add(c, m, n, prec);
acb_add_ui(c, c, 1, prec);
acb_gamma(z2, c, prec);
acb_mul(t, t, z2, prec);
acb_neg(c, c);
acb_pow(z2, z, c, prec);
acb_mul(t, t, z2, prec);
acb_mul_2exp_si(t, t, -1);
arb_const_sqrt_pi(acb_realref(u), prec);
acb_mul_arb(t, t, acb_realref(u), prec);
acb_set(res, t);
acb_clear(a);
acb_clear(b);
acb_clear(c);
acb_clear(z2);
acb_clear(t);
acb_clear(u);
}
void
acb_modular_theta_const_sum_basecase(acb_t theta2, acb_t theta3, acb_t theta4,
const acb_t q, slong N, slong prec)
{
slong * tab;
slong k, term_prec;
double log2q_approx, log2term_approx;
mag_t qmag;
acb_ptr qpow;
acb_t s1, s2, s3, t1, t2;
if (N < 2)
{
acb_set_ui(theta2, 2 * (N > 0));
acb_set_ui(theta3, N > 0);
acb_set(theta4, theta3);
return;
}
if (N < 25)
{
acb_t q1, q2, q4, q8, q16;
acb_init(q1);
acb_init(q2);
acb_init(q4);
acb_init(q8);
acb_init(q16);
acb_set_round(q1, q, prec);
if (N > 2) acb_mul(q2, q1, q1, prec);
if (N > 4) acb_mul(q4, q2, q2, prec);
if (N > 9) acb_mul(q8, q4, q4, prec);
if (N > 16) acb_mul(q16, q8, q8, prec);
/* theta2 = 2 + 2q^2 + 2q^4 [2q^2 + 2q^8 + 2q^16] */
if (N > 6)
{
if (N > 12)
{
acb_add(theta2, q2, q8, prec);
if (N > 20)
acb_add(theta2, theta2, q16, prec);
acb_mul(theta2, theta2, q4, prec);
}
else
{
acb_mul(theta2, q2, q4, prec);
}
acb_add(theta2, theta2, q2, prec);
acb_add_ui(theta2, theta2, 1, prec);
}
else if (N > 2)
acb_add_ui(theta2, q2, 1, prec);
else
acb_one(theta2);
acb_mul_2exp_si(theta2, theta2, 1);
/* theta3 = [1 + 2q^4 + 2q^16] + [2q + 2q^9] */
/* theta4 = [1 + 2q^4 + 2q^16] - [2q + 2q^9] */
if (N > 4)
{
if (N > 16)
acb_add(q4, q4, q16, prec);
acb_mul_2exp_si(q4, q4, 1);
acb_add_ui(q4, q4, 1, prec);
if (N > 9)
acb_addmul(q1, q1, q8, prec);
acb_mul_2exp_si(q1, q1, 1);
acb_add(theta3, q4, q1, prec);
acb_sub(theta4, q4, q1, prec);
}
else
{
acb_mul_2exp_si(q1, q1, 1);
acb_add_ui(theta3, q1, 1, prec);
acb_sub_ui(theta4, q1, 1, prec);
acb_neg(theta4, theta4);
}
acb_clear(q1);
acb_clear(q2);
acb_clear(q4);
acb_clear(q8);
acb_clear(q16);
return;
}
mag_init(qmag);
acb_init(s1);
acb_init(s2);
acb_init(s3);
acb_init(t1);
acb_init(t2);
tab = flint_calloc(N, sizeof(slong));
qpow = _acb_vec_init(N);
for (k = 0; k*(k+1) < N; k++) tab[k*(k+1)] = -1;
for (k = 0; 4*k*k < N; k++) tab[4*k*k] = -1;
for (k = 0; 4*k*(k+1) + 1 < N; k++) tab[4*k*(k+1)] = -1;
if (N > 0) tab[0] = 0;
if (N > 1) tab[1] = 1;
acb_modular_fill_addseq(tab, N);
acb_get_mag(qmag, q);
log2q_approx = mag_get_log2_d_approx(qmag);
for (k = 0; k < N; k++)
{
if (k == 0)
{
acb_one(qpow + k);
}
else if (k == 1)
{
acb_set_round(qpow + k, q, prec);
}
else if (tab[k] != 0)
{
log2term_approx = k * log2q_approx;
term_prec = FLINT_MIN(FLINT_MAX(prec + log2term_approx + 16.0, 16.0), prec);
acb_mul_approx(qpow + k, t1, t2, qpow + tab[k], qpow + k - tab[k], term_prec, prec);
}
}
for (k = 0; k*(k+1) < N; k++) acb_add(s1, s1, qpow + k*(k+1), prec);
for (k = 1; 4*k*k < N; k++) acb_add(s2, s2, qpow + 4*k*k, prec);
for (k = 0; 4*k*(k+1) + 1 < N; k++) acb_add(s3, s3, qpow + 4*k*(k+1), prec);
/*
theta2 = 2 + 2q^2 + 2q^6 + 2q^12 + 2q^20 + 2q^30 + ...
theta3 = 1 + 2 (q^4 + q^16 + ...) + 2q (1 + q^8 + q^24 + ...)
theta4 = 1 + 2 (q^4 + q^16 + ...) - 2q (1 + q^8 + q^24 + ...)
*/
acb_mul(s3, s3, q, prec);
acb_mul_2exp_si(s3, s3, 1);
acb_mul_2exp_si(s2, s2, 1);
acb_add(theta3, s2, s3, prec);
acb_sub(theta4, s2, s3, prec);
acb_add_ui(theta3, theta3, 1, prec);
acb_add_ui(theta4, theta4, 1, prec);
acb_mul_2exp_si(theta2, s1, 1);
_acb_vec_clear(qpow, N);
flint_free(tab);
acb_clear(s1);
acb_clear(s2);
acb_clear(s3);
acb_clear(t1);
acb_clear(t2);
mag_clear(qmag);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("l_euler_product....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 500 * arb_test_multiplier(); iter++)
{
acb_t s, t, u;
dirichlet_group_t G;
dirichlet_char_t chi;
ulong q, k;
slong prec;
acb_init(s);
acb_init(t);
acb_init(u);
q = 1 + n_randint(state, 50);
prec = 2 + n_randint(state, 500);
k = n_randint(state, n_euler_phi(q));
dirichlet_group_init(G, q);
dirichlet_char_init(chi, G);
dirichlet_char_index(chi, G, k);
if (n_randint(state, 2))
{
acb_set_ui(s, 2 + n_randint(state, prec + 50));
}
else
{
acb_randtest(s, state, 2 + n_randint(state, 200), 2);
arb_abs(acb_realref(s), acb_realref(s));
if (n_randint(state, 2))
acb_add_ui(s, s, n_randtest(state), prec);
}
if (n_randint(state, 2))
acb_dirichlet_l_hurwitz(t, s, NULL, G, chi, prec);
else
acb_dirichlet_l_euler_product(t, s, G, chi, prec * 1.5);
acb_dirichlet_l_euler_product(u, s, G, chi, prec);
if (!acb_overlaps(t, u))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("iter = %ld q = %lu k = %lu prec = %ld\n\n", iter, q, k, prec);
flint_printf("s = "); acb_printn(s, 100, 0); flint_printf("\n\n");
flint_printf("t = "); acb_printn(t, 100, 0); flint_printf("\n\n");
flint_printf("u = "); acb_printn(u, 100, 0); flint_printf("\n\n");
abort();
}
dirichlet_char_clear(chi);
dirichlet_group_clear(G);
acb_clear(s);
acb_clear(t);
acb_clear(u);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
acb_hypgeom_legendre_q(acb_t res, const acb_t n, const acb_t m,
const acb_t z, int type, slong prec)
{
if (type == 0)
{
/* http://functions.wolfram.com/07.11.26.0033.01 */
/* todo: simplify the gamma quotients and the sqrt pi factor... */
acb_t a, b, c, z2, mn, nm, t, u;
acb_init(a);
acb_init(b);
acb_init(c);
acb_init(z2);
acb_init(mn);
acb_init(nm);
acb_init(t);
acb_init(u);
acb_add(mn, m, n, prec); /* mn = m + n */
acb_sub(nm, n, m, prec); /* nm = n - m */
acb_mul(z2, z, z, prec); /* z2 = z^2 */
/* t = 2F1((1-m-n)/2, (n-m)/2+1, 3/2, z^2) */
acb_sub_ui(a, mn, 1, prec);
acb_neg(a, a);
acb_mul_2exp_si(a, a, -1);
acb_mul_2exp_si(b, nm, -1);
acb_add_ui(b, b, 1, prec);
acb_set_ui(c, 3);
acb_mul_2exp_si(c, c, -1);
acb_hypgeom_2f1(t, a, b, c, z2, 0, prec);
/* u = 2F1(-(m+n)/2, (n-m+1)/2, 1/2, z^2) */
acb_neg(a, mn);
acb_mul_2exp_si(a, a, -1);
acb_add_ui(b, nm, 1, prec);
acb_mul_2exp_si(b, b, -1);
acb_one(c);
acb_mul_2exp_si(c, c, -1);
acb_hypgeom_2f1(u, a, b, c, z2, 0, prec);
/* a = cospi((m+n)/2) gamma((m+n)/2+1) rgamma((n-m+1)/2) z */
/* b = sinpi((m+n)/2) gamma((m+n+1)/2) rgamma((n-m)/2+1) / 2 */
acb_mul_2exp_si(a, mn, -1);
acb_sin_cos_pi(b, a, a, prec);
acb_mul_2exp_si(c, mn, -1);
acb_add_ui(c, c, 1, prec);
acb_gamma(c, c, prec);
acb_mul(a, a, c, prec);
acb_add_ui(c, nm, 1, prec);
acb_mul_2exp_si(c, c, -1);
acb_rgamma(c, c, prec);
acb_mul(a, a, c, prec);
acb_mul(a, a, z, prec);
acb_add_ui(c, mn, 1, prec);
acb_mul_2exp_si(c, c, -1);
acb_gamma(c, c, prec);
acb_mul(b, b, c, prec);
acb_mul_2exp_si(c, nm, -1);
acb_add_ui(c, c, 1, prec);
acb_rgamma(c, c, prec);
acb_mul(b, b, c, prec);
acb_mul_2exp_si(b, b, -1);
/* at - bu */
acb_mul(t, t, a, prec);
acb_mul(u, u, b, prec);
acb_sub(t, t, u, prec);
/* prefactor sqrt(pi) 2^m (1-z^2)^(-m/2) */
if (!acb_is_zero(m))
{
acb_sub_ui(u, z2, 1, prec);
acb_neg(u, u);
acb_neg(c, m);
acb_mul_2exp_si(c, c, -1);
acb_pow(u, u, c, prec);
acb_set_ui(c, 2);
acb_pow(c, c, m, prec);
acb_mul(u, u, c, prec);
acb_mul(t, t, u, prec);
}
arb_const_sqrt_pi(acb_realref(u), prec);
acb_mul_arb(t, t, acb_realref(u), prec);
acb_set(res, t);
acb_clear(a);
acb_clear(b);
acb_clear(c);
acb_clear(z2);
acb_clear(mn);
acb_clear(nm);
acb_clear(t);
acb_clear(u);
}
else if (type == 1)
{
if ((arf_cmpabs_2exp_si(arb_midref(acb_realref(z)), -2) < 0 &&
arf_cmpabs_2exp_si(arb_midref(acb_imagref(z)), -2) < 0) ||
!_acb_hypgeom_legendre_q_single_valid(z))
{
_acb_hypgeom_legendre_q_double(res, n, m, z, prec);
}
else
{
_acb_hypgeom_legendre_q_single(res, n, m, z, prec);
}
}
else
{
flint_printf("unsupported 'type' %d for legendre q\n", type);
abort();
}
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("bernoulli_poly_ui....");
fflush(stdout);
flint_randinit(state);
/* test multiplication theorem */
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
acb_t x, t, res1, res2;
ulong n, m, k;
slong prec;
n = n_randint(state, 50);
m = 1 + n_randint(state, 5);
prec = 2 + n_randint(state, 200);
acb_init(x);
acb_init(t);
acb_init(res1);
acb_init(res2);
acb_randtest(x, state, 2 + n_randint(state, 200), 20);
acb_randtest(res1, state, 2 + n_randint(state, 200), 20);
acb_mul_ui(t, x, m, prec);
acb_bernoulli_poly_ui(res1, n, t, prec);
acb_zero(res2);
for (k = 0; k < m; k++)
{
acb_set_ui(t, k);
acb_div_ui(t, t, m, prec);
acb_add(t, t, x, prec);
acb_bernoulli_poly_ui(t, n, t, prec);
acb_add(res2, res2, t, prec);
}
if (n > 0)
{
arb_ui_pow_ui(acb_realref(t), m, n - 1, prec);
acb_mul_arb(res2, res2, acb_realref(t), prec);
}
else
{
acb_div_ui(res2, res2, m, prec);
}
if (!acb_overlaps(res1, res2))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("n = %wu, m = %wu\n\n", n, m);
flint_printf("x = "); acb_printd(x, 15); flint_printf("\n\n");
flint_printf("res1 = "); acb_printd(res1, 15); flint_printf("\n\n");
flint_printf("res2 = "); acb_printd(res2, 15); flint_printf("\n\n");
abort();
}
acb_clear(x);
acb_clear(t);
acb_clear(res1);
acb_clear(res2);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
acb_t s, t, a, b;
mag_t tol;
slong prec, goal;
slong N;
ulong k;
int integral, ifrom, ito;
int i, twice, havegoal, havetol;
acb_calc_integrate_opt_t options;
ifrom = ito = -1;
for (i = 1; i < argc; i++)
{
if (!strcmp(argv[i], "-i"))
{
if (!strcmp(argv[i+1], "all"))
{
ifrom = 0;
ito = NUM_INTEGRALS - 1;
}
else
{
ifrom = ito = atol(argv[i+1]);
if (ito < 0 || ito >= NUM_INTEGRALS)
flint_abort();
}
}
}
if (ifrom == -1)
{
flint_printf("Compute integrals using acb_calc_integrate.\n");
flint_printf("Usage: integrals -i n [-prec p] [-tol eps] [-twice] [...]\n\n");
flint_printf("-i n - compute integral n (0 <= n <= %d), or \"-i all\"\n", NUM_INTEGRALS - 1);
flint_printf("-prec p - precision in bits (default p = 64)\n");
flint_printf("-goal p - approximate relative accuracy goal (default p)\n");
flint_printf("-tol eps - approximate absolute error goal (default 2^-p)\n");
flint_printf("-twice - run twice (to see overhead of computing nodes)\n");
flint_printf("-heap - use heap for subinterval queue\n");
flint_printf("-verbose - show information\n");
flint_printf("-verbose2 - show more information\n");
flint_printf("-deg n - use quadrature degree up to n\n");
flint_printf("-eval n - limit number of function evaluations to n\n");
flint_printf("-depth n - limit subinterval queue size to n\n\n");
flint_printf("Implemented integrals:\n");
for (integral = 0; integral < NUM_INTEGRALS; integral++)
flint_printf("I%d = %s\n", integral, descr[integral]);
flint_printf("\n");
return 1;
}
acb_calc_integrate_opt_init(options);
prec = 64;
twice = 0;
goal = 0;
havetol = havegoal = 0;
acb_init(a);
acb_init(b);
acb_init(s);
acb_init(t);
mag_init(tol);
for (i = 1; i < argc; i++)
{
if (!strcmp(argv[i], "-prec"))
{
prec = atol(argv[i+1]);
}
else if (!strcmp(argv[i], "-twice"))
{
twice = 1;
}
else if (!strcmp(argv[i], "-goal"))
{
goal = atol(argv[i+1]);
if (goal < 0)
{
flint_printf("expected goal >= 0\n");
return 1;
}
havegoal = 1;
}
else if (!strcmp(argv[i], "-tol"))
{
arb_t x;
arb_init(x);
arb_set_str(x, argv[i+1], 10);
arb_get_mag(tol, x);
arb_clear(x);
havetol = 1;
}
else if (!strcmp(argv[i], "-deg"))
{
options->deg_limit = atol(argv[i+1]);
}
else if (!strcmp(argv[i], "-eval"))
{
options->eval_limit = atol(argv[i+1]);
}
else if (!strcmp(argv[i], "-depth"))
{
options->depth_limit = atol(argv[i+1]);
}
else if (!strcmp(argv[i], "-verbose"))
{
options->verbose = 1;
}
else if (!strcmp(argv[i], "-verbose2"))
{
options->verbose = 2;
}
else if (!strcmp(argv[i], "-heap"))
{
options->use_heap = 1;
}
}
if (!havegoal)
goal = prec;
if (!havetol)
mag_set_ui_2exp_si(tol, 1, -prec);
for (integral = ifrom; integral <= ito; integral++)
{
flint_printf("I%d = %s ...\n", integral, descr[integral]);
for (i = 0; i < 1 + twice; i++)
{
TIMEIT_ONCE_START
switch (integral)
{
case 0:
acb_set_d(a, 0);
acb_set_d(b, 100);
acb_calc_integrate(s, f_sin, NULL, a, b, goal, tol, options, prec);
break;
case 1:
acb_set_d(a, 0);
acb_set_d(b, 1);
acb_calc_integrate(s, f_atanderiv, NULL, a, b, goal, tol, options, prec);
acb_mul_2exp_si(s, s, 2);
break;
case 2:
acb_set_d(a, 0);
acb_one(b);
acb_mul_2exp_si(b, b, goal);
acb_calc_integrate(s, f_atanderiv, NULL, a, b, goal, tol, options, prec);
arb_add_error_2exp_si(acb_realref(s), -goal);
acb_mul_2exp_si(s, s, 1);
break;
case 3:
acb_set_d(a, 0);
acb_set_d(b, 1);
acb_calc_integrate(s, f_circle, NULL, a, b, goal, tol, options, prec);
acb_mul_2exp_si(s, s, 2);
break;
case 4:
acb_set_d(a, 0);
acb_set_d(b, 8);
acb_calc_integrate(s, f_rump, NULL, a, b, goal, tol, options, prec);
break;
case 5:
acb_set_d(a, 1);
acb_set_d(b, 101);
acb_calc_integrate(s, f_floor, NULL, a, b, goal, tol, options, prec);
break;
case 6:
acb_set_d(a, 0);
acb_set_d(b, 1);
acb_calc_integrate(s, f_helfgott, NULL, a, b, goal, tol, options, prec);
break;
case 7:
acb_zero(s);
acb_set_d_d(a, -1.0, -1.0);
acb_set_d_d(b, 2.0, -1.0);
acb_calc_integrate(t, f_zeta, NULL, a, b, goal, tol, options, prec);
acb_add(s, s, t, prec);
acb_set_d_d(a, 2.0, -1.0);
acb_set_d_d(b, 2.0, 1.0);
acb_calc_integrate(t, f_zeta, NULL, a, b, goal, tol, options, prec);
acb_add(s, s, t, prec);
acb_set_d_d(a, 2.0, 1.0);
acb_set_d_d(b, -1.0, 1.0);
acb_calc_integrate(t, f_zeta, NULL, a, b, goal, tol, options, prec);
acb_add(s, s, t, prec);
acb_set_d_d(a, -1.0, 1.0);
acb_set_d_d(b, -1.0, -1.0);
acb_calc_integrate(t, f_zeta, NULL, a, b, goal, tol, options, prec);
acb_add(s, s, t, prec);
acb_const_pi(t, prec);
acb_div(s, s, t, prec);
acb_mul_2exp_si(s, s, -1);
acb_div_onei(s, s);
break;
case 8:
acb_set_d(a, 0);
acb_set_d(b, 1);
acb_calc_integrate(s, f_essing, NULL, a, b, goal, tol, options, prec);
break;
case 9:
acb_set_d(a, 0);
acb_set_d(b, 1);
acb_calc_integrate(s, f_essing2, NULL, a, b, goal, tol, options, prec);
break;
case 10:
acb_set_d(a, 0);
acb_set_d(b, 10000);
acb_calc_integrate(s, f_factorial1000, NULL, a, b, goal, tol, options, prec);
break;
case 11:
acb_set_d_d(a, 1.0, 0.0);
acb_set_d_d(b, 1.0, 1000.0);
acb_calc_integrate(s, f_gamma, NULL, a, b, goal, tol, options, prec);
break;
case 12:
acb_set_d(a, -10.0);
acb_set_d(b, 10.0);
acb_calc_integrate(s, f_sin_plus_small, NULL, a, b, goal, tol, options, prec);
break;
case 13:
acb_set_d(a, -1020.0);
acb_set_d(b, -1010.0);
acb_calc_integrate(s, f_exp, NULL, a, b, goal, tol, options, prec);
break;
case 14:
acb_set_d(a, 0);
acb_set_d(b, ceil(sqrt(goal * 0.693147181) + 1.0));
acb_calc_integrate(s, f_gaussian, NULL, a, b, goal, tol, options, prec);
acb_mul(b, b, b, prec);
acb_neg(b, b);
acb_exp(b, b, prec);
arb_add_error(acb_realref(s), acb_realref(b));
break;
case 15:
acb_set_d(a, 0.0);
acb_set_d(b, 1.0);
acb_calc_integrate(s, f_spike, NULL, a, b, goal, tol, options, prec);
break;
case 16:
acb_set_d(a, 0.0);
acb_set_d(b, 8.0);
acb_calc_integrate(s, f_monster, NULL, a, b, goal, tol, options, prec);
break;
case 17:
acb_set_d(a, 0);
acb_set_d(b, ceil(goal * 0.693147181 + 1.0));
acb_calc_integrate(s, f_sech, NULL, a, b, goal, tol, options, prec);
acb_neg(b, b);
acb_exp(b, b, prec);
acb_mul_2exp_si(b, b, 1);
arb_add_error(acb_realref(s), acb_realref(b));
break;
case 18:
acb_set_d(a, 0);
acb_set_d(b, ceil(goal * 0.693147181 / 3.0 + 2.0));
acb_calc_integrate(s, f_sech3, NULL, a, b, goal, tol, options, prec);
acb_neg(b, b);
acb_mul_ui(b, b, 3, prec);
acb_exp(b, b, prec);
acb_mul_2exp_si(b, b, 3);
acb_div_ui(b, b, 3, prec);
arb_add_error(acb_realref(s), acb_realref(b));
break;
case 19:
if (goal < 0)
abort();
/* error bound 2^-N (1+N) when truncated at 2^-N */
N = goal + FLINT_BIT_COUNT(goal);
acb_one(a);
acb_mul_2exp_si(a, a, -N);
acb_one(b);
acb_calc_integrate(s, f_log_div1p, NULL, a, b, goal, tol, options, prec);
acb_set_ui(b, N + 1);
acb_mul_2exp_si(b, b, -N);
arb_add_error(acb_realref(s), acb_realref(b));
break;
case 20:
if (goal < 0)
abort();
/* error bound (N+1) exp(-N) when truncated at N */
N = goal + FLINT_BIT_COUNT(goal);
acb_zero(a);
acb_set_ui(b, N);
acb_calc_integrate(s, f_log_div1p_transformed, NULL, a, b, goal, tol, options, prec);
acb_neg(b, b);
acb_exp(b, b, prec);
acb_mul_ui(b, b, N + 1, prec);
arb_add_error(acb_realref(s), acb_realref(b));
break;
case 21:
acb_zero(s);
N = 10;
acb_set_d_d(a, 0.5, -0.5);
acb_set_d_d(b, 0.5, 0.5);
acb_calc_integrate(t, f_elliptic_p_laurent_n, &N, a, b, goal, tol, options, prec);
acb_add(s, s, t, prec);
acb_set_d_d(a, 0.5, 0.5);
acb_set_d_d(b, -0.5, 0.5);
acb_calc_integrate(t, f_elliptic_p_laurent_n, &N, a, b, goal, tol, options, prec);
acb_add(s, s, t, prec);
acb_set_d_d(a, -0.5, 0.5);
acb_set_d_d(b, -0.5, -0.5);
acb_calc_integrate(t, f_elliptic_p_laurent_n, &N, a, b, goal, tol, options, prec);
acb_add(s, s, t, prec);
acb_set_d_d(a, -0.5, -0.5);
acb_set_d_d(b, 0.5, -0.5);
acb_calc_integrate(t, f_elliptic_p_laurent_n, &N, a, b, goal, tol, options, prec);
acb_add(s, s, t, prec);
acb_const_pi(t, prec);
acb_div(s, s, t, prec);
acb_mul_2exp_si(s, s, -1);
acb_div_onei(s, s);
break;
case 22:
acb_zero(s);
N = 1000;
acb_set_d_d(a, 100.0, 0.0);
acb_set_d_d(b, 100.0, N);
acb_calc_integrate(t, f_zeta_frac, NULL, a, b, goal, tol, options, prec);
acb_add(s, s, t, prec);
acb_set_d_d(a, 100, N);
acb_set_d_d(b, 0.5, N);
acb_calc_integrate(t, f_zeta_frac, NULL, a, b, goal, tol, options, prec);
acb_add(s, s, t, prec);
acb_div_onei(s, s);
arb_zero(acb_imagref(s));
acb_set_ui(t, N);
acb_dirichlet_hardy_theta(t, t, NULL, NULL, 1, prec);
acb_add(s, s, t, prec);
acb_const_pi(t, prec);
acb_div(s, s, t, prec);
acb_add_ui(s, s, 1, prec);
break;
case 23:
acb_set_d(a, 0.0);
acb_set_d(b, 1000.0);
acb_calc_integrate(s, f_lambertw, NULL, a, b, goal, tol, options, prec);
break;
case 24:
acb_set_d(a, 0.0);
acb_const_pi(b, prec);
acb_calc_integrate(s, f_max_sin_cos, NULL, a, b, goal, tol, options, prec);
break;
case 25:
acb_set_si(a, -1);
acb_set_si(b, 1);
acb_calc_integrate(s, f_erf_bent, NULL, a, b, goal, tol, options, prec);
break;
case 26:
acb_set_si(a, -10);
acb_set_si(b, 10);
acb_calc_integrate(s, f_airy_ai, NULL, a, b, goal, tol, options, prec);
break;
case 27:
acb_set_si(a, 0);
acb_set_si(b, 10);
acb_calc_integrate(s, f_horror, NULL, a, b, goal, tol, options, prec);
break;
case 28:
acb_set_d_d(a, -1, -1);
acb_set_d_d(b, -1, 1);
acb_calc_integrate(s, f_sqrt, NULL, a, b, goal, tol, options, prec);
break;
case 29:
acb_set_d(a, 0);
acb_set_d(b, ceil(sqrt(goal * 0.693147181) + 1.0));
acb_calc_integrate(s, f_gaussian_twist, NULL, a, b, goal, tol, options, prec);
acb_mul(b, b, b, prec);
acb_neg(b, b);
acb_exp(b, b, prec);
arb_add_error(acb_realref(s), acb_realref(b));
arb_add_error(acb_imagref(s), acb_realref(b));
break;
case 30:
acb_set_d(a, 0);
acb_set_d(b, ceil(goal * 0.693147181 + 1.0));
acb_calc_integrate(s, f_exp_airy, NULL, a, b, goal, tol, options, prec);
acb_neg(b, b);
acb_exp(b, b, prec);
acb_mul_2exp_si(b, b, 1);
arb_add_error(acb_realref(s), acb_realref(b));
break;
case 31:
acb_zero(a);
acb_const_pi(b, prec);
acb_calc_integrate(s, f_sin_cos_frac, NULL, a, b, goal, tol, options, prec);
break;
case 32:
acb_zero(a);
acb_set_ui(b, 3);
acb_calc_integrate(s, f_sin_near_essing, NULL, a, b, goal, tol, options, prec);
break;
case 33:
acb_zero(a);
acb_zero(b);
k = 3;
scaled_bessel_select_N(acb_realref(b), k, prec);
acb_calc_integrate(s, f_scaled_bessel, &k, a, b, goal, tol, options, prec);
scaled_bessel_tail_bound(acb_realref(a), k, acb_realref(b), prec);
arb_add_error(acb_realref(s), acb_realref(a));
break;
case 34:
acb_zero(a);
acb_zero(b);
k = 15;
scaled_bessel_select_N(acb_realref(b), k, prec);
acb_calc_integrate(s, f_scaled_bessel, &k, a, b, goal, tol, options, prec);
scaled_bessel_tail_bound(acb_realref(a), k, acb_realref(b), prec);
arb_add_error(acb_realref(s), acb_realref(a));
break;
case 35:
acb_set_d_d(a, -1, -1);
acb_set_d_d(b, -1, 1);
acb_calc_integrate(s, f_rsqrt, NULL, a, b, goal, tol, options, prec);
break;
default:
abort();
}
TIMEIT_ONCE_STOP
}
flint_printf("I%d = ", integral);
acb_printn(s, 3.333 * prec, 0);
flint_printf("\n\n");
}
acb_clear(a);
acb_clear(b);
acb_clear(s);
acb_clear(t);
mag_clear(tol);
flint_cleanup();
return 0;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("j....");
fflush(stdout);
flint_randinit(state);
/* Test SL2Z invariance */
for (iter = 0; iter < 10000; iter++)
{
acb_t tau1, tau2, z1, z2;
slong e0, prec0, prec1, prec2;
psl2z_t g;
psl2z_init(g);
acb_init(tau1);
acb_init(tau2);
acb_init(z1);
acb_init(z2);
e0 = 1 + n_randint(state, 100);
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_j(z1, tau1, prec1);
acb_modular_j(z2, tau2, prec2);
if (!acb_overlaps(z1, z2))
{
flint_printf("FAIL (overlap)\n");
flint_printf("tau1 = "); acb_print(tau1); flint_printf("\n\n");
flint_printf("tau2 = "); acb_print(tau2); flint_printf("\n\n");
flint_printf("z1 = "); acb_print(z1); flint_printf("\n\n");
flint_printf("z2 = "); acb_print(z2); flint_printf("\n\n");
abort();
}
acb_modular_j(tau1, tau1, prec2);
if (!acb_overlaps(z1, tau1))
{
flint_printf("FAIL (aliasing)\n");
flint_printf("tau1 = "); acb_print(tau1); flint_printf("\n\n");
flint_printf("tau2 = "); acb_print(tau2); flint_printf("\n\n");
flint_printf("z1 = "); acb_print(z1); flint_printf("\n\n");
flint_printf("z2 = "); acb_print(z2); flint_printf("\n\n");
abort();
}
acb_clear(tau1);
acb_clear(tau2);
acb_clear(z1);
acb_clear(z2);
psl2z_clear(g);
}
/* Test special values */
for (iter = 0; iter < 100; iter++)
{
acb_t tau, z;
slong prec;
acb_init(tau);
acb_init(z);
prec = 2 + n_randint(state, 2000);
acb_randtest(z, state, prec, 10);
acb_onei(tau);
acb_modular_j(z, tau, prec);
acb_sub_ui(z, z, 1728, prec);
if (!acb_contains_zero(z))
{
flint_printf("FAIL (value 1)\n");
flint_printf("tau = "); acb_print(tau); flint_printf("\n\n");
flint_printf("z = "); acb_print(z); flint_printf("\n\n");
abort();
}
acb_set_ui(tau, 2);
acb_div_ui(tau, tau, 3, prec);
acb_exp_pi_i(tau, tau, prec);
acb_modular_j(z, tau, prec);
if (!acb_contains_zero(z))
{
flint_printf("FAIL (value 2)\n");
flint_printf("tau = "); acb_print(tau); flint_printf("\n\n");
flint_printf("z = "); acb_print(z); flint_printf("\n\n");
abort();
}
acb_clear(tau);
acb_clear(z);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}