void
dirichlet_prime_group_init(dirichlet_prime_group_struct * P, ulong p, int e)
{
P->p = p;
P->e = e;
if (p == 2 || p == 4)
{
P->p = 2;
nmod_init(&P->pe, 1 << e);
if (p == 2)
{
P->e = 2;
nmod_init(&P->phi, 2);
P->g = (1 << e) - 1;
}
else
{
nmod_init(&P->phi, 1 << (e - 2));
P->g = 5;
}
}
else
{
ulong pe1;
pe1 = n_pow(p, e - 1);
nmod_init(&P->phi, (p-1) * pe1);
nmod_init(&P->pe, p * pe1);
P->g = primitive_root_p_and_p2(p);
}
P->dlog = NULL;
}
void
dlog_rho_init(dlog_rho_t t, ulong a, ulong mod, ulong n)
{
t->a = a;
nmod_init(&t->n, n);
nmod_init(&t->mod, mod);
t->nisprime = n_is_prime(n);
}
void sample(void * arg, ulong count)
{
mp_limb_t n;
nmod_t mod;
info_t * info = (info_t *) arg;
mp_bitcnt_t bits = info->bits;
mp_ptr vec = _nmod_vec_init(1000);
mp_ptr vec2 = _nmod_vec_init(1000);
mp_size_t j;
long i;
flint_rand_t state;
flint_randinit(state);
for (j = 0; j < 1000; j++)
vec[j] = n_randlimb(state);
prof_start();
for (i = 0; i < count; i++)
{
n = n_randbits(state, bits);
if (n == 0UL) n++;
nmod_init(&mod, n);
_nmod_vec_reduce(vec2, vec, 1000, mod);
}
prof_stop();
flint_randclear(state);
_nmod_vec_clear(vec);
_nmod_vec_clear(vec2);
}
/*------------------------------------------------------------*/
void check(int opt){
long i;
flint_rand_t state;
flint_randinit(state);
mp_limb_t n = 65537;
nmod_t mod;
nmod_init(&mod, n);
for (i = 1; i < 2000; i+=30){
if (opt == 1){
mp_limb_t root = nmod_poly_find_root(i, mod);
sage_output_init(mod);
printf("root = k(%ld)\n", root);
printf("root.multiplicative_order() > %ld\n", i);
}
else{
double t;
long j;
t = util_gettime();
for (j = 0; j < 10000; j++)
nmod_poly_find_root(i, mod);
t = util_gettime()-t;
printf("%ld %f\n", i, t);
}
}
flint_randclear(state);
}
int
main(void)
{
int i;
flint_rand_t state;
flint_randinit(state);
printf("dot_ptr....");
fflush(stdout);
for (i = 0; i < 10000; i++)
{
long len;
nmod_t mod;
mp_limb_t m, res, res2;
mp_ptr x, y;
mp_ptr * z;
int limbs1;
long j, offset;
len = n_randint(state, 1000) + 1;
m = n_randtest_not_zero(state);
offset = n_randint(state, 10);
nmod_init(&mod, m);
x = _nmod_vec_init(len);
y = _nmod_vec_init(len);
z = flint_malloc(sizeof(mp_ptr) * len);
_nmod_vec_randtest(x, state, len, mod);
_nmod_vec_randtest(y, state, len, mod);
for (j = 0; j < len; j++)
z[j] = &y[j] + offset;
limbs1 = _nmod_vec_dot_bound_limbs(len, mod);
res = _nmod_vec_dot_ptr(x, z, -offset, len, mod, limbs1);
res2 = _nmod_vec_dot(x, y, len, mod, limbs1);
if (res != res2)
{
printf("FAIL:\n");
printf("m = %lu\n", m);
printf("len = %ld\n", len);
printf("limbs1 = %d\n", limbs1);
abort();
}
_nmod_vec_clear(x);
_nmod_vec_clear(y);
flint_free(z);
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
ARingZZpFlint::ARingZZpFlint(size_t p0) : mCharac(p0)
{
nmod_init(&mModulus, p0);
flint_randinit(mRandomState);
fmpz_init(mFmpzCharac);
fmpz_set_ui(mFmpzCharac, mCharac);
mGenerator = n_primitive_root_prime(mCharac);
}
ulong
dlog_crt_init(dlog_crt_t t, ulong a, ulong mod, ulong n, ulong num)
{
int k;
n_factor_t fac;
ulong * M, * u;
ulong cost = 0;
n_factor_init(&fac);
n_factor(&fac, n, 1);
t->num = fac.num;
nmod_init(&t->mod,mod);
nmod_init(&t->n, n);
M = t->expo = flint_malloc(t->num * sizeof(ulong));
u = t->crt_coeffs = flint_malloc(t->num * sizeof(ulong));
t->pre = flint_malloc(t->num * sizeof(dlog_precomp_struct));
for (k = 0; k < t->num; k++)
{
ulong p, e, mk;
p = fac.p[k];
e = fac.exp[k];
if (0 && mod % p == 0)
{
flint_printf("dlog_crt_init: modulus must be prime to order.\n");
abort();
}
mk = n_pow(p, e);
M[k] = n / mk;
u[k] = nmod_mul(M[k], n_invmod(M[k] % mk, mk), t->n);
/* depends on the power */
#if 0
flint_printf("[sub-crt -- init for size %wu mod %wu]\n", mk, mod);
#endif
dlog_precomp_pe_init(t->pre + k, nmod_pow_ui(a, M[k], t->mod), mod, p, e, mk, num);
cost += t->pre[k].cost;
}
#if 0
if (cost > 500)
flint_printf("[crt init for size %wu mod %wu -> cost %wu]\n", n,mod,cost);
#endif
return cost;
}
/*------------------------------------------------------------*/
void check(int opt){
long i;
flint_rand_t state;
flint_randinit(state);
mp_limb_t n = 65537;
nmod_t mod;
nmod_init(&mod, n);
for (i = 1; i < 200; i+=1){
mp_ptr val = _nmod_vec_init(i);
mp_limb_t q = nmod_poly_find_root(i, mod);
if (opt == 1){
nmod_poly_eval_geom_derivative_fanin(val, q, i, mod);
sage_output_init(mod);
printf("q = k(%lu)\n", q);
printf("i = %lu\n", i);
sage_output_assign_vec(val, i, "val");
printf("P = mul([x-q^j for j in range(i)])\n");
printf("val == [P.derivative()(q^j) for j in range(i)]\n");
}
else{
double t, u;
long j;
t = util_gettime();
for (j = 0; j < 10000; j++)
nmod_poly_eval_geom_derivative_fanin(val, q, i, mod);
t = util_gettime() - t;
nmod_poly_t tmp1, tmp2, tmp3;
nmod_poly_init(tmp1, n);
nmod_poly_init(tmp2, n);
nmod_poly_init(tmp3, n);
nmod_poly_rand_dense(tmp1, state, i);
nmod_poly_rand_dense(tmp2, state, i);
u = util_gettime();
for (j = 0; j < 10000; j++)
nmod_poly_mul(tmp3, tmp1, tmp2);
u = util_gettime() - u;
nmod_poly_clear(tmp1);
nmod_poly_clear(tmp2);
nmod_poly_clear(tmp3);
printf("%lu %f %f\n", i, t, u);
}
_nmod_vec_clear(val);
}
flint_randclear(state);
}
void
ring_init_mod(ring_t ring, const ring_t elem_ring, elem_srcptr modulus)
{
ring->type = TYPE_MOD;
ring->size = elem_ring->size;
ring->parent = (ring_struct *) elem_ring;
ring->modulus = (elem_ptr) modulus; /* should this make a copy? */
if (elem_ring->type == TYPE_LIMB)
nmod_init(&ring->nmod, *((mp_ptr) modulus));
}
int
main(void)
{
int i;
FLINT_TEST_INIT(state);
flint_printf("dot_bound_limbs....");
fflush(stdout);
for (i = 0; i < 1000000; i++)
{
slong len;
nmod_t mod;
mp_limb_t m;
int limbs1, limbs2;
mpz_t t;
len = n_randint(state, 10000) + 1;
m = n_randtest_not_zero(state);
nmod_init(&mod, m);
limbs1 = _nmod_vec_dot_bound_limbs(len, mod);
mpz_init2(t, 4*FLINT_BITS);
flint_mpz_set_ui(t, m-1);
mpz_mul(t, t, t);
flint_mpz_mul_ui(t, t, len);
limbs2 = mpz_size(t);
if (limbs1 != limbs2)
{
flint_printf("FAIL:\n");
flint_printf("m = %wu\n", m);
flint_printf("len = %wd\n", len);
flint_printf("limbs1 = %d\n", limbs1);
flint_printf("limbs2 = %d\n", limbs2);
gmp_printf("bound: %Zd\n", t);
abort();
}
mpz_clear(t);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
void
acb_dirichlet_jacobi_sum_naive(acb_t res, const dirichlet_group_t G, const dirichlet_char_t chi1, const dirichlet_char_t chi2, slong prec)
{
ulong k1, k2, m1, m2, g, e, m;
ulong * v1, * v2;
slong *v;
nmod_t expo;
acb_t z;
v1 = flint_malloc(G->q * sizeof(ulong));
v2 = flint_malloc(G->q * sizeof(ulong));
dirichlet_vec_set_null(v1, G, G->q);
dirichlet_chi_vec_loop(v1, G, chi1, G->q);
dirichlet_vec_set_null(v2, G, G->q);
dirichlet_chi_vec_loop(v2, G, chi2, G->q);
nmod_init(&expo, G->expo);
m1 = dirichlet_order_char(G, chi1);
m2 = dirichlet_order_char(G, chi2);
g = m1 * m2 / n_gcd(m1, m2);
m = G->expo / g;
v = flint_malloc(g * sizeof(slong));
for (e = 0; e < g; e++)
v[e] = 0;
for (k1 = 2, k2 = G->q - 1; k2 > 1; k1++, k2--)
{
if (v1[k1] == DIRICHLET_CHI_NULL ||
v2[k2] == DIRICHLET_CHI_NULL)
continue;
e = nmod_add(v1[k1], v2[k2], expo) / m;
v[e]++;
}
acb_init(z);
acb_unit_root(z, g, prec);
acb_dirichlet_si_poly_evaluate(res, v, g, z, prec);
acb_clear(z);
flint_free(v);
flint_free(v2);
flint_free(v1);
}
int
main(void)
{
int i, result;
flint_rand_t state;
flint_randinit(state);
printf("reduce....");
fflush(stdout);
for (i = 0; i < 10000; i++)
{
long j, len = n_randint(state, 100) + 1;
mp_ptr vec = _nmod_vec_init(len);
mp_ptr vec2 = _nmod_vec_init(len);
mp_limb_t n = n_randtest_not_zero(state);
nmod_t mod;
nmod_init(&mod, n);
for (j = 0; j < len; j++)
{
vec[j] = n_randtest(state);
vec2[j] = vec[j];
}
_nmod_vec_reduce(vec, vec, len, mod);
for (j = 0; j < len; j++)
vec2[j] = n_mod2_preinv(vec2[j], mod.n, mod.ninv);
result = _nmod_vec_equal(vec, vec2, len);
if (!_nmod_vec_equal(vec, vec2, len))
{
printf("FAIL:\n");
printf("len = %ld, n = %ld\n", len, n);
abort();
}
_nmod_vec_clear(vec);
_nmod_vec_clear(vec2);
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
int main(void)
{
flint_rand_t state;
long i, j;
printf("bell_number_nmod....");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 10; i++)
{
mp_ptr b;
long n;
nmod_t mod;
mp_limb_t p;
n = n_randint(state, 1000);
p = n_randtest_prime(state, 0);
nmod_init(&mod, p);
b = _nmod_vec_init(n + 1);
bell_number_nmod_vec(b, n + 1, mod);
for (j = 0; j <= n; j++)
{
mp_limb_t u = bell_number_nmod(j, mod);
if (u != b[j])
{
printf("FAIL: p = %lu, i = %ld\n", p, j);
abort();
}
}
_nmod_vec_clear(b);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
void
dirichlet_group_init(dirichlet_group_t G, ulong q)
{
slong k;
ulong e2;
n_factor_t fac;
G->q = q;
nmod_init(&G->mod, q);
e2 = n_remove(&q, 2);
G->q_even = 1 << e2;
/* number of components at p=2 */
G->neven = (e2 >= 3) ? 2 : (e2 == 2) ? 1 : 0;
/* warning: only factor odd part */
n_factor_init(&fac);
n_factor(&fac, q, 1);
G->num = fac.num + G->neven;
G->P = flint_malloc(G->num * sizeof(dirichlet_prime_group_struct));
G->generators = flint_malloc(G->num * sizeof(ulong));
G->PHI = flint_malloc(G->num * sizeof(ulong));
/* even part */
if (G->neven >= 1)
dirichlet_prime_group_init(&G->P[0], 2, e2);
if (G->neven == 2)
dirichlet_prime_group_init(&G->P[1], 4, e2);
/* odd part */
G->rad_q = 1;
for (k = G->neven; k < G->num; k++)
{
ulong p, e;
p = fac.p[k - G->neven];
e = fac.exp[k - G->neven];
G->rad_q *= p;
dirichlet_prime_group_init(&G->P[k], p, e);
}
dirichlet_group_lift_generators(G);
}
/*------------------------------------------------------------*/
void check(int opt){
long i;
flint_rand_t state;
flint_randinit(state);
mp_limb_t n = 65537;
nmod_t mod;
nmod_init(&mod, n);
for (i = 1; i < 1000; i+=3){
mp_ptr v = _nmod_vec_init(i);
nmod_vec_rand_dense(v, state, i, mod);
if (opt == 1){
sage_output_init(mod);
sage_output_assign_vec(v, i, "v");
}
_nmod_vec_clear(v);
}
flint_randclear(state);
}
void
nmod_mat_multiplication_test_benchmark(
slong dim0,slong dim1,slong dim2,
mp_limb_t p,
slong experiments)
{
assert(experiments >= 1);
assert(dim2 > 1);
clock_t t0,t1,t2,t3;
slong i;
mp_limb_t* update_me;
nmod_mat_t A0,B0,C0,A1,B1,C1,C2;
p_k_pk_t P; P.p=p;
nmod_t M0,M1;
flint_randinit(st);
init__p_k_pk__and__nmod( &P, &M0 );
nmod_init( &M1, P.p_deg_k );
init_matrix(A0,B0, C0,C1,C2, dim0,dim1,dim2, M0);
reduce_modulo( A1, A0, M1);
reduce_modulo( B1, B0, M1);
--experiments;
memcpy( &C2->mod, &M1, sizeof(nmod_t) );
memcpy( &C1->mod, &M1, sizeof(nmod_t) );
t0=clock();
CHAIN_MULT(experiments, nmod_mat_mul, A1, B1, C2, C1);
t1=clock();
memcpy( &C2->mod, &M0, sizeof(nmod_t) );
memcpy( &C0->mod, &M0, sizeof(nmod_t) );
t2=clock();
CHAIN_MULT(experiments, nmod_mat_mul_pk_classical, A0, B0, C2, C0);
t3=clock();
equality_check( C0, C1 );
flint_printf("2**%w * %wu**%wu | %w %w %w: ",M1.norm,p,P.k,dim0,dim1,dim2);
// ************************ Warning ************************
// line below works on amd64/Linux,
flint_printf("%w %w\n", t1-t0, t3-t2); // because clock_t is slong
// If clock_t is not integer, replace format string above with smth else
}
void
bell_number_multi_mod(fmpz_t res, ulong n)
{
fmpz_comb_temp_t temp;
fmpz_comb_t comb;
nmod_t mod;
mp_ptr primes, residues;
long k, size, prime_bits, num_primes;
size = bell_number_size(n);
prime_bits = FLINT_BITS - 1;
num_primes = (size + prime_bits - 1) / prime_bits;
primes = flint_malloc(num_primes * sizeof(mp_limb_t));
residues = flint_malloc(num_primes * sizeof(mp_limb_t));
primes[0] = n_nextprime(1UL << prime_bits, 0);
for (k = 1; k < num_primes; k++)
primes[k] = n_nextprime(primes[k-1], 0);
for (k = 0; k < num_primes; k++)
{
nmod_init(&mod, primes[k]);
residues[k] = bell_number_nmod(n, mod);
}
fmpz_comb_init(comb, primes, num_primes);
fmpz_comb_temp_init(temp, comb);
fmpz_multi_CRT_ui(res, residues, comb, temp, 0);
fmpz_comb_clear(comb);
fmpz_comb_temp_clear(temp);
flint_free(primes);
flint_free(residues);
}
/*------------------------------------------------------------*/
void check(int opt){
mp_limb_t n = 12345;
nmod_t Zn;
nmod_init(&Zn, n);
sage_output_init(Zn);
nmod_poly_t a;
nmod_poly_init2(a, n, 10);
long i;
for (i = 0; i < 10; i++)
a->coeffs[i] = i;
a->length = 10;
_nmod_poly_normalise(a);
sage_output_print_poly(a);
printf("\n");
nmod_poly_zero(a);
sage_output_print_poly(a);
printf("\n");
nmod_poly_clear(a);
}
int main(int argc, char *argv[])
{
int out = LOG;
int i, ni = 8;
int bits[9] = { 10, 15, 20, 25, 30, 35, 40, 45, 50 };
int j, nj = 6;
ulong * v;
ulong nv[6] = { 50, 200, 1000, 2000, 10000, 30000 };
int k, np = NPRIMES;
nmod_t * p;
ulong * a;
int l, nf = 5;
vec_f func[5] = { f_empty, dlog_vec_loop, dlog_vec_eratos, dlog_vec_sieve, dlog_vec };
char * n[5] = { "empty", "loop", "eratos", "sieve", "default" };
flint_rand_t state;
nmod_t order;
nmod_init(&order, 100);
p = flint_malloc(np * sizeof(nmod_t));
a = flint_malloc(np * sizeof(ulong));
flint_randinit(state);
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]);
abort();
}
for (i = 0; i < ni; i++)
{
for (k = 0; k < np; k++)
{
nmod_init(&p[k], n_randprime(state, bits[i], 0));
a[k] = n_primitive_root_prime(p[k].n);
}
for (j = 0; j < nj; j++)
{
v = flint_malloc(nv[j] * sizeof(ulong));
if (out == LOG)
{
flint_printf("log(1..%wu) mod %d primes of size %d bits....\n", nv[j], np, bits[i]);
fflush(stdout);
}
for (l = 0; l < nf; l++)
{
if (l == 1 && i > 2)
continue;
if (l == 2 && i > 5)
continue;
if (out == LOG)
{
flint_printf("%-20s... ",n[l]);
fflush(stdout);
}
else if (out == CSV)
{
flint_printf("%-8s, %2d, %4d, %3d, ",n[l],bits[i],nv[j],np);
}
else if (out == JSON)
{
flint_printf("{ \"name\": \"%s\", \"bits\": %d, \"nv\": %d, \"nprimes\": %d, \"time\": ",
n[l],bits[i],nv[j],np);
}
TIMEIT_ONCE_START
for (k = 0; k < np; k++)
{
int kk;
for (kk=0; kk < nv[j]; kk++)
v[kk] = 0;
(func[l])(v, nv[j], a[k], 1, p[k], p[k].n - 1, order);
}
TIMEIT_ONCE_STOP
if (out == JSON)
flint_printf("}\n");
else
flint_printf("\n");
}
flint_free(v);
}
np /= 2;
}
flint_free(p);
flint_free(a);
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong bits, nv, iter;
flint_rand_t state;
int f, nf = 4;
vec_f func[4] = { dlog_vec_trivial, dlog_vec_loop, dlog_vec_eratos,
dlog_vec_sieve };
char * n[4] = { "trivial", "loop", "eratos", "sieve" };
flint_printf("vec....");
fflush(stdout);
flint_randinit(state);
for (bits = 10; bits <= FLINT_MIN(35, FLINT_BITS); bits += 5)
{
for (nv = 10; nv <= 10000; nv *= 10)
{
ulong *v, *ref;
int iref;
iref = (bits == 10 && nv <= 1000) ? 0 : 2;
ref = flint_malloc(nv * sizeof(ulong));
v = flint_malloc(nv * sizeof(ulong));
for (iter = 0; iter < 10; iter++)
{
int k;
ulong p, a, va, na;
nmod_t mod, order;
p = n_randprime(state, bits, 0);
a = n_primitive_root_prime(p);
nmod_init(&mod, p);
va = 1; na = p - 1;
nmod_init(&order, na);
dlog_vec_fill(ref, nv, 0);
(func[iref])(ref, nv, a, va, mod, na, order);
/* compare */
for (f = iref + 1; f < nf; f++)
{
dlog_vec_fill(v, nv, 0);
(func[f])(v, nv, a, va, mod, na, order);
if ((k = dlog_vec_diff(v, ref, nv)))
{
flint_printf("FAIL: log(%wu,%wu) mod %wu: %s->%w != %s->%w\n",
k, a, p, n[iref], ref[k], n[f], v[k]);
abort();
}
}
}
flint_free(ref);
flint_free(v);
}
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
dirichlet_subgroup_init(dirichlet_group_t H, const dirichlet_group_t G, ulong h)
{
int s[15]; /* selected components */
slong k, j, e2;
H->q = h;
nmod_init(&H->mod, h);
/* even components */
e2 = n_remove(&h, 2);
H->q_even = 1 << e2;
s[0] = s[1] = 0;
j = 0;
if (e2 >= 2)
s[j++] = 2;
if (e2 >= 3)
s[j++] = e2;
H->neven = j;
/* odd components */
for (k = G->neven; k < G->num; k++)
{
ulong p = G->P[k].p;
s[k] = n_remove(&h, p);
if (s[k] > 0)
{
j++;
H->rad_q *= p;
}
}
H->num = j;
H->P = flint_malloc(j * sizeof(dirichlet_prime_group_struct));
H->generators = flint_malloc(j * sizeof(ulong));
H->PHI = flint_malloc(j * sizeof(ulong));
j = 0;
for (k = 0; k < H->neven; k++)
{
H->P[j] = G->P[k];
if (H->q_even < G->q_even)
{
nmod_init(&H->P[j].pe, H->q_even);
H->P[j].e = s[k];
if (k == 0)
H->P[j].g = H->q_even - 1;
else
nmod_init(&H->P[j].phi, H->q_even / 4);
}
j++;
}
for (k = G->neven; k < G->num; k++)
{
if (s[k])
{
H->P[j] = G->P[k];
if (s[k] < G->P[k].e)
{
ulong pf, p = H->P[j].p;
H->P[j].e = s[k];
pf = n_pow(p, s[k]);
nmod_init(&H->P[j].pe, pf);
nmod_init(&H->P[j].phi, (p-1) * pf / p);
}
j++;
}
}
dirichlet_group_lift_generators(H);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("dlog....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000; iter++)
{
dlog_table_t table;
dlog_bsgs_t bsgs;
dlog_crt_t crt;
dlog_precomp_t pre1, pre100;
ulong p, a, k;
nmod_t modp;
if (iter < 10)
p = n_nth_prime(iter + 2);
else
p = n_randprime(state, 15, 0);
nmod_init(&modp, p);
a = n_primitive_root_prime(p);
dlog_table_init(table, a, p);
dlog_bsgs_init(bsgs, a, p, p-1, dlog_bsgs_size(p, 1));
dlog_crt_init(crt, a, p, p-1, 10);
dlog_precomp_n_init(pre1, a, p, p-1, 1);
dlog_precomp_n_init(pre100, a, p, p-1, 100);
for (k = 1; k < 100 && k < p; k++)
{
ulong l0, l1, l2, l3, l4, l5;
l1 = dlog_table(table, k);
l2 = dlog_bsgs(bsgs, k);
l3 = dlog_crt(crt, k);
l4 = dlog_precomp(pre1, k);
l5 = dlog_precomp(pre100, k);
if (iter < 50 && k <= 7)
l0 = dlog_once(k, a, modp, p-1);
else
l0 = l1;
if (l0 != l1 || l1 != l2 || l1 != l3 || l1 != l4 || l1 != l5)
{
flint_printf("\n\nFAIL: log(%wu,%wu) mod %wu\n\n",k,a,p);
flint_printf("once: %wu\ntable: %wu\nbsgs: %wu\ncrt: %wu\nprecomp1: %wu\nprecomp100: %wu\n\n",
l0, l1, l2, l3, l4, l5);
abort();
}
}
dlog_table_clear(table);
dlog_bsgs_clear(bsgs);
dlog_crt_clear(crt);
dlog_precomp_clear(pre1);
dlog_precomp_clear(pre100);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
