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);
}
static void
evaluate(acb_poly_t A, acb_srcptr a, slong p, const acb_t z, slong n, slong prec)
{
acb_poly_fit_length(A, p + 1);
if (p == 1)
{
acb_add_ui(A->coeffs, a, n, prec);
if (z != NULL)
acb_mul(A->coeffs, A->coeffs, z, prec);
}
else if (p == 2)
{
acb_add(A->coeffs, a + 0, a + 1, prec);
acb_add_ui(A->coeffs + 1, A->coeffs, 2 * n, prec);
acb_add_ui(A->coeffs, A->coeffs, n, prec);
acb_mul_ui(A->coeffs, A->coeffs, n, prec);
acb_addmul(A->coeffs, a + 0, a + 1, prec);
if (z != NULL)
{
acb_mul(A->coeffs, A->coeffs, z, prec);
acb_mul(A->coeffs + 1, A->coeffs + 1, z, prec);
}
}
else if (p == 3)
{
acb_t t, u;
acb_init(t);
acb_init(u);
acb_add(t, a + 0, a + 1, prec);
acb_add(t, t, a + 2, prec);
acb_mul(u, a + 0, a + 1, prec);
acb_mul(A->coeffs, u, a + 2, prec);
acb_addmul(u, a + 0, a + 2, prec);
acb_addmul(u, a + 1, a + 2, prec);
/*
(a0 + n)(a1 + n)(a2 + n) = a0 a1 a2 + (a0 a1 + a0 a2 + a1 a2) n + (a0 + a1 + a2) n^2 + n^3
(a0 a1 + a0 a2 + a1 a2) + 2 (a0 + a1 + a2) n + 3 n^2
(a0 + a1 + a2) + 3n
1
*/
acb_addmul_ui(A->coeffs, u, n, prec);
acb_addmul_ui(A->coeffs, t, n * n, prec);
acb_add_ui(A->coeffs, A->coeffs, n * n * n, prec);
acb_set(A->coeffs + 1, u);
acb_addmul_ui(A->coeffs + 1, t, 2 * n, prec);
acb_add_ui(A->coeffs + 1, A->coeffs + 1, 3 * n * n, prec);
acb_add_ui(A->coeffs + 2, t, 3 * n, prec);
if (z != NULL)
{
acb_mul(A->coeffs + 0, A->coeffs + 0, z, prec);
acb_mul(A->coeffs + 1, A->coeffs + 1, z, prec);
acb_mul(A->coeffs + 2, A->coeffs + 2, z, prec);
}
acb_clear(t);
acb_clear(u);
}
else if (p != 0)
{
flint_abort();
}
if (z != NULL)
acb_set(A->coeffs + p, z);
else
acb_one(A->coeffs + p);
_acb_poly_set_length(A, p + 1);
_acb_poly_normalise(A);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("elliptic_p....");
fflush(stdout);
flint_randinit(state);
/* check test values */
for (iter = 0; iter < 100; iter++)
{
slong i;
acb_t z, tau, p1, p2;
acb_init(z);
acb_init(tau);
acb_init(p1);
acb_init(p2);
for (i = 0; i < NUM_TESTS; i++)
{
acb_set_dddd(z, testdata[i][0], 0.0, testdata[i][1], 0.0);
acb_set_dddd(tau, testdata[i][2], 0.0, testdata[i][3], 0.0);
acb_set_dddd(p2, testdata[i][4], EPS, testdata[i][5], EPS);
acb_modular_elliptic_p(p1, z, tau, 2 + n_randint(state, 1000));
if (!acb_overlaps(p1, p2))
{
flint_printf("FAIL (test value)\n");
flint_printf("tau = "); acb_printd(tau, 15); flint_printf("\n\n");
flint_printf("z = "); acb_printd(z, 15); flint_printf("\n\n");
flint_printf("p1 = "); acb_printd(p1, 15); flint_printf("\n\n");
flint_printf("p2 = "); acb_printd(p2, 15); flint_printf("\n\n");
abort();
}
}
acb_clear(z);
acb_clear(tau);
acb_clear(p1);
acb_clear(p2);
}
/* Test periods */
for (iter = 0; iter < 2000; iter++)
{
acb_t tau, z1, z2, p1, p2;
slong m, n, e0, prec0, prec1, prec2;
acb_init(tau);
acb_init(z1);
acb_init(z2);
acb_init(p1);
acb_init(p2);
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);
if (arf_sgn(arb_midref(acb_imagref(tau))) < 0)
acb_neg(tau, tau);
acb_randtest(z1, state, prec0, e0);
acb_randtest(p1, state, prec0, e0);
acb_randtest(p2, state, prec0, e0);
/* z2 = z1 + m + n*tau */
m = n_randint(state, 10);
n = n_randint(state, 10);
acb_add_ui(z2, z1, m, prec0);
acb_addmul_ui(z2, tau, n, prec0);
acb_modular_elliptic_p(p1, z1, tau, prec1);
acb_modular_elliptic_p(p2, z2, tau, prec2);
if (!acb_overlaps(p1, p2))
{
flint_printf("FAIL (overlap)\n");
flint_printf("tau = "); acb_printd(tau, 15); flint_printf("\n\n");
flint_printf("z1 = "); acb_printd(z1, 15); flint_printf("\n\n");
flint_printf("z2 = "); acb_printd(z2, 15); flint_printf("\n\n");
flint_printf("p1 = "); acb_printd(p1, 15); flint_printf("\n\n");
flint_printf("p2 = "); acb_printd(p2, 15); flint_printf("\n\n");
abort();
}
acb_modular_elliptic_p(z1, z1, tau, prec1);
if (!acb_overlaps(z1, p1))
{
flint_printf("FAIL (aliasing)\n");
flint_printf("tau = "); acb_printd(tau, 15); flint_printf("\n\n");
flint_printf("z1 = "); acb_printd(z1, 15); flint_printf("\n\n");
flint_printf("p1 = "); acb_printd(p1, 15); flint_printf("\n\n");
abort();
}
acb_clear(tau);
acb_clear(z1);
acb_clear(z2);
acb_clear(p1);
acb_clear(p2);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
