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);
}
int main() {
slong i;
mp_limb_t p, w;
nmod_poly_t f;
mp_ptr res, res2, vect;
// p premier
// Le cardinal du groupe multiplicatif doit être une puissance de 2
// Ne marche que pour p = 0, 1, 2, 3, 5, 17, 257, 65537.
p = 17;
nmod_poly_init(f, p);
nmod_poly_set_coeff_ui(f, 0, 0);
nmod_poly_set_coeff_ui(f, 1, 1);
nmod_poly_set_coeff_ui(f, 2, 2);
nmod_poly_set_coeff_ui(f, 3, 1);
nmod_poly_set_coeff_ui(f, 4, 1);
w = n_primitive_root_prime(p);
res = _nmod_vec_init(p);
nmod_poly_fft_pow2(res, f, w);
flint_printf("w : %d\n", w);
_fmpz_vec_print(res, p);
flint_printf("\n");
vect = _nmod_vec_init(p);
for(i = 0 ; i < p ; i++) {
vect[i] = i;
}
res2 = _nmod_vec_init(p);
nmod_poly_evaluate_nmod_vec(res2, f, vect, p);
_fmpz_vec_print(res2, p);
flint_printf("\nBooléen d'égalité : %d\n", _nmod_vec_equal(res,res2,p));
nmod_poly_clear(f);
_nmod_vec_clear(res);
_nmod_vec_clear(res2);
_nmod_vec_clear(vect);
return 0;
}
static ulong
primitive_root_p_and_p2(ulong p)
{
if (p == 40487)
return 10;
#if FLINT_BITS == 64
if (p == UWORD(6692367337))
return 7;
if (p > UWORD(1000000000000))
{
printf("primitive root: p > 10^12 not implemented");
abort();
}
#endif
return n_primitive_root_prime(p);
}
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;
}
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;
}
