mp_limb_t
_nmod_poly_evaluate_nmod(mp_srcptr poly, slong len, mp_limb_t c, nmod_t mod)
{
slong m;
mp_limb_t val;
if (len == 0)
return 0;
if (len == 1 || c == 0)
return poly[0];
m = len - 1;
val = poly[m];
m--;
for ( ; m >= 0; m--)
{
val = n_mulmod2_preinv(val, c, mod.n, mod.ninv);
val = n_addmod(val, poly[m], mod.n);
}
return val;
}
// X_i^p = X_i
void nmod_multi_poly_mod_fermat(mp_ptr f_bar, const mp_ptr f, slong p, slong d, slong m, const slong* P) {
if(p < d) {
slong i, cpt, *pos, coord_p;
_nmod_vec_zero(f_bar,n_pow(p,m));
pos = (slong*)calloc(sizeof(slong),m);
coord_p;
cpt = 0;
while(pos[m-1] != d) {
coord_p = Coord_mod(P,p,pos,m);
f_bar[coord_p] = n_addmod(f_bar[coord_p],f[cpt],p);
pos[0]++;
cpt++;
i = 0;
while( (pos[i] == d) && (i != (m-1)) ) {
pos[i] = 0;
// Le i est incrémenté avant pos++
pos[++i]++;
}
}
free(pos);
}
}
void _fq_nmod_trace(fmpz_t rop2, const mp_limb_t *op, slong len,
const fq_nmod_ctx_t ctx)
{
const slong d = fq_nmod_ctx_degree(ctx);
ulong i, l;
mp_limb_t *t, rop;
t = _nmod_vec_init(d);
_nmod_vec_zero(t, d);
t[0] = n_mod2_preinv(d, ctx->mod.n, ctx->mod.ninv);
for (i = 1; i < d; i++)
{
for (l = ctx->len - 2; l >= 0 && ctx->j[l] >= d - (i - 1); l--)
{
t[i] = n_addmod(t[i],
n_mulmod2_preinv(t[ctx->j[l] + i - d], ctx->a[l], ctx->mod.n, ctx->mod.ninv),
ctx->mod.n);
}
if (l >= 0 && ctx->j[l] == d - i)
{
t[i] = n_addmod(t[i],
n_mulmod2_preinv(ctx->a[l], i, ctx->mod.n, ctx->mod.ninv),
ctx->mod.n);
}
t[i] = n_negmod(t[i], ctx->mod.n);
}
rop = WORD(0);
for (i = 0; i < d; i++)
{
rop = n_addmod(rop,
n_mulmod2_preinv(op[i], t[i], ctx->mod.n, ctx->mod.ninv),
ctx->mod.n);
}
_nmod_vec_clear(t);
fmpz_set_ui(rop2, rop);
}
mp_limb_t _fmpz_poly_evaluate_mod(const fmpz * poly, slong len, mp_limb_t a,
mp_limb_t n, mp_limb_t ninv)
{
mp_limb_t c, res = 0;
while (len--)
{
c = fmpz_fdiv_ui(poly + len, n);
res = n_addmod(n_mulmod2_preinv(res, a, n, ninv), c, n);
}
return res;
}
void
elem_add(elem_ptr res, elem_srcptr op1, elem_srcptr op2, const ring_t ring)
{
switch (ring->type)
{
case TYPE_FMPZ:
fmpz_add(res, op1, op2);
break;
case TYPE_LIMB:
*((mp_ptr) res) = *((mp_srcptr) op1) + *((mp_srcptr) op2);
break;
case TYPE_POLY:
elem_poly_add(res, op1, op2, ring);
break;
case TYPE_MOD:
{
switch (RING_PARENT(ring)->type)
{
case TYPE_LIMB:
*((mp_ptr) res) = n_addmod(*((mp_srcptr) op1), *((mp_srcptr) op2), ring->nmod.n);
break;
case TYPE_FMPZ:
fmpz_add(res, op1, op2);
if (fmpz_cmpabs(res, RING_MODULUS(ring)) >= 0)
fmpz_sub(res, res, RING_MODULUS(ring));
break;
default:
NOT_IMPLEMENTED("add (mod)", ring);
}
}
break;
case TYPE_FRAC:
elem_frac_add(res, op1, op2, ring);
break;
case TYPE_COMPLEX:
elem_add(REALPART(res, ring), REALPART(op1, ring), REALPART(op2, ring), ring->parent);
elem_add(IMAGPART(res, ring), IMAGPART(op1, ring), IMAGPART(op2, ring), ring->parent);
break;
default:
NOT_IMPLEMENTED("add", ring);
}
}
n_pair_t
fchain2_preinv(mp_limb_t m, mp_limb_t n, mp_limb_t ninv)
{
n_pair_t current = {0, 0}, old;
int length;
mp_limb_t power, xy;
old.x = 2UL;
old.y = n - 3UL;
length = FLINT_BIT_COUNT(m);
power = (1UL << (length - 1));
for (; length > 0; length--)
{
xy = n_mulmod2_preinv(old.x, old.y, n, ninv);
xy = n_addmod(xy, 3UL, n);
if (m & power)
{
current.y =
n_submod(n_mulmod2_preinv(old.y, old.y, n, ninv), 2UL, n);
current.x = xy;
}
else
{
current.x =
n_submod(n_mulmod2_preinv(old.x, old.x, n, ninv), 2UL, n);
current.y = xy;
}
power >>= 1;
old = current;
}
return current;
}
void
_nmod_poly_compose_divconquer(mp_ptr res, mp_srcptr poly1, long len1,
mp_srcptr poly2, long len2, nmod_t mod)
{
long i, j, k, n;
long * hlen, alloc, powlen;
mp_ptr v, * h, pow, temp;
if (len1 == 1)
{
res[0] = poly1[0];
return;
}
if (len2 == 1)
{
res[0] = _nmod_poly_evaluate_nmod(poly1, len1, poly2[0], mod);
return;
}
if (len1 == 2)
{
_nmod_poly_compose_horner(res, poly1, len1, poly2, len2, mod);
return;
}
/* Initialisation */
hlen = (long *) flint_malloc(((len1 + 1) / 2) * sizeof(long));
for (k = 1; (2 << k) < len1; k++) ;
hlen[0] = hlen[1] = ((1 << k) - 1) * (len2 - 1) + 1;
for (i = k - 1; i > 0; i--)
{
long hi = (len1 + (1 << i) - 1) / (1 << i);
for (n = (hi + 1) / 2; n < hi; n++)
hlen[n] = ((1 << i) - 1) * (len2 - 1) + 1;
}
powlen = (1 << k) * (len2 - 1) + 1;
alloc = 0;
for (i = 0; i < (len1 + 1) / 2; i++)
alloc += hlen[i];
v = _nmod_vec_init(alloc + 2 * powlen);
h = (mp_ptr *) flint_malloc(((len1 + 1) / 2) * sizeof(mp_ptr));
h[0] = v;
for (i = 0; i < (len1 - 1) / 2; i++)
{
h[i + 1] = h[i] + hlen[i];
hlen[i] = 0;
}
hlen[(len1 - 1) / 2] = 0;
pow = v + alloc;
temp = pow + powlen;
/* Let's start the actual work */
for (i = 0, j = 0; i < len1 / 2; i++, j += 2)
{
if (poly1[j + 1] != 0L)
{
_nmod_vec_scalar_mul_nmod(h[i], poly2, len2, poly1[j + 1], mod);
h[i][0] = n_addmod(h[i][0], poly1[j], mod.n);
hlen[i] = len2;
}
else if (poly1[j] != 0L)
{
h[i][0] = poly1[j];
hlen[i] = 1;
}
}
if ((len1 & 1L))
{
if (poly1[j] != 0L)
{
h[i][0] = poly1[j];
hlen[i] = 1;
}
}
_nmod_poly_mul(pow, poly2, len2, poly2, len2, mod);
powlen = 2 * len2 - 1;
for (n = (len1 + 1) / 2; n > 2; n = (n + 1) / 2)
{
if (hlen[1] > 0)
{
long templen = powlen + hlen[1] - 1;
_nmod_poly_mul(temp, pow, powlen, h[1], hlen[1], mod);
_nmod_poly_add(h[0], temp, templen, h[0], hlen[0], mod);
hlen[0] = FLINT_MAX(hlen[0], templen);
}
for (i = 1; i < n / 2; i++)
{
if (hlen[2*i + 1] > 0)
{
_nmod_poly_mul(h[i], pow, powlen, h[2*i + 1], hlen[2*i + 1], mod);
hlen[i] = hlen[2*i + 1] + powlen - 1;
} else
hlen[i] = 0;
_nmod_poly_add(h[i], h[i], hlen[i], h[2*i], hlen[2*i], mod);
hlen[i] = FLINT_MAX(hlen[i], hlen[2*i]);
}
if ((n & 1L))
{
mpn_copyi(h[i], h[2*i], hlen[2*i]);
hlen[i] = hlen[2*i];
}
_nmod_poly_mul(temp, pow, powlen, pow, powlen, mod);
powlen += powlen - 1;
{
mp_ptr t = pow;
pow = temp;
temp = t;
}
}
_nmod_poly_mul(res, pow, powlen, h[1], hlen[1], mod);
_nmod_vec_add(res, res, h[0], hlen[0], mod);
_nmod_vec_clear(v);
flint_free(h);
flint_free(hlen);
}
void embeddings_isomorphism_2(nmod_poly_t G, mp_srcptr F,
const embeddings_t FP, const embeddings_t FQ, const embeddings_t FR){
nmod_t mod = G->mod;
long m = nmod_poly_degree(FP->P);
long n = nmod_poly_degree(FQ->P);
long np = n + m - 1;
long p = ceil(sqrt(np));
long q = ceil((1.0*np)/p);
long i, j, k;
nmod_poly_t iT, iTm, T, X, tmp;
nmod_poly_struct *TT;
nmod_poly_init(iTm, mod.n);
nmod_poly_init(iT, mod.n);
nmod_poly_init(T, mod.n);
nmod_poly_init(X, mod.n);
nmod_poly_init(tmp, mod.n);
nmod_poly_mat_t MT, MH, MV;
nmod_poly_mat_init(MT, q, n, mod.n);
nmod_poly_mat_init(MH, p, q, mod.n);
nmod_poly_mat_init(MV, p, n, mod.n);
TT = flint_malloc(sizeof(nmod_poly_struct) * (q+1));
for (i = 0; i < q+1; i++)
nmod_poly_init(TT+i, mod.n);
nmod_poly_set_coeff_ui(X, 1, 1);
embeddings_embed(T, X, FQ, FP, FR);
nmod_poly_invmod(iT, T, FR->P);
nmod_poly_powmod_ui_binexp(iTm, iT, m-1, FR->P);
nmod_poly_zero(TT);
nmod_poly_set_coeff_ui(TT, 0, 1);
for (i = 1; i < q+1; i++)
nmod_poly_mulmod(TT+i, TT+(i-1), T, FR->P);
for (i = 0; i < q; i++)
for (j = 0; j < n; j++){
long jm = j*m;
for (k = 0; k < m; k++)
nmod_poly_set_coeff_ui(nmod_poly_mat_entry(MT, i, j), k, nmod_poly_get_coeff_ui(TT+i, k+jm));
}
for (i = 0; i < p; i++)
for (j = 0; j < q; j++){
long idx = i*q+j;
long lo = FLINT_MAX(0,m-1-idx);
long hi = FLINT_MIN(m,n+m-1-idx);
for (k = lo; k < hi; k++)
nmod_poly_set_coeff_ui(nmod_poly_mat_entry(MH, i, j), k, F[k*n+k+idx-m+1]);
}
nmod_poly_mat_mul(MV, MH, MT);
nmod_poly_zero(G);
for (i = p-1; i >= 0; i--){
nmod_poly_zero(tmp);
for (j = 0; j < n; j++){
long len = nmod_poly_mat_entry(MV, i, j)->length;
mp_ptr coefs = nmod_poly_mat_entry(MV, i, j)->coeffs;
long jm = j*m;
for (k = 0; k < len; k++)
nmod_poly_set_coeff_ui(tmp, k+jm, n_addmod(nmod_poly_get_coeff_ui(tmp, k+jm), coefs[k], mod.n));
}
nmod_poly_rem(tmp, tmp, FR->P);
nmod_poly_mulmod(G, G, TT+q, FR->P);
nmod_poly_add(G, G, tmp);
}
nmod_poly_mulmod(G, G, iTm, FR->P);
nmod_poly_clear(tmp);
nmod_poly_mat_clear(MT);
nmod_poly_mat_clear(MH);
nmod_poly_mat_clear(MV);
for (i = 0; i < q+1; i++)
nmod_poly_clear(TT+i);
flint_free(TT);
nmod_poly_clear(iTm);
nmod_poly_clear(iT);
nmod_poly_clear(T);
nmod_poly_clear(X);
}
