void
fq_zech_ctx_randtest(fq_zech_ctx_t ctx, flint_rand_t state)
{
fmpz_t p;
slong max_d, d;
fq_nmod_ctx_struct * fq_nmod_ctx;
fq_nmod_ctx = flint_malloc(sizeof(fq_nmod_ctx_struct));
fmpz_init(p);
fmpz_set_ui(p, n_randprime(state, 2 + n_randint(state, 4), 1));
max_d = floor(log(n_pow(2, 16)) / log(fmpz_get_ui(p)));
d = n_randint(state, max_d - 1) + 2;
fq_nmod_ctx_init(fq_nmod_ctx, p, d, "a");
fq_zech_ctx_init_fq_nmod_ctx(ctx, fq_nmod_ctx);
fmpz_clear(p);
ctx->owns_fq_nmod_ctx = 1;
}
int main(void)
{
int i, j, result;
flint_rand_t state;
flint_randinit(state);
printf("factor_trial_range....");
fflush(stdout);
for (i = 0; i < 10000; i++) /* Test random numbers */
{
mp_limb_t n1, n2;
n_factor_t factors;
n_factor_init(&factors);
n1 = n_randtest_not_zero(state);
n2 = n_factor_trial_range(&factors, n1, 100UL, 10000UL);
for (j = 0; j < factors.num; j++)
{
n2 *= n_pow(factors.p[j], factors.exp[j]);
}
result = (n1 == n2);
if (!result)
{
printf("FAIL\n");
printf("n1 = %lu, n2 = %lu\n", n1, n2);
abort();
}
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
int main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("flog....");
fflush(stdout);
for (i = 0; i < 10000 * flint_test_multiplier(); i++)
{
mp_limb_t a = 0, b = 0, k, x;
while (a < 1)
a = n_randtest(state);
while (b < 2)
b = n_randtest(state);
k = n_flog(a, b);
x = n_pow(b, k);
result = (x <= a && a / b < x);
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("a = %wu\n", a);
flint_printf("b = %wu\n", b);
flint_printf("x = %wu\n", x);
flint_printf("k = %wu\n", k);
}
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main(void)
{
slong n;
FLINT_TEST_INIT(state);
flint_printf("primes....");
fflush(stdout);
_flint_rand_init_gmp(state);
/* compare with n_nextprime */
{
n_primes_t iter;
slong i;
mp_limb_t p, q;
n_primes_init(iter);
q = 0;
for (i = 0; i < 200000; i++)
{
p = n_primes_next(iter);
q = n_nextprime(q, 0);
if (p != q)
{
flint_printf("FAIL\n");
flint_printf("i = %wu, p = %wu, q = %wu\n", i, p, q);
abort();
}
}
n_primes_clear(iter);
}
/* count primes */
for (n = 0; n < 10; n++)
{
n_primes_t iter;
mp_limb_t s, p, r;
const unsigned int primepi[10] = {
0, 4, 25, 168, 1229, 9592, 78498, 664579, 5761455, 50847534
};
r = n_pow(10, n);
n_primes_init(iter);
s = 0;
while ((p = n_primes_next(iter)) <= r)
s++;
if (s != primepi[n])
{
flint_printf("FAIL\n");
flint_printf("pi(10^%wd) = %u, computed = %wu\n", n, primepi[n], s);
abort();
}
n_primes_clear(iter);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
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);
}
// Version Fq
void fq_poly_compose_mod_kedlaya_umans(fq_poly_t fg, const fq_poly_t f, const fq_poly_t g, const fq_poly_t h, slong d, fq_ctx_t ctx) {
slong n, i, j, m, dm, N, Nm, degree;
fmpz* p;
fmpz_t q;
fq_multi_poly_t f_prime;
fq_struct *vect_beta, *vect_alpha, *vect_alpha2, *vect_eval;
fq_poly_t gi;
// Vérification des paramètres
n = FLINT_MAX(fq_poly_length(f,ctx),fq_poly_length(g,ctx));
i = fq_poly_length(h,ctx);
if(n >= i) {
printf("Erreur, f ou g n'a pas été modulé par h.\n");
exit(1);
}
// Les polynômes f et g étant réduits modulo h, n vaut le nombre de coefficients de h
n = i;
if(d < 2) {
printf("d < 2\n");
exit(1);
}
if(d >= n) {
printf("d >= n\n");
exit(1);
}
p = fq_ctx_prime(ctx);
degree = fq_ctx_degree(ctx);
m = n_clog(n,d);
dm = n_pow(d,m);
N = n_pow(d,m)*m*d;
Nm = N*m;
if(fmpz_cmp_ui(p,N) < 0) {
flint_printf("\nErreur, pas assez de points d'interpolation !\n");
flint_printf("\np tient sur un mot machine, utilisez donc la version fq_nmod !\n");
exit(1);
}
// Étape 1 //////////////////////////////
fq_multi_poly_init(f_prime, dm, d, m, ctx);
_fq_vec_zero(f_prime->poly, dm, ctx);
for(i = 0 ; i < n ; i++) {
fq_poly_get_coeff(&(f_prime->poly[i]),f,i,ctx);
}
// Étape 3 //////////////////////////////
vect_beta = _fq_vec_init(N,ctx);
for(i = 0 ; i < N ; i++) {
fmpz_poly_set_coeff_ui(vect_beta + i, 0, i);
}
vect_alpha = _fq_vec_init(N*m, ctx);
fq_poly_init(gi,ctx);
fq_poly_set(gi,g,ctx);
fq_poly_evaluate_fq_vec(vect_alpha, gi, vect_beta, N, ctx);
for(i = 1 ; i < m ; i++) {
// Étape 2 //////////////////////////////
// Calcul du g^(d^i) avec g^(d^i) = [ (g^(d^(i-1))) ^ d ] mod h
fq_poly_powmod_ui_binexp(gi,gi,d,h,ctx);
fq_poly_evaluate_fq_vec(vect_alpha+i*N, gi, vect_beta, N, ctx);
}
fq_poly_clear(gi, ctx);
// Transposition
// Passe de m lignes N colonnes
// à N lignes m colonnes ==> nécessaire pour EMM dans Fp
vect_alpha2 = _fq_vec_init(Nm,ctx);
for(i = 0 ; i < m ; i++) {
for(j = 0 ; j < N ; j++) {
fq_set(vect_alpha2 + j*m + i,vect_alpha + i*N + j,ctx);
}
}
vect_alpha = vect_alpha2;
// Étape 4 //////////////////////////////
// EMM
vect_eval = _fq_vec_init(N,ctx);
fq_multi_poly_multimodular(vect_eval, N, f_prime, vect_alpha, ctx);
_fq_vec_clear(vect_alpha,Nm,ctx);
fq_multi_poly_clear(f_prime,ctx);
// Étape 5 //////////////////////////////
fq_poly_interpolate_fq_vec_fast(fg, vect_beta, vect_eval, N, ctx);
_fq_vec_clear(vect_beta,N,ctx);
_fq_vec_clear(vect_eval,N,ctx);
// Étape 6 //////////////////////////////
fq_poly_rem(fg,fg,h,ctx);
}
