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("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;
}
void
acb_hypgeom_2f1_transform_nolimit(acb_t res, const acb_t a, const acb_t b,
const acb_t c, const acb_t z, int regularized, int which, slong prec)
{
acb_t ba, ca, cb, cab, ac1, bc1, ab1, ba1, w, t, u, v, s;
if (acb_contains_zero(z) || !acb_is_finite(z))
{
acb_indeterminate(res);
return;
}
if (arb_contains_si(acb_realref(z), 1) && arb_contains_zero(acb_imagref(z)))
{
acb_indeterminate(res);
return;
}
if (!regularized)
{
acb_init(t);
acb_gamma(t, c, prec);
acb_hypgeom_2f1_transform_nolimit(res, a, b, c, z, 1, which, prec);
acb_mul(res, res, t, prec);
acb_clear(t);
return;
}
acb_init(ba);
acb_init(ca); acb_init(cb); acb_init(cab);
acb_init(ac1); acb_init(bc1);
acb_init(ab1); acb_init(ba1);
acb_init(w); acb_init(t);
acb_init(u); acb_init(v);
acb_init(s);
acb_add_si(s, z, -1, prec); /* s = 1 - z */
acb_neg(s, s);
acb_sub(ba, b, a, prec); /* ba = b - a */
acb_sub(ca, c, a, prec); /* ca = c - a */
acb_sub(cb, c, b, prec); /* cb = c - b */
acb_sub(cab, ca, b, prec); /* cab = c - a - b */
acb_add_si(ac1, ca, -1, prec); acb_neg(ac1, ac1); /* ac1 = a - c + 1 */
acb_add_si(bc1, cb, -1, prec); acb_neg(bc1, bc1); /* bc1 = b - c + 1 */
acb_add_si(ab1, ba, -1, prec); acb_neg(ab1, ab1); /* ab1 = a - b + 1 */
acb_add_si(ba1, ba, 1, prec); /* ba1 = b - a + 1 */
/* t = left term, u = right term (DLMF 15.8.1 - 15.8.5) */
if (which == 2)
{
acb_inv(w, z, prec); /* w = 1/z */
acb_hypgeom_2f1_direct(t, a, ac1, ab1, w, 1, prec);
acb_hypgeom_2f1_direct(u, b, bc1, ba1, w, 1, prec);
}
else if (which == 3)
{
acb_inv(w, s, prec); /* w = 1/(1-z) */
acb_hypgeom_2f1_direct(t, a, cb, ab1, w, 1, prec);
acb_hypgeom_2f1_direct(u, b, ca, ba1, w, 1, prec);
}
else if (which == 4)
{
acb_set(w, s); /* w = 1-z */
acb_add(v, ac1, b, prec); /* v = a+b-c+1 */
acb_hypgeom_2f1_direct(t, a, b, v, w, 1, prec);
acb_add_si(v, cab, 1, prec); /* v = c-a-b+1 */
acb_hypgeom_2f1_direct(u, ca, cb, v, w, 1, prec);
}
else if (which == 5)
{
acb_inv(w, z, prec); /* w = 1-1/z */
acb_neg(w, w);
acb_add_si(w, w, 1, prec);
acb_add(v, ac1, b, prec); /* v = a+b-c+1 */
acb_hypgeom_2f1_direct(t, a, ac1, v, w, 1, prec);
acb_add_si(v, cab, 1, prec); /* v = c-a-b+1 */
acb_add_si(u, a, -1, prec); /* u = 1-a */
acb_neg(u, u);
acb_hypgeom_2f1_direct(u, ca, u, v, w, 1, prec);
}
else
{
flint_printf("invalid transformation!\n");
flint_abort();
}
/* gamma factors */
acb_rgamma(v, a, prec);
acb_mul(u, u, v, prec);
acb_rgamma(v, ca, prec);
acb_mul(t, t, v, prec);
acb_rgamma(v, b, prec);
if (which == 2 || which == 3)
acb_mul(t, t, v, prec);
else
acb_mul(u, u, v, prec);
acb_rgamma(v, cb, prec);
if (which == 2 || which == 3)
acb_mul(u, u, v, prec);
else
acb_mul(t, t, v, prec);
if (which == 2 || which == 3)
{
if (which == 2)
acb_neg(s, z); /* -z, otherwise 1-z since before */
acb_neg(v, a);
acb_pow(v, s, v, prec);
acb_mul(t, t, v, prec);
acb_neg(v, b);
acb_pow(v, s, v, prec);
acb_mul(u, u, v, prec);
}
else
{
acb_pow(v, s, cab, prec);
acb_mul(u, u, v, prec);
if (which == 5)
{
acb_neg(v, a);
acb_pow(v, z, v, prec);
acb_mul(t, t, v, prec);
acb_neg(v, ca);
acb_pow(v, z, v, prec);
acb_mul(u, u, v, prec);
}
}
acb_sub(t, t, u, prec);
if (which == 2 || which == 3)
acb_sin_pi(v, ba, prec);
else
acb_sin_pi(v, cab, prec);
acb_div(t, t, v, prec);
acb_const_pi(v, prec);
acb_mul(t, t, v, prec);
acb_set(res, t);
acb_clear(ba);
acb_clear(ca); acb_clear(cb); acb_clear(cab);
acb_clear(ac1); acb_clear(bc1);
acb_clear(ab1); acb_clear(ba1);
acb_clear(w); acb_clear(t);
acb_clear(u); acb_clear(v);
acb_clear(s);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("chi....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
acb_t zn1, zn2, zn1n2, zn1zn2;
dirichlet_group_t G;
dirichlet_char_t chi;
ulong q, m, n1, n2, iter2;
int res;
q = 1 + n_randint(state, 1000);
dirichlet_group_init(G, q);
dirichlet_char_init(chi, G);
acb_init(zn1);
acb_init(zn2);
acb_init(zn1n2);
acb_init(zn1zn2);
/* check chi(n1) chi(n2) = chi(n1 n2) */
for (iter2 = 0; iter2 < 10; iter2++)
{
do {
m = 1 + n_randint(state, q);
} while (n_gcd(q, m) != 1);
dirichlet_char_log(chi, G, m);
n1 = n_randint(state, 1000);
n2 = n_randint(state, 1000);
acb_dirichlet_chi(zn1, G, chi, n1, 53);
acb_dirichlet_pairing(zn2, G, m, n1, 53);
if (!acb_overlaps(zn1, zn2))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("q = %wu\n\n", q);
flint_printf("m = %wu\n\n", m);
flint_printf("n = %wu\n\n", n1);
flint_printf("char = "); acb_printd(zn1, 15); flint_printf("\n\n");
flint_printf("pairing = "); acb_printd(zn2, 15); flint_printf("\n\n");
dirichlet_char_print(G, chi);
dirichlet_char_log(chi, G, m);
flint_printf("log(m) = "); dirichlet_char_print(G, chi);
dirichlet_char_log(chi, G, n1);
flint_printf("log(n1) = "); dirichlet_char_print(G, chi);
flint_abort();
}
acb_dirichlet_pairing(zn2, G, m, n2, 53);
acb_dirichlet_pairing(zn1n2, G, m, n1 * n2, 53);
acb_mul(zn1zn2, zn1, zn2, 53);
if (!acb_overlaps(zn1n2, zn1zn2))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("q = %wu\n\n", q);
flint_printf("m = %wu\n\n", m);
flint_printf("n1 = %wu\n\n", n1);
flint_printf("n2 = %wu\n\n", n2);
flint_printf("zn1 = "); acb_printd(zn1, 15); flint_printf("\n\n");
flint_printf("zn2 = "); acb_printd(zn2, 15); flint_printf("\n\n");
flint_printf("zn1n2 = "); acb_printd(zn1n2, 15); flint_printf("\n\n");
flint_printf("zn1zn2 = "); acb_printd(zn1zn2, 15); flint_printf("\n\n");
flint_abort();
}
}
if (iter % 10 == 0)
{
/* check orthogonality */
acb_zero(zn1);
n1 = n_randint(state, 1000);
for (m = 1; m <= q; m++)
{
if (n_gcd(q, m) == 1)
{
acb_dirichlet_pairing(zn2, G, m, n1, 53);
acb_add(zn1, zn1, zn2, 53);
}
}
if (n1 % q == 1 % q)
res = arb_contains_si(acb_realref(zn1), n_euler_phi(q)) &&
arb_contains_zero(acb_imagref(zn1));
else
res = acb_contains_zero(zn1);
if (!res)
{
flint_printf("FAIL: orthogonality\n\n");
flint_printf("q = %wu\n\n", q);
flint_printf("phi = %wu\n\n", n_euler_phi(q));
flint_printf("n1 = %wu\n\n", n1);
flint_printf("zn1 = "); acb_printd(zn1, 15); flint_printf("\n\n");
flint_abort();
}
}
dirichlet_group_clear(G);
dirichlet_char_clear(chi);
acb_clear(zn1);
acb_clear(zn2);
acb_clear(zn1n2);
acb_clear(zn1zn2);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
acb_hypgeom_2f1_transform_limit(acb_t res, const acb_t a, const acb_t b,
const acb_t c, const acb_t z, int regularized, int which, slong prec)
{
acb_poly_t aa, bb, cc, zz;
acb_t t;
if (acb_contains_zero(z) || !acb_is_finite(z))
{
acb_indeterminate(res);
return;
}
if (arb_contains_si(acb_realref(z), 1) && arb_contains_zero(acb_imagref(z)))
{
acb_indeterminate(res);
return;
}
if (!regularized)
{
acb_init(t);
acb_gamma(t, c, prec);
acb_hypgeom_2f1_transform_limit(res, a, b, c, z, 1, which, prec);
acb_mul(res, res, t, prec);
acb_clear(t);
return;
}
acb_poly_init(aa);
acb_poly_init(bb);
acb_poly_init(cc);
acb_poly_init(zz);
acb_init(t);
acb_poly_set_acb(aa, a);
acb_poly_set_acb(bb, b);
acb_poly_set_acb(cc, c);
acb_poly_set_acb(zz, z);
if (which == 2 || which == 3)
{
acb_sub(t, b, a, prec);
acb_poly_set_coeff_si(aa, 1, 1);
/* prefer b-a nonnegative (either is correct) to avoid
expensive operations in the hypergeometric series */
if (arb_is_nonnegative(acb_realref(t)))
_acb_hypgeom_2f1_transform_limit(res, aa, bb, cc, zz, which, prec);
else
_acb_hypgeom_2f1_transform_limit(res, bb, aa, cc, zz, which, prec);
}
else
{
acb_poly_set_coeff_si(aa, 1, 1);
_acb_hypgeom_2f1_transform_limit(res, aa, bb, cc, zz, which, prec);
}
acb_poly_clear(aa);
acb_poly_clear(bb);
acb_poly_clear(cc);
acb_poly_clear(zz);
acb_clear(t);
}
