void
_acb_poly_revert_series_lagrange_fast(acb_ptr Qinv, acb_srcptr Q, slong Qlen, slong n, slong prec)
{
slong i, j, k, m;
acb_ptr R, S, T, tmp;
acb_t t;
if (n <= 2)
{
if (n >= 1)
acb_zero(Qinv);
if (n == 2)
acb_inv(Qinv + 1, Q + 1, prec);
return;
}
m = n_sqrt(n);
acb_init(t);
R = _acb_vec_init((n - 1) * m);
S = _acb_vec_init(n - 1);
T = _acb_vec_init(n - 1);
acb_zero(Qinv);
acb_inv(Qinv + 1, Q + 1, prec);
_acb_poly_inv_series(Ri(1), Q + 1, FLINT_MIN(Qlen, n) - 1, n - 1, prec);
for (i = 2; i <= m; i++)
_acb_poly_mullow(Ri(i), Ri((i + 1) / 2), n - 1, Ri(i / 2), n - 1, n - 1, prec);
for (i = 2; i < m; i++)
acb_div_ui(Qinv + i, Ri(i) + i - 1, i, prec);
_acb_vec_set(S, Ri(m), n - 1);
for (i = m; i < n; i += m)
{
acb_div_ui(Qinv + i, S + i - 1, i, prec);
for (j = 1; j < m && i + j < n; j++)
{
acb_mul(t, S + 0, Ri(j) + i + j - 1, prec);
for (k = 1; k <= i + j - 1; k++)
acb_addmul(t, S + k, Ri(j) + i + j - 1 - k, prec);
acb_div_ui(Qinv + i + j, t, i + j, prec);
}
if (i + 1 < n)
{
_acb_poly_mullow(T, S, n - 1, Ri(m), n - 1, n - 1, prec);
tmp = S; S = T; T = tmp;
}
}
acb_clear(t);
_acb_vec_clear(R, (n - 1) * m);
_acb_vec_clear(S, n - 1);
_acb_vec_clear(T, n - 1);
}
void ifft(acb_t *x) {
long *base=(long *)x-2,i;
long n=base[0],prec=base[1],halfn=n>>1;
fft(x);
acb_div_ui(x[0],x[0],n,prec);
acb_div_ui(x[halfn],x[halfn],n,prec);
for (i=1;i<halfn;i++) {
acb_div_ui(x[i],x[i],n,prec);
acb_div_ui(x[n-i],x[n-i],n,prec);
acb_swap(x[i],x[n-i]);
}
}
/* f(z) = sin((1/1000 + (1-z)^2)^(-3/2)), example from Mioara Joldes' thesis
(suggested by Nicolas Brisebarre) */
int
f_sin_near_essing(acb_ptr res, const acb_t z, void * param, slong order, slong prec)
{
acb_t t, u;
if (order > 1)
flint_abort(); /* Would be needed for Taylor method. */
acb_init(t);
acb_init(u);
acb_sub_ui(t, z, 1, prec);
acb_neg(t, t);
acb_mul(t, t, t, prec);
acb_one(u);
acb_div_ui(u, u, 1000, prec);
acb_add(t, t, u, prec);
acb_set_d(u, -1.5);
acb_pow_analytic(t, t, u, order != 0, prec);
acb_sin(res, t, prec);
acb_clear(t);
acb_clear(u);
return 0;
}
void
acb_hypgeom_jacobi_p_ui_direct(acb_t res, ulong n,
const acb_t a, const acb_t b, const acb_t z, slong prec)
{
acb_ptr terms;
acb_t t, u, v;
slong k;
terms = _acb_vec_init(n + 1);
acb_init(t);
acb_init(u);
acb_init(v);
acb_one(terms);
acb_add_ui(u, z, 1, prec);
for (k = 1; k <= n; k++)
{
acb_add_ui(t, a, n + 1 - k, prec);
acb_mul(t, t, u, prec);
acb_div_ui(t, t, 2 * k, prec);
acb_mul(terms + k, terms + k - 1, t, prec);
}
acb_sub_ui(u, z, 1, prec);
acb_one(v);
for (k = 1; k <= n; k++)
{
acb_add_ui(t, b, n + 1 - k, prec);
acb_mul(t, t, u, prec);
acb_div_ui(t, t, 2 * k, prec);
acb_mul(v, v, t, prec);
acb_mul(terms + n - k, terms + n - k, v, prec);
}
acb_set(res, terms);
for (k = 1; k <= n; k++)
acb_add(res, res, terms + k, prec);
_acb_vec_clear(terms, n + 1);
acb_clear(t);
acb_clear(u);
acb_clear(v);
}
void
acb_hypgeom_laguerre_l_ui_recurrence(acb_t res, ulong n, const acb_t m,
const acb_t z, slong prec)
{
acb_t t, u, v;
ulong k;
if (n == 0)
{
acb_one(res);
return;
}
if (n == 1)
{
acb_sub(res, m, z, prec);
acb_add_ui(res, res, 1, prec);
return;
}
acb_init(t);
acb_init(u);
acb_init(v);
acb_one(t);
acb_sub(u, m, z, prec);
acb_add_ui(u, u, 1, prec);
for (k = 2; k <= n; k++)
{
acb_add_ui(v, m, k - 1, prec);
acb_mul(t, t, v, prec);
acb_add_ui(v, m, 2 * k - 1, prec);
acb_sub(v, v, z, prec);
acb_mul(v, v, u, prec);
acb_sub(t, v, t, prec);
acb_div_ui(t, t, k, prec);
acb_swap(t, u);
}
acb_set(res, u);
acb_clear(t);
acb_clear(u);
acb_clear(v);
}
/* 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;
}
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;
}
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);
}
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;
}
/* todo: use log(1-z) when this is better? would also need to
adjust strategy in the main function */
void
acb_hypgeom_dilog_bernoulli(acb_t res, const acb_t z, slong prec)
{
acb_t s, w, w2;
slong n, k;
fmpz_t c, d;
mag_t m, err;
double lm;
int real;
acb_init(s);
acb_init(w);
acb_init(w2);
fmpz_init(c);
fmpz_init(d);
mag_init(m);
mag_init(err);
real = 0;
if (acb_is_real(z))
{
arb_sub_ui(acb_realref(w), acb_realref(z), 1, 30);
real = arb_is_nonpositive(acb_realref(w));
}
acb_log(w, z, prec);
acb_get_mag(m, w);
/* for k >= 4, the terms are bounded by (|w| / (2 pi))^k */
mag_set_ui_2exp_si(err, 2670177, -24); /* upper bound for 1/(2pi) */
mag_mul(err, err, m);
lm = mag_get_d_log2_approx(err);
if (lm < -0.25)
{
n = prec / (-lm) + 1;
n = FLINT_MAX(n, 4);
mag_geom_series(err, err, n);
BERNOULLI_ENSURE_CACHED(n)
acb_mul(w2, w, w, prec);
for (k = n - (n % 2 == 0); k >= 3; k -= 2)
{
fmpz_mul_ui(c, fmpq_denref(bernoulli_cache + k - 1), k - 1);
fmpz_mul_ui(d, c, (k + 1) * (k + 2));
acb_mul(s, s, w2, prec);
acb_mul_fmpz(s, s, c, prec);
fmpz_mul_ui(c, fmpq_numref(bernoulli_cache + k - 1), (k + 1) * (k + 2));
acb_sub_fmpz(s, s, c, prec);
acb_div_fmpz(s, s, d, prec);
}
acb_mul(s, s, w, prec);
acb_mul_2exp_si(s, s, 1);
acb_sub_ui(s, s, 3, prec);
acb_mul(s, s, w2, prec);
acb_mul_2exp_si(s, s, -1);
acb_const_pi(w2, prec);
acb_addmul(s, w2, w2, prec);
acb_div_ui(s, s, 6, prec);
acb_neg(w2, w);
acb_log(w2, w2, prec);
acb_submul(s, w2, w, prec);
acb_add(res, s, w, prec);
acb_add_error_mag(res, err);
if (real)
arb_zero(acb_imagref(res));
}
else
{
acb_indeterminate(res);
}
acb_clear(s);
acb_clear(w);
acb_clear(w2);
fmpz_clear(c);
fmpz_clear(d);
mag_clear(m);
mag_clear(err);
}
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);
}
}
int
acb_calc_integrate_taylor(acb_t res,
acb_calc_func_t func, void * param,
const acb_t a, const acb_t b,
const arf_t inner_radius,
const arf_t outer_radius,
long accuracy_goal, long prec)
{
long num_steps, step, N, bp;
int result;
acb_t delta, m, x, y1, y2, sum;
acb_ptr taylor_poly;
arf_t err;
acb_init(delta);
acb_init(m);
acb_init(x);
acb_init(y1);
acb_init(y2);
acb_init(sum);
arf_init(err);
acb_sub(delta, b, a, prec);
/* precision used for bounds calculations */
bp = MAG_BITS;
/* compute the number of steps */
{
arf_t t;
arf_init(t);
acb_get_abs_ubound_arf(t, delta, bp);
arf_div(t, t, inner_radius, bp, ARF_RND_UP);
arf_mul_2exp_si(t, t, -1);
num_steps = (long) (arf_get_d(t, ARF_RND_UP) + 1.0);
/* make sure it's not something absurd */
num_steps = FLINT_MIN(num_steps, 10 * prec);
num_steps = FLINT_MAX(num_steps, 1);
arf_clear(t);
}
result = ARB_CALC_SUCCESS;
acb_zero(sum);
for (step = 0; step < num_steps; step++)
{
/* midpoint of subinterval */
acb_mul_ui(m, delta, 2 * step + 1, prec);
acb_div_ui(m, m, 2 * num_steps, prec);
acb_add(m, m, a, prec);
if (arb_calc_verbose)
{
printf("integration point %ld/%ld: ", 2 * step + 1, 2 * num_steps);
acb_printd(m, 15); printf("\n");
}
/* evaluate at +/- x */
/* TODO: exactify m, and include error in x? */
acb_div_ui(x, delta, 2 * num_steps, prec);
/* compute bounds and number of terms to use */
{
arb_t cbound, xbound, rbound;
arf_t C, D, R, X, T;
double DD, TT, NN;
arb_init(cbound);
arb_init(xbound);
arb_init(rbound);
arf_init(C);
arf_init(D);
arf_init(R);
arf_init(X);
arf_init(T);
/* R is the outer radius */
arf_set(R, outer_radius);
/* X = upper bound for |x| */
acb_get_abs_ubound_arf(X, x, bp);
arb_set_arf(xbound, X);
/* Compute C(m,R). Important subtlety: due to rounding when
computing m, we will in general be farther than R away from
the integration path. But since acb_calc_cauchy_bound
actually integrates over the area traced by a complex
interval, it will catch any extra singularities (giving
an infinite bound). */
arb_set_arf(rbound, outer_radius);
acb_calc_cauchy_bound(cbound, func, param, m, rbound, 8, bp);
arf_set_mag(C, arb_radref(cbound));
arf_add(C, arb_midref(cbound), C, bp, ARF_RND_UP);
/* Sanity check: we need C < inf and R > X */
if (arf_is_finite(C) && arf_cmp(R, X) > 0)
{
/* Compute upper bound for D = C * R * X / (R - X) */
arf_mul(D, C, R, bp, ARF_RND_UP);
arf_mul(D, D, X, bp, ARF_RND_UP);
arf_sub(T, R, X, bp, ARF_RND_DOWN);
arf_div(D, D, T, bp, ARF_RND_UP);
/* Compute upper bound for T = (X / R) */
arf_div(T, X, R, bp, ARF_RND_UP);
/* Choose N */
/* TODO: use arf arithmetic to avoid overflow */
/* TODO: use relative accuracy (look at |f(m)|?) */
DD = arf_get_d(D, ARF_RND_UP);
TT = arf_get_d(T, ARF_RND_UP);
NN = -(accuracy_goal * 0.69314718055994530942 + log(DD)) / log(TT);
N = NN + 0.5;
N = FLINT_MIN(N, 100 * prec);
N = FLINT_MAX(N, 1);
/* Tail bound: D / (N + 1) * T^N */
{
mag_t TT;
mag_init(TT);
arf_get_mag(TT, T);
mag_pow_ui(TT, TT, N);
arf_set_mag(T, TT);
mag_clear(TT);
}
arf_mul(D, D, T, bp, ARF_RND_UP);
arf_div_ui(err, D, N + 1, bp, ARF_RND_UP);
}
else
{
N = 1;
arf_pos_inf(err);
result = ARB_CALC_NO_CONVERGENCE;
}
if (arb_calc_verbose)
{
printf("N = %ld; bound: ", N); arf_printd(err, 15); printf("\n");
printf("R: "); arf_printd(R, 15); printf("\n");
printf("C: "); arf_printd(C, 15); printf("\n");
printf("X: "); arf_printd(X, 15); printf("\n");
}
arb_clear(cbound);
arb_clear(xbound);
arb_clear(rbound);
arf_clear(C);
arf_clear(D);
arf_clear(R);
arf_clear(X);
arf_clear(T);
}
/* evaluate Taylor polynomial */
taylor_poly = _acb_vec_init(N + 1);
func(taylor_poly, m, param, N, prec);
_acb_poly_integral(taylor_poly, taylor_poly, N + 1, prec);
_acb_poly_evaluate(y2, taylor_poly, N + 1, x, prec);
acb_neg(x, x);
_acb_poly_evaluate(y1, taylor_poly, N + 1, x, prec);
acb_neg(x, x);
/* add truncation error */
arb_add_error_arf(acb_realref(y1), err);
arb_add_error_arf(acb_imagref(y1), err);
arb_add_error_arf(acb_realref(y2), err);
arb_add_error_arf(acb_imagref(y2), err);
acb_add(sum, sum, y2, prec);
acb_sub(sum, sum, y1, prec);
if (arb_calc_verbose)
{
printf("values: ");
acb_printd(y1, 15); printf(" ");
acb_printd(y2, 15); printf("\n");
}
_acb_vec_clear(taylor_poly, N + 1);
if (result == ARB_CALC_NO_CONVERGENCE)
break;
}
acb_set(res, sum);
acb_clear(delta);
acb_clear(m);
acb_clear(x);
acb_clear(y1);
acb_clear(y2);
acb_clear(sum);
arf_clear(err);
return result;
}
void
acb_dirichlet_l(acb_t res, const acb_t s,
const dirichlet_group_t G, const dirichlet_char_t chi, slong prec)
{
if (!acb_is_finite(s))
{
acb_indeterminate(res);
}
else if (G == NULL || G->q == 1)
{
acb_dirichlet_zeta(res, s, prec);
}
else if (dirichlet_char_is_primitive(G, chi) &&
(arf_cmp_d(arb_midref(acb_realref(s)), -0.5) < 0 ||
(G->q != 1 && dirichlet_parity_char(G, chi) == 0 &&
arf_cmpabs_d(arb_midref(acb_imagref(s)), 0.125) < 0 &&
arf_cmp_d(arb_midref(acb_realref(s)), 0.125) < 0)))
{
/* use functional equation */
acb_t t, u, v;
int parity;
ulong q;
parity = dirichlet_parity_char(G, chi);
q = G->q;
acb_init(t);
acb_init(u);
acb_init(v);
/* gamma((1-s+p)/2) / gamma((s+p)/2) */
acb_add_ui(t, s, parity, prec);
acb_mul_2exp_si(t, t, -1);
acb_rgamma(t, t, prec);
if (!acb_is_zero(t)) /* assumes q != 1 when s = 0 */
{
acb_neg(u, s);
acb_add_ui(u, u, 1 + parity, prec);
acb_mul_2exp_si(u, u, -1);
acb_gamma(u, u, prec);
acb_mul(t, t, u, prec);
/* epsilon */
acb_dirichlet_root_number(u, G, chi, prec);
acb_mul(t, t, u, prec);
/* (pi/q)^(s-1/2) */
acb_const_pi(u, prec);
acb_div_ui(u, u, q, prec);
acb_set_d(v, -0.5);
acb_add(v, v, s, prec);
acb_pow(u, u, v, prec);
acb_mul(t, t, u, prec);
acb_sub_ui(u, s, 1, prec);
acb_neg(u, u);
acb_conj(u, u);
acb_dirichlet_l_general(u, u, G, chi, prec);
acb_conj(u, u);
acb_mul(t, t, u, prec);
if (dirichlet_char_is_real(G, chi) && acb_is_real(s))
arb_zero(acb_imagref(t));
}
acb_set(res, t);
acb_clear(t);
acb_clear(u);
acb_clear(v);
}
else
{
acb_dirichlet_l_general(res, s, G, chi, prec);
}
}
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);
}
void
acb_modular_elliptic_k_cpx(acb_ptr w, const acb_t m, slong len, slong prec)
{
acb_t t, u, msub1m, m2sub1;
slong k, n;
if (len < 1)
return;
if (len == 1)
{
acb_modular_elliptic_k(w, m, prec);
return;
}
if (acb_is_zero(m))
{
acb_const_pi(w, prec);
acb_mul_2exp_si(w, w, -1);
for (k = 1; k < len; k++)
{
acb_mul_ui(w + k, w + k - 1, (2 * k - 1) * (2 * k - 1), prec);
acb_div_ui(w + k, w + k, 4 * k * k, prec);
}
return;
}
acb_init(t);
acb_init(u);
acb_init(msub1m);
acb_init(m2sub1);
acb_sub_ui(msub1m, m, 1, prec);
acb_neg(t, msub1m);
acb_sqrt(t, t, prec);
acb_mul(msub1m, msub1m, m, prec);
acb_mul_2exp_si(m2sub1, m, 1);
acb_sub_ui(m2sub1, m2sub1, 1, prec);
acb_agm1_cpx(w, t, 2, prec);
/* pi M'(t) / (4 t M(t)^2) */
acb_mul(u, w, w, prec);
acb_mul(t, t, u, prec);
acb_div(w + 1, w + 1, t, prec);
acb_const_pi(u, prec);
acb_mul(w + 1, w + 1, u, prec);
acb_mul_2exp_si(w + 1, w + 1, -2);
/* pi / (2 M(t)) */
acb_const_pi(u, prec);
acb_div(w, u, w, prec);
acb_mul_2exp_si(w, w, -1);
acb_inv(t, msub1m, prec);
for (k = 2; k < len; k++)
{
n = k - 2;
acb_mul_ui(w + k, w + n, (2 * n + 1) * (2 * n + 1), prec);
acb_mul(u, w + n + 1, m2sub1, prec);
acb_addmul_ui(w + k, u, (n + 1) * (n + 1) * 4, prec);
acb_mul(w + k, w + k, t, prec);
acb_div_ui(w + k, w + k, 4 * (n + 1) * (n + 2), prec);
acb_neg(w + k, w + k);
}
acb_clear(t);
acb_clear(u);
acb_clear(msub1m);
acb_clear(m2sub1);
}
void
acb_modular_eisenstein(acb_ptr r, const acb_t tau, slong len, slong prec)
{
psl2z_t g;
arf_t one_minus_eps;
acb_t tau_prime, t1, t2, t3, t4, q;
slong m, n;
if (len < 1)
return;
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);
/* fourth powers of the theta functions (a, b, c) */
acb_mul(t2, t2, t2, prec);
acb_mul(t2, t2, t2, prec);
acb_mul(t2, t2, q, prec);
acb_mul(t3, t3, t3, prec);
acb_mul(t3, t3, t3, prec);
acb_mul(t4, t4, t4, prec);
acb_mul(t4, t4, t4, prec);
/* c2 = pi^4 * (a^8 + b^8 + c^8) / 30 */
/* c3 = pi^6 * (b^12 + c^12 - 3a^8 * (b^4+c^4)) / 180 */
/* r = a^8 */
acb_mul(r, t2, t2, prec);
if (len > 1)
{
/* r[1] = -3 a^8 * (b^4 + c^4) */
acb_add(r + 1, t3, t4, prec);
acb_mul(r + 1, r + 1, r, prec);
acb_mul_si(r + 1, r + 1, -3, prec);
}
/* b^8 */
acb_mul(t1, t3, t3, prec);
acb_add(r, r, t1, prec);
/* b^12 */
if (len > 1)
acb_addmul(r + 1, t1, t3, prec);
/* c^8 */
acb_mul(t1, t4, t4, prec);
acb_add(r, r, t1, prec);
/* c^12 */
if (len > 1)
acb_addmul(r + 1, t1, t4, prec);
acb_const_pi(t1, prec);
acb_mul(t1, t1, t1, prec);
acb_mul(t2, t1, t1, prec);
acb_mul(r, r, t2, prec);
acb_div_ui(r, r, 30, prec);
if (len > 1)
{
acb_mul(t2, t2, t1, prec);
acb_mul(r + 1, r + 1, t2, prec);
acb_div_ui(r + 1, r + 1, 189, prec);
}
/* apply modular transformation */
if (!fmpz_is_zero(&g->c))
{
acb_mul_fmpz(t1, tau, &g->c, prec);
acb_add_fmpz(t1, t1, &g->d, prec);
acb_inv(t1, t1, prec);
acb_mul(t1, t1, t1, prec);
acb_mul(t2, t1, t1, prec);
acb_mul(r, r, t2, prec);
if (len > 1)
{
acb_mul(t2, t1, t2, prec);
acb_mul(r + 1, r + 1, t2, prec);
}
}
/* compute more coefficients using recurrence */
for (n = 4; n < len + 2; n++)
{
acb_zero(r + n - 2);
m = 2;
for (m = 2; m * 2 < n; m++)
acb_addmul(r + n - 2, r + m - 2, r + n - m - 2, prec);
acb_mul_2exp_si(r + n - 2, r + n - 2, 1);
if (n % 2 == 0)
acb_addmul(r + n - 2, r + n / 2 - 2, r + n / 2 - 2, prec);
acb_mul_ui(r + n - 2, r + n - 2, 3, prec);
acb_div_ui(r + n - 2, r + n - 2, (2 * n + 1) * (n - 3), prec);
}
/* convert c's to G's */
for (n = 0; n < len; n++)
acb_div_ui(r + n, r + n, 2 * n + 3, prec);
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);
}
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()
{
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;
}