static ulong
do_charpluscond(ulong q1, ulong q2)
{
ulong n, q, k;
for (n = 0, q = q1; q <= q2; q++)
{
dirichlet_group_t G;
dirichlet_char_t x;
dirichlet_group_init(G, q);
dirichlet_char_init(x, G);
dirichlet_char_one(x, G);
n++;
for (; dirichlet_char_next(x, G) >= 0; n++)
dirichlet_conductor_char(G, x);
dirichlet_char_clear(x);
dirichlet_group_clear(G);
}
return n;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("l....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000 * 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, 100);
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_si(s, n_randint(state, 50) - 25);
else
acb_randtest(s, state, 2 + n_randint(state, 200), 2);
acb_dirichlet_l_hurwitz(t, s, NULL, G, chi, prec);
acb_dirichlet_l(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;
}
/* should use only for prime power modulus */
void
acb_dirichlet_jacobi_sum_gauss(acb_t res, const dirichlet_group_t G, const dirichlet_char_t chi1, const dirichlet_char_t chi2, slong prec)
{
/* J_q(a,b)G_q(ab) = G_q(a)G_q(b) */
acb_t tmp;
dirichlet_char_t chi12;
dirichlet_char_init(chi12, G);
dirichlet_char_mul(chi12, G, chi1, chi2);
acb_init(tmp);
acb_dirichlet_gauss_sum(res, G, chi1, prec);
if (chi2->n == chi1->n)
acb_set(tmp, res);
else
acb_dirichlet_gauss_sum(tmp, G, chi2, prec);
acb_mul(res, res, tmp, prec);
acb_dirichlet_gauss_sum(tmp, G, chi12, prec);
acb_div(res, res, tmp, prec);
dirichlet_char_clear(chi12);
acb_clear(tmp);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("hardy_z_series....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 200 * arb_test_multiplier(); iter++)
{
slong m, n1, n2, bits1, bits2, bits3;
acb_poly_t S, A, B, C;
dirichlet_group_t G;
dirichlet_char_t chi;
ulong q;
bits1 = 2 + n_randint(state, 200);
bits2 = 2 + n_randint(state, 200);
bits3 = 2 + n_randint(state, 200);
m = 1 + n_randint(state, 8);
n1 = 1 + n_randint(state, 8);
n2 = 1 + n_randint(state, 8);
do {
q = 1 + n_randint(state, 15);
} while (q % 4 == 2);
dirichlet_group_init(G, q);
dirichlet_char_init(chi, G);
do {
dirichlet_char_index(chi, G, n_randint(state, G->phi_q));
} while (!dirichlet_char_is_primitive(G, chi));
acb_poly_init(S);
acb_poly_init(A);
acb_poly_init(B);
acb_poly_init(C);
acb_poly_randtest(S, state, m, bits1, 3);
acb_dirichlet_hardy_z_series(A, S, G, chi, n1, bits2);
acb_poly_set(B, S); /* aliasing */
if (q == 1 && n_randint(state, 2))
acb_poly_neg(B, B);
acb_dirichlet_hardy_z_series(B, B, G, chi, n2, bits3);
acb_poly_set(C, A);
acb_poly_truncate(C, FLINT_MIN(n1, n2));
acb_poly_truncate(B, FLINT_MIN(n1, n2));
if (!acb_poly_overlaps(B, C))
{
flint_printf("FAIL\n\n");
flint_printf("S = "); acb_poly_printd(S, 15); flint_printf("\n\n");
flint_printf("A = "); acb_poly_printd(A, 15); flint_printf("\n\n");
flint_printf("B = "); acb_poly_printd(B, 15); flint_printf("\n\n");
abort();
}
acb_poly_clear(S);
acb_poly_clear(A);
acb_poly_clear(B);
acb_poly_clear(C);
dirichlet_char_clear(chi);
dirichlet_group_clear(G);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
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;
}
int main(int argc, char *argv[])
{
int out;
ulong n, nref, maxq = 5000;
ulong * rand;
flint_rand_t state;
slong r, nr;
int l, nf = 5;
do_f func[5] = { acb_dirichlet_gauss_sum_naive,
acb_dirichlet_gauss_sum_factor,
acb_dirichlet_gauss_sum_theta,
acb_dirichlet_gauss_sum,
acb_dirichlet_gauss_sum };
char * name[5] = { "naive", "factor", "theta", "default", "precomp" };
int i, ni = 5;
ulong qmin[5] = { 3, 50, 500, 1000, 10000 };
ulong qmax[5] = { 50, 100, 599, 1050, 10030 };
int j, nj = 3;
slong prec[3] = { 64, 128, 1024 };
if (argc < 2)
out = LOG;
else if (!strcmp(argv[1], "json"))
out = JSON;
else if (!strcmp(argv[1], "csv"))
out = CSV;
else if (!strcmp(argv[1], "log"))
out = LOG;
else
{
printf("usage: %s [log|csv|json]\n", argv[0]);
flint_abort();
}
if (out == CSV)
flint_printf("# %-12s, %7s, %7s, %7s, %7s\n","name", "prec", "qmin", "qmax", "time");
for (j = 0; j < nj; j++)
{
for (i = 0; i < ni; i++)
{
if (out == LOG)
flint_printf("G_q(a) at prec %wu for all %wu <= q <= %wu....\n", prec[j], qmin[i], qmax[i]);
for (l = 0; l < nf; l++)
{
ulong q;
if (qmin[i] > 2000 && l == 0)
continue;
if (out == LOG)
flint_printf("%-14s ... ", name[l]);
else if (out == CSV)
flint_printf("%-12s, %7d, %7d, %7d, ", name[l], prec[j], qmin[i], qmax[i]);
else if (out == JSON)
flint_printf("{ \"name\": \"%s\", \"prec\": %d, \"qmin\": %d, \"qmax\": %d, \"time\": ",
name[l], prec[j], qmin[i], qmax[i]);
TIMEIT_ONCE_START
for (q = qmin[i]; q <= qmax[i]; q++)
{
dirichlet_group_t G;
dirichlet_char_t chi;
acb_t res;
if (q % 4 == 2)
continue;
dirichlet_group_init(G, q);
if (l == 4)
dirichlet_group_dlog_precompute(G, 1);
dirichlet_char_init(chi, G);
dirichlet_char_first_primitive(chi, G);
acb_init(res);
do {
func[l](res, G, chi, prec[j]);
} while (dirichlet_char_next_primitive(chi, G) >= 0);
acb_clear(res);
dirichlet_char_clear(chi);
if (l == 4)
dirichlet_group_dlog_clear(G);
dirichlet_group_clear(G);
}
TIMEIT_ONCE_STOP
if (out == JSON)
flint_printf("}\n");
else
flint_printf("\n");
}
}
}
flint_cleanup();
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("hardy_z....");
fflush(stdout);
flint_randinit(state);
/* test self-consistency */
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
acb_t s, s2;
dirichlet_group_t G;
dirichlet_char_t chi;
acb_ptr vec1, vec2;
slong len1, len2;
slong prec1, prec2;
ulong q, k;
slong i;
len1 = n_randint(state, 6);
len2 = n_randint(state, 6);
prec1 = 2 + n_randint(state, 100);
prec2 = 2 + n_randint(state, 100);
do {
q = 1 + n_randint(state, 30);
} while (q % 4 == 2);
dirichlet_group_init(G, q);
dirichlet_char_init(chi, G);
do {
k = n_randint(state, n_euler_phi(q));
dirichlet_char_index(chi, G, k);
} while (dirichlet_conductor_char(G, chi) != q);
acb_init(s);
acb_init(s2);
vec1 = _acb_vec_init(len1);
vec2 = _acb_vec_init(len2);
acb_randtest(s, state, 2 + n_randint(state, 200), 2);
acb_randtest(s2, state, 2 + n_randint(state, 200), 2);
acb_sub(s2, s2, s2, 200);
acb_add(s2, s, s2, 200);
acb_dirichlet_hardy_z(vec1, s, G, chi, len1, prec1);
acb_dirichlet_hardy_z(vec2, s2, G, chi, len2, prec2);
for (i = 0; i < FLINT_MIN(len1, len2); i++)
{
if (!acb_overlaps(vec1 + i, vec2 + i))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("iter = %wd q = %wu k = %wu i = %wd\n\n", iter, q, k, i);
flint_printf("s = "); acb_printn(s, 50, 0); flint_printf("\n\n");
flint_printf("r1 = "); acb_printn(vec1 + i, 50, 0); flint_printf("\n\n");
flint_printf("r2 = "); acb_printn(vec2 + i, 50, 0); flint_printf("\n\n");
flint_abort();
}
}
if (arb_contains_zero(acb_imagref(s)))
{
for (i = 0; i < len1; i++)
{
if (!arb_contains_zero(acb_imagref(vec1 + i)))
{
flint_printf("FAIL: real 1\n\n");
flint_printf("iter = %wd q = %wu k = %wu i = %wd\n\n", iter, q, k, i);
flint_printf("s = "); acb_printn(s, 50, 0); flint_printf("\n\n");
flint_printf("r1 = "); acb_printn(vec1 + i, 50, 0); flint_printf("\n\n");
flint_abort();
}
}
}
if (arb_contains_zero(acb_imagref(s2)))
{
for (i = 0; i < len2; i++)
{
if (!arb_contains_zero(acb_imagref(vec2 + i)))
{
flint_printf("FAIL: real 1\n\n");
flint_printf("iter = %wd q = %wu k = %wu i = %wd\n\n", iter, q, k, i);
flint_printf("s = "); acb_printn(s, 50, 0); flint_printf("\n\n");
flint_printf("r1 = "); acb_printn(vec2 + i, 50, 0); flint_printf("\n\n");
flint_abort();
}
}
}
dirichlet_char_clear(chi);
dirichlet_group_clear(G);
acb_clear(s);
acb_clear(s2);
_acb_vec_clear(vec1, len1);
_acb_vec_clear(vec2, len2);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter, bits;
flint_rand_t state;
flint_printf("properties....");
fflush(stdout);
flint_randinit(state);
for (bits = 5; bits <= 30; bits += 5)
{
for (iter = 0; iter < 50; iter++)
{
dirichlet_group_t G;
dirichlet_char_t chi, psi;
ulong q, iter2;
q = 2 + n_randint(state, 1 << bits);
dirichlet_group_init(G, q);
dirichlet_char_init(chi, G);
dirichlet_char_init(psi, G);
/* check number char properties */
for (iter2 = 0; iter2 < 100; iter2++)
{
ulong m, n;
ulong p1, p2, pairing, cm, cn, q2, q3;
dirichlet_group_t G2, G3;
dirichlet_char_t chi2, chi3;
if (iter2 == 50)
dirichlet_group_dlog_precompute(G, 5);
/* one random character */
do
m = n_randint(state, q);
while (n_gcd(q, m) > 1);
dirichlet_char_log(chi, G, m);
p1 = dirichlet_order_ui(G, m);
p2 = dirichlet_order_char(G, chi);
check_eq(p1, p2, q, m, "order m", "order chi");
p1 = dirichlet_conductor_ui(G, m);
p2 = dirichlet_conductor_char(G, chi);
check_eq(p1, p2, q, m, "conductor m", "conductor chi");
p1 = dirichlet_parity_ui(G, m);
p2 = dirichlet_parity_char(G, chi);
check_eq(p1, p2, q, m, "parity m", "parity chi");
p1 = dirichlet_char_is_real(G, chi);
p2 = (dirichlet_order_char(G, chi) <= 2);
check_eq(p1, p2, q, m, "is_real", "(order <= 2)");
/* check index */
p1 = dirichlet_index_char(G, chi);
dirichlet_char_index(psi, G, p1);
if (!dirichlet_char_eq_deep(G, chi, psi))
{
flint_printf("FAIL: index\n\n");
flint_printf("q = %wu\n\n", q);
flint_printf("m = %wu\n\n", m);
flint_printf("chi = "); dirichlet_char_print(G, chi);
flint_printf("\n\nindex(chi) = %wu\n\n", p1);
flint_printf("psi(index) = %wu\n\n", psi->n);
flint_printf("psi = "); dirichlet_char_print(G, psi);
flint_printf("\n\n");
abort();
}
/* lift to higher modulus */
q2 = q * (1 + n_randint(state, 100));
dirichlet_group_init(G2, q2);
dirichlet_char_init(chi2, G2);
dirichlet_char_lift(chi2, G2, chi, G);
p1 = dirichlet_conductor_char(G, chi);
p2 = dirichlet_conductor_char(G2, chi2);
check_eq(p1, p2, q, m, "conductor chi", "conductor lift");
p1 = dirichlet_order_char(G, chi);
p2 = dirichlet_order_char(G2, chi2);
check_eq(p1, p2, q, m, "order chi", "order lift");
/* and lower */
dirichlet_char_lower(psi, G, chi2, G2);
if (!dirichlet_char_eq_deep(G, chi, psi))
{
flint_printf("FAIL: lift and lower back\n\n");
flint_printf("q = %wu\n\nchi = ", q);
dirichlet_char_print(G, chi);
flint_printf("\n\nq2 = %wu\n\nchi2 = ", q2);
dirichlet_char_print(G2, chi2);
flint_printf("\n\nq = %wu\n\npsi = ", q);
dirichlet_char_print(G, psi);
flint_printf("\n\n");
abort();
}
q3 = dirichlet_conductor_char(G, chi) * random_divisor(state, G);
q3 = n_gcd(q, q3);
dirichlet_group_init(G3, q3);
dirichlet_char_init(chi3, G3);
dirichlet_char_lower(chi3, G3, chi2, G2);
p1 = dirichlet_conductor_char(G, chi);
p2 = dirichlet_conductor_char(G3, chi3);
check_eq(p1, p2, q, m, "conductor chi", "conductor lower");
p1 = dirichlet_order_char(G, chi);
p2 = dirichlet_order_char(G3, chi3);
check_eq(p1, p2, q, m, "order chi", "order lower");
dirichlet_char_clear(chi3);
dirichlet_group_clear(G3);
dirichlet_char_clear(chi2);
dirichlet_group_clear(G2);
/* another random character */
do
n = n_randint(state, q);
while (n_gcd(q, n) > 1);
dirichlet_char_log(psi, G, n);
pairing = dirichlet_pairing(G, m, n);
cn = dirichlet_chi(G, chi, n);
cm = dirichlet_chi(G, psi, m);
if (pairing != cn || pairing != cm)
{
flint_printf("FAIL: pairing\n\n");
flint_printf("q = %wu\n\n", q);
flint_printf("m = %wu\n\n", m);
flint_printf("n = %wu\n\n", n);
flint_printf("chi(m,n) = %wu\n\n", pairing);
flint_printf("chi(m)(n) = %wu\n\n", cn);
flint_printf("chi(n)(m) = %wu\n\n", cm);
abort();
}
}
dirichlet_group_dlog_clear(G);
dirichlet_char_clear(chi);
dirichlet_char_clear(psi);
dirichlet_group_clear(G);
}
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
