Line data Source code
1 : /* Copyright (C) 2007 The PARI group.
2 :
3 : This file is part of the PARI/GP package.
4 :
5 : PARI/GP is free software; you can redistribute it and/or modify it under the
6 : terms of the GNU General Public License as published by the Free Software
7 : Foundation; either version 2 of the License, or (at your option) any later
8 : version. It is distributed in the hope that it will be useful, but WITHOUT
9 : ANY WARRANTY WHATSOEVER.
10 :
11 : Check the License for details. You should have received a copy of it, along
12 : with the package; see the file 'COPYING'. If not, write to the Free Software
13 : Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
14 :
15 : #include "pari.h"
16 : #include "paripriv.h"
17 :
18 : #define DEBUGLEVEL DEBUGLEVEL_fflog
19 :
20 : /* Not so fast arithmetic with polynomials over F_2 */
21 :
22 : /***********************************************************************/
23 : /** **/
24 : /** F2x **/
25 : /** **/
26 : /***********************************************************************/
27 : /* F2x objects are defined as follows:
28 : An F2x is a t_VECSMALL:
29 : x[0] = codeword
30 : x[1] = evalvarn(variable number) (signe is not stored).
31 : x[2] = a_0...a_31 x[3] = a_32..a_63, etc. on 32bit
32 : x[2] = a_0...a_63 x[3] = a_64..a_127, etc. on 64bit
33 :
34 : where the a_i are bits.
35 :
36 : signe(x) is not valid. Use lgpol(x)!=0 instead.
37 : Note: pol0_F2x=pol0_Flx and pol1_F2x=pol1_Flx
38 : */
39 :
40 : INLINE long
41 264 : F2x_degreespec(GEN x, long l)
42 : {
43 264 : return (l==0)?-1:l*BITS_IN_LONG-bfffo(x[l-1])-1;
44 : }
45 :
46 : INLINE long
47 268819320 : F2x_degree_lg(GEN x, long l)
48 : {
49 268819320 : return (l==2)?-1:bit_accuracy(l)-bfffo(x[l-1])-1;
50 : }
51 :
52 : long
53 81054603 : F2x_degree(GEN x)
54 : {
55 81054603 : return F2x_degree_lg(x, lg(x));
56 : }
57 :
58 : GEN
59 63 : monomial_F2x(long d, long vs)
60 : {
61 63 : long l=nbits2lg(d+1);
62 63 : GEN z = zero_zv(l-1);
63 63 : z[1] = vs;
64 63 : F2x_set(z,d);
65 63 : return z;
66 : }
67 :
68 : GEN
69 1317280 : F2x_to_ZX(GEN x)
70 : {
71 1317280 : long l = 3+F2x_degree(x), lx = lg(x);
72 1317283 : GEN z = cgetg(l,t_POL);
73 : long i, j ,k;
74 2632664 : for (i=2, k=2; i<lx; i++)
75 4496655 : for (j=0; j<BITS_IN_LONG && k<l; j++,k++)
76 3181277 : gel(z,k) = (x[i]&(1UL<<j))?gen_1:gen_0;
77 1317286 : z[1]=evalsigne(l>=3)|x[1];
78 1317286 : return z;
79 : }
80 :
81 : GEN
82 133199 : F2x_to_Flx(GEN x)
83 : {
84 133199 : long l = 3+F2x_degree(x), lx = lg(x);
85 133199 : GEN z = cgetg(l,t_VECSMALL);
86 : long i, j, k;
87 133200 : z[1] = x[1];
88 300228 : for (i=2, k=2; i<lx; i++)
89 4692280 : for (j=0; j<BITS_IN_LONG && k<l; j++,k++)
90 4525252 : z[k] = (x[i]>>j)&1UL;
91 133200 : return z;
92 : }
93 :
94 : GEN
95 378 : F2x_to_F2xX(GEN z, long sv)
96 : {
97 378 : long i, d = F2x_degree(z);
98 378 : GEN x = cgetg(d+3,t_POL);
99 6769 : for (i=0; i<=d; i++)
100 6391 : gel(x,i+2) = F2x_coeff(z,i) ? pol1_F2x(sv): pol0_F2x(sv);
101 378 : x[1] = evalsigne(d+1!=0)| z[1]; return x;
102 : }
103 :
104 : GEN
105 213079 : Z_to_F2x(GEN x, long sv)
106 : {
107 213079 : return mpodd(x) ? pol1_F2x(sv): pol0_F2x(sv);
108 : }
109 :
110 : GEN
111 3147584 : ZX_to_F2x(GEN x)
112 : {
113 3147584 : long lx = lg(x), l = nbits2lg(lx-2);
114 3147585 : GEN z = cgetg(l,t_VECSMALL);
115 : long i, j, k;
116 3147616 : z[1] = ((ulong)x[1])&VARNBITS;
117 11234688 : for (i=2, k=1,j=BITS_IN_LONG; i<lx; i++,j++)
118 : {
119 8087048 : if (j==BITS_IN_LONG)
120 : {
121 3128887 : j=0; z[++k]=0;
122 : }
123 8087048 : if (mpodd(gel(x,i)))
124 6089135 : z[k] |= 1UL<<j;
125 : }
126 3147640 : return F2x_renormalize(z,l);
127 : }
128 :
129 : GEN
130 153503 : Flx_to_F2x(GEN x)
131 : {
132 153503 : long lx = lg(x), l = nbits2lg(lx-2);
133 153502 : GEN z = cgetg(l,t_VECSMALL);
134 : long i, j, k;
135 153506 : z[1] = x[1];
136 4776735 : for (i=2, k=1, j=BITS_IN_LONG; i<lx; i++,j++)
137 : {
138 4623229 : if (j==BITS_IN_LONG)
139 : {
140 180334 : j=0; z[++k] = 0;
141 : }
142 4623229 : if (x[i]&1UL)
143 2366825 : z[k] |= 1UL<<j;
144 : }
145 153506 : return F2x_renormalize(z,l);
146 : }
147 :
148 : GEN
149 1555322 : F2x_to_F2v(GEN x, long N)
150 : {
151 1555322 : long i, l = lg(x);
152 1555322 : long n = nbits2lg(N);
153 1555322 : GEN z = cgetg(n,t_VECSMALL);
154 1555317 : z[1] = N;
155 3341991 : for (i=2; i<l ; i++) z[i]=x[i];
156 1646554 : for ( ; i<n; i++) z[i]=0;
157 1555317 : return z;
158 : }
159 :
160 : GEN
161 1400 : RgX_to_F2x(GEN x)
162 : {
163 1400 : long l=nbits2lg(lgpol(x));
164 1400 : GEN z=cgetg(l,t_VECSMALL);
165 : long i,j,k;
166 1400 : z[1]=((ulong)x[1])&VARNBITS;
167 4277 : for(i=2, k=1,j=BITS_IN_LONG;i<lg(x);i++,j++)
168 : {
169 2877 : if (j==BITS_IN_LONG)
170 : {
171 1386 : j=0; k++; z[k]=0;
172 : }
173 2877 : if (Rg_to_F2(gel(x,i)))
174 1407 : z[k]|=1UL<<j;
175 : }
176 1400 : return F2x_renormalize(z,l);
177 : }
178 :
179 : /* If x is a POLMOD, assume modulus is a multiple of T. */
180 : GEN
181 1164334 : Rg_to_F2xq(GEN x, GEN T)
182 : {
183 1164334 : long ta, tx = typ(x), v = get_F2x_var(T);
184 : GEN a, b;
185 1164334 : if (is_const_t(tx))
186 : {
187 1163169 : if (tx == t_FFELT) return FF_to_F2xq(x);
188 246133 : return Rg_to_F2(x)? pol1_F2x(v): pol0_F2x(v);
189 : }
190 1169 : switch(tx)
191 : {
192 0 : case t_POLMOD:
193 0 : b = gel(x,1);
194 0 : a = gel(x,2); ta = typ(a);
195 0 : if (is_const_t(ta)) return Rg_to_F2(a)? pol1_F2x(v): pol0_F2x(v);
196 0 : b = RgX_to_F2x(b); if (b[1] != v) break;
197 0 : a = RgX_to_F2x(a); if (F2x_equal(b,T)) return a;
198 0 : if (lgpol(F2x_rem(b,T))==0) return F2x_rem(a, T);
199 0 : break;
200 1169 : case t_POL:
201 1169 : x = RgX_to_F2x(x);
202 1169 : if (x[1] != v) break;
203 1169 : return F2x_rem(x, T);
204 0 : case t_RFRAC:
205 0 : a = Rg_to_F2xq(gel(x,1), T);
206 0 : b = Rg_to_F2xq(gel(x,2), T);
207 0 : return F2xq_div(a,b, T);
208 : }
209 0 : pari_err_TYPE("Rg_to_F2xq",x);
210 : return NULL; /* LCOV_EXCL_LINE */
211 : }
212 :
213 : ulong
214 13370 : F2x_eval(GEN P, ulong x)
215 : {
216 13370 : if (lgpol(P)==0) return 0;
217 9694 : if (odd(x))
218 : {
219 2851 : long i, lP = lg(P);
220 2851 : ulong c = 0;
221 5702 : for (i=2; i<lP; i++)
222 2851 : c ^= P[i];
223 : #ifdef LONG_IS_64BIT
224 2442 : c ^= c >> 32;
225 : #endif
226 2851 : c ^= c >> 16;
227 2851 : c ^= c >> 8;
228 2851 : c ^= c >> 4;
229 2851 : c ^= c >> 2;
230 2851 : c ^= c >> 1;
231 2851 : return c & 1;
232 : }
233 6843 : else return F2x_coeff(P,0);
234 : }
235 :
236 : GEN
237 31033988 : F2x_add(GEN x, GEN y)
238 : {
239 : long i,lz;
240 : GEN z;
241 31033988 : long lx=lg(x);
242 31033988 : long ly=lg(y);
243 31033988 : if (ly>lx) swapspec(x,y, lx,ly);
244 31033988 : lz = lx; z = cgetg(lz, t_VECSMALL); z[1]=x[1];
245 62789890 : for (i=2; i<ly; i++) z[i] = x[i]^y[i];
246 38614432 : for ( ; i<lx; i++) z[i] = x[i];
247 31039489 : return F2x_renormalize(z, lz);
248 : }
249 :
250 : static GEN
251 73287 : F2x_addspec(GEN x, GEN y, long lx, long ly)
252 : {
253 : long i,lz;
254 : GEN z;
255 :
256 73287 : if (ly>lx) swapspec(x,y, lx,ly);
257 73287 : lz = lx+2; z = cgetg(lz, t_VECSMALL) + 2;
258 205589 : for (i=0; i<ly-3; i+=4)
259 : {
260 132302 : z[i] = x[i]^y[i];
261 132302 : z[i+1] = x[i+1]^y[i+1];
262 132302 : z[i+2] = x[i+2]^y[i+2];
263 132302 : z[i+3] = x[i+3]^y[i+3];
264 : }
265 132603 : for (; i<ly; i++)
266 59316 : z[i] = x[i]^y[i];
267 631504 : for ( ; i<lx; i++) z[i] = x[i];
268 73287 : z -= 2; z[1] = 0; return F2x_renormalize(z, lz);
269 : }
270 :
271 : GEN
272 189934 : F2x_1_add(GEN y)
273 : {
274 : GEN z;
275 : long lz, i;
276 189934 : if (!lgpol(y))
277 90422 : return pol1_F2x(y[1]);
278 99512 : lz=lg(y);
279 99512 : z=cgetg(lz,t_VECSMALL);
280 99512 : z[1] = y[1];
281 99512 : z[2] = y[2]^1UL;
282 99512 : for(i=3;i<lz;i++)
283 0 : z[i] = y[i];
284 99512 : if (lz==3) z = F2x_renormalize(z,lz);
285 99512 : return z;
286 : }
287 :
288 : INLINE void
289 163577025 : F2x_addshiftipspec(GEN x, GEN y, long ny, ulong db)
290 : {
291 : long i;
292 163577025 : if (db)
293 : {
294 139043003 : ulong dc=BITS_IN_LONG-db;
295 139043003 : ulong r=0, yi;
296 217680128 : for(i=0; i<ny-3; i+=4)
297 : {
298 78637125 : yi = uel(y,i); x[i] ^= (yi<<db)|r; r = yi>>dc;
299 78637125 : yi = uel(y,i+1); x[i+1] ^= (yi<<db)|r; r = yi>>dc;
300 78637125 : yi = uel(y,i+2); x[i+2] ^= (yi<<db)|r; r = yi>>dc;
301 78637125 : yi = uel(y,i+3); x[i+3] ^= (yi<<db)|r; r = yi>>dc;
302 : }
303 274746551 : for( ; i<ny; i++)
304 : {
305 135703548 : ulong yi = uel(y,i); x[i] ^= (yi<<db)|r; r = yi>>dc;
306 : }
307 139043003 : if (r) x[i] ^= r;
308 : }
309 : else
310 : {
311 27364517 : for(i=0; i<ny-3; i+=4)
312 : {
313 2830495 : x[i] ^= y[i];
314 2830495 : x[i+1] ^= y[i+1];
315 2830495 : x[i+2] ^= y[i+2];
316 2830495 : x[i+3] ^= y[i+3];
317 : }
318 51908152 : for( ; i<ny; i++)
319 27374130 : x[i] ^= y[i];
320 : }
321 163577025 : }
322 :
323 : INLINE void
324 135789206 : F2x_addshiftip(GEN x, GEN y, ulong d)
325 : {
326 135789206 : ulong db, dl=dvmduBIL(d, &db);
327 135889055 : F2x_addshiftipspec(x+2+dl, y+2, lgpol(y), db);
328 135859226 : }
329 :
330 : static GEN
331 20094725 : F2x_mul1(ulong x, ulong y)
332 : {
333 20094725 : ulong x1=(x&HIGHMASK)>>BITS_IN_HALFULONG;
334 20094725 : ulong x2=x&LOWMASK;
335 20094725 : ulong y1=(y&HIGHMASK)>>BITS_IN_HALFULONG;
336 20094725 : ulong y2=y&LOWMASK;
337 : ulong r1,r2,rr;
338 : GEN z;
339 : ulong i;
340 20094725 : rr=r1=r2=0UL;
341 20094725 : if (x2)
342 618327031 : for(i=0;i<BITS_IN_HALFULONG;i++)
343 598271536 : if (x2&(1UL<<i))
344 : {
345 52216467 : r2^=y2<<i;
346 52216467 : rr^=y1<<i;
347 : }
348 20094725 : if (x1)
349 3479315 : for(i=0;i<BITS_IN_HALFULONG;i++)
350 3357936 : if (x1&(1UL<<i))
351 : {
352 914671 : r1^=y1<<i;
353 914671 : rr^=y2<<i;
354 : }
355 20094725 : r2^=(rr&LOWMASK)<<BITS_IN_HALFULONG;
356 20094725 : r1^=(rr&HIGHMASK)>>BITS_IN_HALFULONG;
357 20094725 : z=cgetg((r1?4:3),t_VECSMALL);
358 20094935 : z[2]=r2;
359 20094935 : if (r1) z[3]=r1;
360 20094935 : return z;
361 : }
362 :
363 : static GEN
364 3821358 : F2x_mulspec_basecase(GEN x, GEN y, long nx, long ny)
365 : {
366 : long l, i, j;
367 : GEN z;
368 3821358 : l = nx + ny;
369 3821358 : z = zero_Flv(l+1);
370 4433776 : for(i=0; i < ny-1; i++)
371 : {
372 612474 : GEN zi = z+2+i;
373 612474 : ulong yi = uel(y,i);
374 612474 : if (yi)
375 33672679 : for(j=0; j < BITS_IN_LONG; j++)
376 33060514 : if (yi&(1UL<<j)) F2x_addshiftipspec(zi,x,nx,j);
377 : }
378 : {
379 3821302 : GEN zi = z+2+i;
380 3821302 : ulong yi = uel(y,i);
381 3821302 : long c = BITS_IN_LONG-bfffo(yi);
382 26702652 : for(j=0; j < c; j++)
383 22881410 : if (yi&(1UL<<j)) F2x_addshiftipspec(zi,x,nx,j);
384 : }
385 3821242 : return F2x_renormalize(z, l+2);
386 : }
387 :
388 : static GEN
389 46908 : F2x_addshift(GEN x, GEN y, long d)
390 : {
391 46908 : GEN xd,yd,zd = (GEN)avma;
392 46908 : long a,lz,ny = lgpol(y), nx = lgpol(x);
393 46908 : long vs = x[1];
394 46908 : if (nx == 0) return y;
395 46908 : x += 2; y += 2; a = ny-d;
396 46908 : if (a <= 0)
397 : {
398 3255 : lz = (a>nx)? ny+2: nx+d+2;
399 3255 : (void)new_chunk(lz); xd = x+nx; yd = y+ny;
400 37981 : while (xd > x) *--zd = *--xd;
401 3255 : x = zd + a;
402 4577 : while (zd > x) *--zd = 0;
403 : }
404 : else
405 : {
406 43653 : xd = new_chunk(d); yd = y+d;
407 43653 : x = F2x_addspec(x,yd,nx,a);
408 43653 : lz = (a>nx)? ny+2: lg(x)+d;
409 895711 : x += 2; while (xd > x) *--zd = *--xd;
410 : }
411 525815 : while (yd > y) *--zd = *--yd;
412 46908 : *--zd = vs;
413 46908 : *--zd = evaltyp(t_VECSMALL) | evallg(lz); return zd;
414 : }
415 :
416 : /* shift polynomial + GC; do not set evalvarn. Cf Flx_shiftip */
417 : static GEN
418 23948519 : F2x_shiftip(pari_sp av, GEN x, long v)
419 : {
420 23948519 : long i, lx = lg(x), ly;
421 : GEN y;
422 23948519 : if (!v || lx==2) return gc_uptoleaf(av, x);
423 29438 : ly = lx + v;
424 29438 : (void)new_chunk(ly); /* check that result fits */
425 29438 : x += lx; y = (GEN)av;
426 136139 : for (i = 2; i<lx; i++) *--y = *--x;
427 164868 : for (i = 0; i< v; i++) *--y = 0;
428 29438 : y -= 2; y[0] = evaltyp(t_VECSMALL) | evallg(ly);
429 29438 : return gc_const((pari_sp)y, y);
430 : }
431 :
432 : static GEN
433 264 : F2x_to_int(GEN a, long na, long da, long bs)
434 : {
435 264 : const long BIL = BITS_IN_LONG;
436 : GEN z, zs;
437 : long i,j,k,m;
438 264 : long lz = nbits2lg(1+da*bs);
439 264 : z = cgeti(lz); z[1] = evalsigne(1)|evallgefint(lz);
440 264 : zs = int_LSW(z); *zs = 0;
441 16185 : for (i=0, k=2, m=0; i<na; i++)
442 1022781 : for (j=0; j<BIL; j++, m+=bs)
443 : {
444 1007121 : if (m >= BIL)
445 : {
446 202089 : k++; if (k>=lz) break;
447 201828 : zs = int_nextW(zs);
448 201828 : *zs = 0;
449 201828 : m -= BIL;
450 : }
451 1006860 : *zs |= ((a[i]>>j)&1UL)<<m;
452 : }
453 264 : return int_normalize(z,0);
454 : }
455 :
456 : static GEN
457 132 : int_to_F2x(GEN x, long d, long bs)
458 : {
459 132 : const long BIL = BITS_IN_LONG;
460 132 : long lx = lgefint(x), lz = nbits2lg(d+1);
461 : long i,j,k,m;
462 132 : GEN xs = int_LSW(x);
463 132 : GEN z = cgetg(lz, t_VECSMALL);
464 132 : z[1] = 0;
465 15924 : for (k=2, i=2, m=0; k < lx; i++)
466 : {
467 15792 : z[i] = 0;
468 1022217 : for (j=0; j<BIL; j++, m+=bs)
469 : {
470 1006557 : if (m >= BIL)
471 : {
472 202005 : if (++k==lx) break;
473 201873 : xs = int_nextW(xs);
474 201873 : m -= BIL;
475 : }
476 1006425 : if ((*xs>>m)&1UL)
477 449712 : z[i]|=1UL<<j;
478 : }
479 : }
480 132 : return F2x_renormalize(z,lz);
481 : }
482 :
483 : static GEN
484 132 : F2x_mulspec_mulii(GEN a, GEN b, long na, long nb)
485 : {
486 132 : long da = F2x_degreespec(a,na), db = F2x_degreespec(b,nb);
487 132 : long bs = expu(1 + maxss(da, db))+1;
488 132 : GEN A = F2x_to_int(a,na,da,bs);
489 132 : GEN B = F2x_to_int(b,nb,db,bs);
490 132 : GEN z = mulii(A,B);
491 132 : return int_to_F2x(z,da+db,bs);
492 : }
493 :
494 : /* fast product (Karatsuba) of polynomials a,b. These are not real GENs, a+2,
495 : * b+2 were sent instead. na, nb = number of terms of a, b.
496 : * Only c, c0, c1, c2 are genuine GEN.
497 : */
498 : static GEN
499 28421347 : F2x_mulspec(GEN a, GEN b, long na, long nb)
500 : {
501 : GEN a0,c,c0;
502 28421347 : long n0, n0a, i, v = 0;
503 : pari_sp av;
504 28529248 : while (na && !a[0]) { a++; na-=1; v++; }
505 28449293 : while (nb && !b[0]) { b++; nb-=1; v++; }
506 28421347 : if (na < nb) swapspec(a,b, na,nb);
507 28421347 : if (!nb) return pol0_F2x(0);
508 :
509 23948189 : av = avma;
510 23948189 : if (na == 1)
511 20094707 : return F2x_shiftip(av, F2x_mul1(*a,*b), v);
512 3853482 : if (na < F2x_MUL_KARATSUBA_LIMIT)
513 3821355 : return F2x_shiftip(av, F2x_mulspec_basecase(a, b, na, nb), v);
514 32127 : if (nb >= F2x_MUL_MULII_LIMIT)
515 132 : return F2x_shiftip(av, F2x_mulspec_mulii(a, b, na, nb), v);
516 31995 : i=(na>>1); n0=na-i; na=i;
517 31995 : a0=a+n0; n0a=n0;
518 32080 : while (n0a && !a[n0a-1]) n0a--;
519 :
520 31995 : if (nb > n0)
521 : {
522 : GEN b0,c1,c2;
523 : long n0b;
524 :
525 14817 : nb -= n0; b0 = b+n0; n0b = n0;
526 14824 : while (n0b && !b[n0b-1]) n0b--;
527 14817 : c = F2x_mulspec(a,b,n0a,n0b);
528 14817 : c0 = F2x_mulspec(a0,b0,na,nb);
529 :
530 14817 : c2 = F2x_addspec(a0,a,na,n0a);
531 14817 : c1 = F2x_addspec(b0,b,nb,n0b);
532 :
533 14817 : c1 = F2x_mul(c1,c2);
534 14817 : c2 = F2x_add(c0,c);
535 :
536 14817 : c2 = F2x_add(c1,c2);
537 14817 : c0 = F2x_addshift(c0,c2,n0);
538 : }
539 : else
540 : {
541 17178 : c = F2x_mulspec(a,b,n0a,nb);
542 17274 : c0 = F2x_mulspec(a0,b,na,nb);
543 : }
544 32091 : c0 = F2x_addshift(c0,c,n0);
545 32091 : return F2x_shiftip(av,c0, v);
546 : }
547 :
548 : GEN
549 28357200 : F2x_mul(GEN x, GEN y)
550 : {
551 28357200 : GEN z = F2x_mulspec(x+2,y+2, lgpol(x),lgpol(y));
552 28357396 : z[1] = x[1]; return z;
553 : }
554 :
555 : GEN
556 9097253 : F2x_sqr(GEN x)
557 : {
558 9097253 : const ulong sq[]={0,1,4,5,16,17,20,21,64,65,68,69,80,81,84,85};
559 : long i,ii,j,jj;
560 9097253 : long lx=lg(x), lz=2+((lx-2)<<1);
561 : GEN z;
562 9097253 : z = cgetg(lz, t_VECSMALL); z[1]=x[1];
563 18322567 : for (j=2,jj=2;j<lx;j++,jj++)
564 : {
565 9201514 : ulong x1=((ulong)x[j]&HIGHMASK)>>BITS_IN_HALFULONG;
566 9201514 : ulong x2=(ulong)x[j]&LOWMASK;
567 9201514 : z[jj]=0;
568 9201514 : if (x2)
569 76839103 : for(i=0,ii=0;i<BITS_IN_HALFULONG;i+=4,ii+=8)
570 67708869 : z[jj]|=sq[(x2>>i)&15UL]<<ii;
571 9201514 : z[++jj]=0;
572 9201514 : if (x1)
573 6338882 : for(i=0,ii=0;i<BITS_IN_HALFULONG;i+=4,ii+=8)
574 5518152 : z[jj]|=sq[(x1>>i)&15UL]<<ii;
575 : }
576 9121053 : return F2x_renormalize(z, lz);
577 : }
578 :
579 : static GEN
580 175655 : F2x_pow2n(GEN x, long n)
581 : {
582 : long i;
583 527024 : for(i=1;i<=n;i++)
584 351285 : x = F2x_sqr(x);
585 175739 : return x;
586 : }
587 :
588 : int
589 35589 : F2x_issquare(GEN x)
590 : {
591 35589 : const ulong mask = (ULONG_MAX/3UL)*2;
592 35589 : ulong i, lx = lg(x);
593 71178 : for (i=2; i<lx; i++)
594 35589 : if ((x[i]&mask)) return 0;
595 35589 : return 1;
596 : }
597 :
598 : /* Assume x is a perfect square */
599 : GEN
600 247300 : F2x_sqrt(GEN x)
601 : {
602 247300 : const ulong sq[]={0,1,4,5,2,3,6,7,8,9,12,13,10,11,14,15};
603 : long i,ii,j,jj;
604 247300 : long lx=lg(x), lz=2+((lx-1)>>1);
605 : GEN z;
606 247300 : z = cgetg(lz, t_VECSMALL); z[1]=x[1];
607 494651 : for (j=2,jj=2;jj<lz;j++,jj++)
608 : {
609 247343 : ulong x2=x[j++];
610 247343 : z[jj]=0;
611 247343 : if (x2)
612 2084699 : for(i=0,ii=0;ii<BITS_IN_HALFULONG;i+=8,ii+=4)
613 : {
614 1837368 : ulong rl = (x2>>i)&15UL, rh = (x2>>(i+4))&15UL;
615 1837368 : z[jj]|=sq[rl|(rh<<1)]<<ii;
616 : }
617 247343 : if (j<lx)
618 : {
619 348 : x2 = x[j];
620 348 : if (x2)
621 2217 : for(i=0,ii=0;ii<BITS_IN_HALFULONG;i+=8,ii+=4)
622 : {
623 1884 : ulong rl = (x2>>i)&15UL, rh = (x2>>(i+4))&15UL;
624 1884 : z[jj]|=(sq[rl|(rh<<1)]<<ii)<<BITS_IN_HALFULONG;
625 : }
626 : }
627 : }
628 247308 : return F2x_renormalize(z, lz);
629 : }
630 :
631 : static GEN
632 1108 : F2x_shiftneg(GEN y, ulong d)
633 : {
634 1108 : long db, dl=dvmdsBIL(d, &db);
635 1108 : long i, ly = lg(y), lx = ly-dl;
636 : GEN x;
637 1108 : if (lx <= 2) return zero_F2x(y[1]);
638 1092 : x = cgetg(lx, t_VECSMALL);
639 1092 : x[1] = y[1];
640 1092 : if (db)
641 : {
642 1092 : ulong dc=BITS_IN_LONG-db;
643 1092 : ulong r=0;
644 2184 : for(i=lx-1; i>=2; i--)
645 : {
646 1092 : x[i] = (((ulong)y[i+dl])>>db)|r;
647 1092 : r = ((ulong)y[i+dl])<<dc;
648 : }
649 : }
650 : else
651 0 : for(i=2; i<lx; i++)
652 0 : x[i] = y[i+dl];
653 1092 : return F2x_renormalize(x,lx);
654 : }
655 :
656 : static GEN
657 275121 : F2x_shiftpos(GEN y, ulong d)
658 : {
659 275121 : long db, dl=dvmdsBIL(d, &db);
660 275108 : long i, ly = lg(y), lx = ly+dl+(!!db);
661 275108 : GEN x = cgetg(lx, t_VECSMALL);
662 275116 : x[1] = y[1]; for(i=0; i<dl; i++) x[i+2] = 0;
663 275025 : if (db)
664 : {
665 274981 : ulong dc=BITS_IN_LONG-db;
666 274981 : ulong r=0;
667 554330 : for(i=2; i<ly; i++)
668 : {
669 279349 : x[i+dl] = (((ulong)y[i])<<db)|r;
670 279349 : r = ((ulong)y[i])>>dc;
671 : }
672 274981 : x[i+dl] = r;
673 : }
674 : else
675 58 : for(i=2; i<ly; i++)
676 14 : x[i+dl] = y[i];
677 275025 : return F2x_renormalize(x,lx);
678 : }
679 :
680 : GEN
681 276219 : F2x_shift(GEN y, long d)
682 : {
683 276219 : return d<0 ? F2x_shiftneg(y,-d): F2x_shiftpos(y,d);
684 : }
685 :
686 : #define F2x_recip2(pk,m) u = ((u&m)<<pk)|((u&(~m))>>pk);
687 : #define F2x_recipu(pk) F2x_recip2(pk,((~0UL)/((1UL<<pk)+1)))
688 :
689 : static ulong
690 42 : F2x_recip1(ulong u)
691 : {
692 42 : u = (u<<BITS_IN_HALFULONG)|(u>>BITS_IN_HALFULONG);
693 : #ifdef LONG_IS_64BIT
694 36 : F2x_recipu(16);
695 : #endif
696 42 : F2x_recipu(8);
697 42 : F2x_recipu(4);
698 42 : F2x_recipu(2);
699 42 : F2x_recipu(1);
700 42 : return u;
701 : }
702 :
703 : static GEN
704 0 : F2x_recip_raw(GEN x)
705 : {
706 : long i, l;
707 0 : GEN y = cgetg_copy(x,&l);
708 0 : y[1] = x[1];
709 0 : for (i=0; i<l-2; i++)
710 0 : uel(y,l-1-i) = F2x_recip1(uel(x,2+i));
711 0 : return y;
712 : }
713 :
714 : GEN
715 0 : F2x_recip(GEN x)
716 : {
717 0 : long lb = remsBIL(F2x_degree(x)+1);
718 0 : GEN y = F2x_recip_raw(x);
719 0 : if (lb) y = F2x_shiftneg(y,BITS_IN_LONG-lb);
720 0 : return y;
721 : }
722 :
723 : GEN
724 83 : F2xn_red(GEN f, long n)
725 : {
726 : GEN g;
727 : long i, dl, db, l;
728 83 : if (F2x_degree(f) < n) return zv_copy(f);
729 0 : dl = dvmdsBIL(n, &db); l = 2 + dl + (db>0);
730 0 : g = cgetg(l, t_VECSMALL);
731 0 : g[1] = f[1];
732 0 : for (i=2; i<l; i++)
733 0 : uel(g,i) = uel(f,i);
734 0 : if (db) uel(g,l-1) = uel(f,l-1)&((1UL<<db)-1);
735 0 : return F2x_renormalize(g, l);
736 : }
737 :
738 : static GEN
739 46 : F2xn_mul(GEN a, GEN b, long n) { return F2xn_red(F2x_mul(a, b), n); }
740 :
741 : static ulong
742 42 : F2xn_inv_basecase1(ulong x)
743 : {
744 : ulong u, v, w;
745 : long i;
746 42 : u = x>>1;
747 42 : v = (u&1UL)|2UL;
748 42 : w = u&v; w ^= w >> 1; v = (w&1UL)|(v<<1);
749 42 : w = u&v; w ^= w >> 2; w ^= w >> 1; v = (w&1UL)|(v<<1);
750 42 : w = u&v; w ^= w >> 2; w ^= w >> 1; v = (w&1UL)|(v<<1);
751 210 : for (i=1;i<=4;i++)
752 168 : { w = u&v; w ^= w >> 4; w ^= w >> 2; w ^= w >> 1; v = (w&1UL)|(v<<1); }
753 378 : for (i=1;i<=8;i++)
754 336 : { w = u&v; w ^= w >> 8; w ^= w >> 4; w ^= w >> 2; w ^= w >> 1;
755 336 : v = (w&1UL)|(v<<1); }
756 714 : for (i=1;i<=16;i++)
757 672 : { w = u&v; w ^= w >> 16; w ^= w >> 8; w ^= w >> 4; w ^= w >> 2; w ^= w >> 1;
758 672 : v = (w&1UL)|(v<<1); }
759 : #ifdef LONG_IS_64BIT
760 1188 : for (i=1; i<=32; i++)
761 1152 : { w = u&v; w ^= w >> 32; w ^= w >> 16; w ^= w >> 8; w ^= w >> 4; w ^= w >> 2;
762 1152 : w ^= w >> 1; v = (w&1UL)|(v<<1); }
763 : #endif
764 42 : return (F2x_recip1(v)<<1) | 1UL;
765 : }
766 :
767 : static GEN
768 42 : F2xn_inv1(GEN v, long e)
769 : {
770 42 : ulong mask = e==BITS_IN_LONG ? -1UL: ((1UL<<e)-1);
771 42 : return mkvecsmall2(v[1],F2xn_inv_basecase1(uel(v,2))&mask);
772 : }
773 :
774 : static GEN
775 28 : F2xn_div1(GEN g, GEN f, long e)
776 : {
777 28 : GEN fi = F2xn_inv1(f, e);
778 28 : return g ? F2xn_mul(g, fi, e): fi;
779 : }
780 :
781 : GEN
782 42 : F2xn_div(GEN g, GEN f, long e)
783 : {
784 42 : pari_sp av = avma, av2;
785 : ulong mask;
786 : GEN W;
787 42 : long n=1;
788 42 : if (lg(f)<=2) pari_err_INV("Flxn_inv",f);
789 42 : if (e <= BITS_IN_LONG) return F2xn_div1(g, f, e);
790 14 : W = F2xn_inv1(f, BITS_IN_LONG);
791 14 : mask = quadratic_prec_mask(divsBIL(e+BITS_IN_LONG-1));
792 14 : n = BITS_IN_LONG;
793 14 : av2 = avma;
794 30 : for (;mask>1;)
795 : {
796 : GEN u, fr;
797 16 : long n2 = n;
798 16 : n<<=1; if (mask & 1) n--;
799 16 : mask >>= 1;
800 16 : fr = F2xn_red(f, n);
801 16 : if (mask>1 || !g)
802 : {
803 9 : u = F2x_shift(F2xn_mul(W, fr, n), -n2);
804 9 : W = F2x_add(W, F2x_shift(F2xn_mul(u, W, n-n2), n2));
805 : } else
806 : {
807 7 : GEN y = F2xn_mul(g, W, n), yt = F2xn_red(y, n-n2);
808 7 : u = F2xn_mul(yt, F2x_shift(F2xn_mul(fr, W, n), -n2), n-n2);
809 7 : W = F2x_add(y, F2x_shift(u, n2));
810 : }
811 16 : if (gc_needed(av2,2))
812 : {
813 0 : if(DEBUGMEM>1) pari_warn(warnmem,"F2xn_inv, e = %ld", n);
814 0 : W = gc_upto(av2, W);
815 : }
816 : }
817 14 : return gc_upto(av, F2xn_red(W,e));
818 : }
819 :
820 : GEN
821 28 : F2xn_inv(GEN f, long e)
822 28 : { return F2xn_div(NULL, f, e); }
823 :
824 : GEN
825 218673 : F2x_get_red(GEN T)
826 : {
827 218673 : return T;
828 : }
829 :
830 : /* separate from F2x_divrem for maximal speed. */
831 : GEN
832 49014867 : F2x_rem(GEN x, GEN y)
833 : {
834 : long dx,dy;
835 49014867 : long lx=lg(x);
836 49014867 : dy = F2x_degree(y); if (!dy) return pol0_F2x(x[1]);
837 46402545 : dx = F2x_degree_lg(x,lx);
838 46388852 : x = F2x_copy(x);
839 159520552 : while (dx>=dy)
840 : {
841 113235634 : F2x_addshiftip(x,y,dx-dy);
842 116054600 : while (lx>2 && x[lx-1]==0) lx--;
843 113268483 : dx = F2x_degree_lg(x,lx);
844 : }
845 46284918 : return F2x_renormalize(x, lx);
846 : }
847 :
848 : GEN
849 11704610 : F2x_divrem(GEN x, GEN y, GEN *pr)
850 : {
851 11704610 : long dx, dy, dz, lx = lg(x), vs = x[1];
852 : GEN z;
853 :
854 11704610 : dy = F2x_degree(y);
855 11703936 : if (dy<0) pari_err_INV("F2x_divrem",y);
856 11704022 : if (pr == ONLY_REM) return F2x_rem(x, y);
857 11704022 : if (!dy)
858 : {
859 2357549 : z = F2x_copy(x);
860 2357542 : if (pr && pr != ONLY_DIVIDES) *pr = pol0_F2x(vs);
861 2357543 : return z;
862 : }
863 9346473 : dx = F2x_degree_lg(x,lx);
864 9347339 : dz = dx-dy;
865 9347339 : if (dz < 0)
866 : {
867 14 : if (pr == ONLY_DIVIDES) return dx < 0? F2x_copy(x): NULL;
868 14 : z = pol0_F2x(vs);
869 14 : if (pr) *pr = F2x_copy(x);
870 14 : return z;
871 : }
872 9347325 : z = zero_zv(lg(x)-lg(y)+2); z[1] = vs;
873 9348003 : x = F2x_copy(x);
874 30613729 : while (dx>=dy)
875 : {
876 21266656 : F2x_set(z,dx-dy);
877 21267810 : F2x_addshiftip(x,y,dx-dy);
878 22823340 : while (lx>2 && x[lx-1]==0) lx--;
879 21260608 : dx = F2x_degree_lg(x,lx);
880 : }
881 9347073 : z = F2x_renormalize(z, lg(z));
882 9347813 : if (!pr) { cgiv(x); return z; }
883 8095519 : x = F2x_renormalize(x, lx);
884 8095519 : if (pr == ONLY_DIVIDES) {
885 0 : if (lg(x) == 2) { cgiv(x); return z; }
886 0 : return gc_NULL((pari_sp)(z + lg(z)));
887 : }
888 8095519 : *pr = x; return z;
889 : }
890 :
891 : long
892 35364 : F2x_valrem(GEN x, GEN *Z)
893 : {
894 35364 : long v, v2, i, l=lg(x);
895 : GEN y;
896 35364 : if (l==2) { *Z = F2x_copy(x); return LONG_MAX; }
897 35367 : for (i=2; i<l && x[i]==0; i++) /*empty*/;
898 35364 : v = i-2;
899 35364 : v2 = (i < l)? vals(x[i]): 0;
900 35365 : if (v+v2 == 0) { *Z = x; return 0; }
901 11278 : l -= i-2;
902 11278 : y = cgetg(l, t_VECSMALL); y[1] = x[1];
903 11278 : if (v2 == 0)
904 6 : for (i=2; i<l; i++) uel(y,i) = uel(x,i+v);
905 11275 : else if (l == 3)
906 11254 : y[2] = uel(x,2+v) >> v2;
907 : else
908 : {
909 21 : const ulong sh = BITS_IN_LONG - v2;
910 21 : ulong r = uel(x,2+v);
911 42 : for (i=3; i<l; i++)
912 : {
913 21 : uel(y,i-1) = (uel(x,i+v)<< sh) | (r >> v2);
914 21 : r = uel(x,i+v);
915 : }
916 21 : uel(y,l-1) = r >> v2;
917 21 : (void)F2x_renormalize(y,l);
918 : }
919 11278 : *Z = y; return (v << TWOPOTBITS_IN_LONG) + v2;
920 : }
921 :
922 : GEN
923 0 : F2x_deflate(GEN x, long d)
924 : {
925 : GEN y;
926 0 : long i,id, dy, dx = F2x_degree(x);
927 0 : if (d <= 1) return F2x_copy(x);
928 0 : if (dx < 0) return F2x_copy(x);
929 0 : dy = dx/d; /* dy+1 coefficients + 1 extra word for variable */
930 0 : y = zero_zv(nbits2lg(dy+1)-1); y[1] = x[1];
931 0 : for (i=id=0; i<=dy; i++,id+=d)
932 0 : if (F2x_coeff(x,id)) F2x_set(y, i);
933 0 : return y;
934 : }
935 :
936 : /* write p(X) = e(X^2) + Xo(X^2), shallow function */
937 : void
938 61738 : F2x_even_odd(GEN p, GEN *pe, GEN *po)
939 : {
940 61738 : long n = F2x_degree(p), n0, n1, i;
941 : GEN p0, p1;
942 :
943 61736 : if (n <= 0) { *pe = F2x_copy(p); *po = pol0_F2x(p[1]); return; }
944 :
945 57424 : n0 = (n>>1)+1; n1 = n+1 - n0; /* n1 <= n0 <= n1+1 */
946 57424 : p0 = zero_zv(nbits2lg(n0+1)-1); p0[1] = p[1];
947 57423 : p1 = zero_zv(nbits2lg(n1+1)-1); p1[1] = p[1];
948 2144204 : for (i=0; i<n1; i++)
949 : {
950 2086780 : if (F2x_coeff(p,i<<1)) F2x_set(p0,i);
951 2086713 : if (F2x_coeff(p,1+(i<<1))) F2x_set(p1,i);
952 : }
953 57424 : if (n1 != n0 && F2x_coeff(p,i<<1)) F2x_set(p0,i);
954 57424 : *pe = F2x_renormalize(p0,lg(p0));
955 57426 : *po = F2x_renormalize(p1,lg(p1));
956 : }
957 :
958 : GEN
959 1283905 : F2x_deriv(GEN z)
960 : {
961 1283905 : const ulong mask = ULONG_MAX/3UL;
962 1283905 : long i,l = lg(z);
963 1283905 : GEN x = cgetg(l, t_VECSMALL); x[1] = z[1];
964 2574475 : for (i=2; i<l; i++) x[i] = (((ulong)z[i])>>1)&mask;
965 1283877 : return F2x_renormalize(x,l);
966 : }
967 :
968 : GEN
969 3854374 : F2x_gcd(GEN a, GEN b)
970 : {
971 3854374 : pari_sp av = avma;
972 3854374 : if (lg(b) > lg(a)) swap(a, b);
973 24531612 : while (lgpol(b))
974 : {
975 20429998 : GEN c = F2x_rem(a,b);
976 20677238 : a = b; b = c;
977 20677238 : if (gc_needed(av,2))
978 : {
979 0 : if (DEBUGMEM>1) pari_warn(warnmem,"F2x_gcd (d = %ld)",F2x_degree(c));
980 0 : (void)gc_all(av,2, &a,&b);
981 : }
982 : }
983 3842838 : if (gc_needed(av,2)) a = gc_uptoleaf(av, a);
984 3842838 : return a;
985 : }
986 :
987 : GEN
988 2042318 : F2x_extgcd(GEN a, GEN b, GEN *ptu, GEN *ptv)
989 : {
990 2042318 : pari_sp av=avma;
991 : GEN u,v,d,d1,v1;
992 2042318 : long vx = a[1];
993 2042318 : d = a; d1 = b;
994 2042318 : v = pol0_F2x(vx); v1 = pol1_F2x(vx);
995 12164843 : while (lgpol(d1))
996 : {
997 10122524 : GEN r, q = F2x_divrem(d,d1, &r);
998 10122524 : v = F2x_add(v,F2x_mul(q,v1));
999 10122525 : u=v; v=v1; v1=u;
1000 10122525 : u=r; d=d1; d1=u;
1001 10122525 : if (gc_needed(av,2))
1002 : {
1003 0 : if (DEBUGMEM>1) pari_warn(warnmem,"F2x_extgcd (d = %ld)",F2x_degree(d));
1004 0 : (void)gc_all(av,5, &d,&d1,&u,&v,&v1);
1005 : }
1006 : }
1007 2042317 : if (ptu) *ptu = F2x_div(F2x_add(d, F2x_mul(b,v)), a);
1008 2042317 : *ptv = v;
1009 2042317 : if (gc_needed(av,2)) (void)gc_all(av,ptu?3:2,&d,ptv,ptu);
1010 2042317 : return d;
1011 : }
1012 :
1013 : static GEN
1014 960 : F2x_halfgcd_i(GEN a, GEN b)
1015 : {
1016 960 : pari_sp av=avma;
1017 : GEN u,u1,v,v1;
1018 960 : long vx = a[1];
1019 960 : long n = (F2x_degree(a)+1)>>1;
1020 960 : u1 = v = pol0_F2x(vx);
1021 960 : u = v1 = pol1_F2x(vx);
1022 15275 : while (F2x_degree(b)>=n)
1023 : {
1024 14315 : GEN r, q = F2x_divrem(a,b, &r);
1025 14315 : a = b; b = r; swap(u,u1); swap(v,v1);
1026 14315 : u1 = F2x_add(u1, F2x_mul(u, q));
1027 14315 : v1 = F2x_add(v1, F2x_mul(v, q));
1028 14315 : if (gc_needed(av,2))
1029 : {
1030 0 : if (DEBUGMEM>1) pari_warn(warnmem,"F2x_halfgcd (d = %ld)",F2x_degree(b));
1031 0 : (void)gc_all(av,6, &a,&b,&u1,&v1,&u,&v);
1032 : }
1033 : }
1034 960 : return gc_GEN(av, mkmat22(u,v,u1,v1));
1035 : }
1036 :
1037 : GEN
1038 960 : F2x_halfgcd(GEN x, GEN y)
1039 : {
1040 : pari_sp av;
1041 : GEN M,q,r;
1042 960 : if (F2x_degree(y)<F2x_degree(x)) return F2x_halfgcd_i(x,y);
1043 960 : av = avma;
1044 960 : q = F2x_divrem(y,x,&r);
1045 960 : M = F2x_halfgcd_i(x,r);
1046 960 : gcoeff(M,1,1) = F2x_add(gcoeff(M,1,1), F2x_mul(q, gcoeff(M,1,2)));
1047 960 : gcoeff(M,2,1) = F2x_add(gcoeff(M,2,1), F2x_mul(q, gcoeff(M,2,2)));
1048 960 : return gc_GEN(av, M);
1049 : }
1050 :
1051 : GEN
1052 10049164 : F2xq_mul(GEN x,GEN y,GEN pol)
1053 : {
1054 10049164 : GEN z = F2x_mul(x,y);
1055 10049395 : return F2x_rem(z,pol);
1056 : }
1057 :
1058 : GEN
1059 8750079 : F2xq_sqr(GEN x,GEN pol)
1060 : {
1061 8750079 : GEN z = F2x_sqr(x);
1062 8784363 : return F2x_rem(z,pol);
1063 : }
1064 :
1065 : GEN
1066 2042318 : F2xq_invsafe(GEN x, GEN T)
1067 : {
1068 2042318 : GEN V, z = F2x_extgcd(get_F2x_mod(T), x, NULL, &V);
1069 2042317 : if (F2x_degree(z)) return NULL;
1070 2042282 : return V;
1071 : }
1072 :
1073 : GEN
1074 2042311 : F2xq_inv(GEN x,GEN T)
1075 : {
1076 2042311 : pari_sp av=avma;
1077 2042311 : GEN U = F2xq_invsafe(x, T);
1078 2042310 : if (!U) pari_err_INV("F2xq_inv", F2x_to_ZX(x));
1079 2042275 : return gc_uptoleaf(av, U);
1080 : }
1081 :
1082 : GEN
1083 558162 : F2xq_div(GEN x,GEN y,GEN T)
1084 : {
1085 558162 : pari_sp av = avma;
1086 558162 : return gc_uptoleaf(av, F2xq_mul(x,F2xq_inv(y,T),T));
1087 : }
1088 :
1089 : static GEN
1090 582910 : _F2xq_red(void *E, GEN x) { return F2x_rem(x, (GEN)E); }
1091 : static GEN
1092 1701978 : _F2xq_add(void *E, GEN x, GEN y) { (void)E; return F2x_add(x,y); }
1093 :
1094 : static GEN
1095 2089399 : _F2xq_cmul(void *E, GEN P, long a, GEN x)
1096 : {
1097 2089399 : GEN pol = (GEN) E;
1098 2089399 : return F2x_coeff(P,a) ? x: pol0_F2x(pol[1]);
1099 : }
1100 : static GEN
1101 1211210 : _F2xq_sqr(void *E, GEN x) { return F2xq_sqr(x, (GEN) E); }
1102 : static GEN
1103 2184356 : _F2xq_mul(void *E, GEN x, GEN y) { return F2xq_mul(x,y, (GEN) E); }
1104 :
1105 : static GEN
1106 925963 : _F2xq_one(void *E)
1107 : {
1108 925963 : GEN pol = (GEN) E;
1109 925963 : return pol1_F2x(pol[1]);
1110 : }
1111 : static GEN
1112 259292 : _F2xq_zero(void *E)
1113 : {
1114 259292 : GEN pol = (GEN) E;
1115 259292 : return pol0_F2x(pol[1]);
1116 : }
1117 :
1118 : GEN
1119 2441453 : F2xq_pow(GEN x, GEN n, GEN pol)
1120 : {
1121 2441453 : pari_sp av=avma;
1122 : GEN y;
1123 :
1124 2441453 : if (!signe(n)) return pol1_F2x(x[1]);
1125 2434915 : if (is_pm1(n)) /* +/- 1 */
1126 1842504 : return (signe(n) < 0)? F2xq_inv(x,pol): F2x_copy(x);
1127 :
1128 592411 : if (signe(n) < 0) x = F2xq_inv(x,pol);
1129 592411 : y = gen_pow_i(x, n, (void*)pol, &_F2xq_sqr, &_F2xq_mul);
1130 592414 : return gc_GEN(av, y);
1131 : }
1132 :
1133 : GEN
1134 49 : F2xq_powu(GEN x, ulong n, GEN pol)
1135 : {
1136 49 : pari_sp av=avma;
1137 : GEN y;
1138 49 : switch(n)
1139 : {
1140 0 : case 0: return pol1_F2x(x[1]);
1141 7 : case 1: return F2x_copy(x);
1142 14 : case 2: return F2xq_sqr(x,pol);
1143 : }
1144 28 : y = gen_powu_i(x, n, (void*)pol, &_F2xq_sqr, &_F2xq_mul);
1145 28 : return gc_GEN(av, y);
1146 : }
1147 :
1148 : GEN
1149 14 : F2xq_pow_init(GEN x, GEN n, long k, GEN T)
1150 : {
1151 14 : return gen_pow_init(x, n, k, (void*)T, &_F2xq_sqr, &_F2xq_mul);
1152 : }
1153 :
1154 : GEN
1155 5244 : F2xq_pow_table(GEN R, GEN n, GEN T)
1156 : {
1157 5244 : return gen_pow_table(R, n, (void*)T, &_F2xq_one, &_F2xq_mul);
1158 : }
1159 :
1160 : /* generates the list of powers of x of degree 0,1,2,...,l*/
1161 : GEN
1162 364152 : F2xq_powers(GEN x, long l, GEN T)
1163 : {
1164 364152 : int use_sqr = 2*F2x_degree(x) >= get_F2x_degree(T);
1165 364151 : return gen_powers(x, l, use_sqr, (void*)T, &_F2xq_sqr, &_F2xq_mul, &_F2xq_one);
1166 : }
1167 :
1168 : GEN
1169 234918 : F2xq_matrix_pow(GEN y, long n, long m, GEN P)
1170 : {
1171 234918 : return F2xV_to_F2m(F2xq_powers(y,m-1,P),n);
1172 : }
1173 :
1174 : GEN
1175 658725 : F2x_Frobenius(GEN T)
1176 : {
1177 658725 : return F2xq_sqr(polx_F2x(get_F2x_var(T)), T);
1178 : }
1179 :
1180 : GEN
1181 234918 : F2x_matFrobenius(GEN T)
1182 : {
1183 234918 : long n = get_F2x_degree(T);
1184 234918 : return F2xq_matrix_pow(F2x_Frobenius(T), n, n, T);
1185 : }
1186 :
1187 : static struct bb_algebra F2xq_algebra = { _F2xq_red, _F2xq_add, _F2xq_add,
1188 : _F2xq_mul, _F2xq_sqr, _F2xq_one, _F2xq_zero};
1189 :
1190 : GEN
1191 610484 : F2x_F2xqV_eval(GEN Q, GEN x, GEN T)
1192 : {
1193 610484 : long d = F2x_degree(Q);
1194 610484 : return gen_bkeval_powers(Q,d,x,(void*)T,&F2xq_algebra,_F2xq_cmul);
1195 : }
1196 :
1197 : GEN
1198 44822 : F2x_F2xq_eval(GEN Q, GEN x, GEN T)
1199 : {
1200 44822 : long d = F2x_degree(Q);
1201 44822 : int use_sqr = 2*F2x_degree(x) >= get_F2x_degree(T);
1202 44822 : return gen_bkeval(Q, d, x, use_sqr, (void*)T, &F2xq_algebra, _F2xq_cmul);
1203 : }
1204 :
1205 : static GEN
1206 29362 : F2xq_autpow_sqr(void * T, GEN x) { return F2x_F2xq_eval(x, x, (GEN) T); }
1207 :
1208 : static GEN
1209 14732 : F2xq_autpow_mul(void * T, GEN x, GEN y) { return F2x_F2xq_eval(x, y, (GEN) T); }
1210 :
1211 : GEN
1212 19260 : F2xq_autpow(GEN x, long n, GEN T)
1213 : {
1214 19260 : if (n==0) return F2x_rem(polx_F2x(x[1]), T);
1215 19260 : if (n==1) return F2x_rem(x, T);
1216 19260 : return gen_powu(x,n,(void*)T,F2xq_autpow_sqr,F2xq_autpow_mul);
1217 : }
1218 :
1219 : ulong
1220 456816 : F2xq_trace(GEN x, GEN T)
1221 : {
1222 456816 : pari_sp av = avma;
1223 456816 : long n = get_F2x_degree(T)-1;
1224 456816 : GEN z = F2xq_mul(x, F2x_deriv(get_F2x_mod(T)), T);
1225 456816 : return gc_ulong(av, F2x_degree(z) < n ? 0 : 1);
1226 : }
1227 :
1228 : GEN
1229 7 : F2xq_conjvec(GEN x, GEN T)
1230 : {
1231 7 : long i, l = 1+get_F2x_degree(T);
1232 7 : GEN z = cgetg(l,t_COL);
1233 7 : gel(z,1) = F2x_copy(x);
1234 140 : for (i=2; i<l; i++) gel(z,i) = F2xq_sqr(gel(z,i-1), T);
1235 7 : return z;
1236 : }
1237 :
1238 : static GEN
1239 2398196 : _F2xq_pow(void *data, GEN x, GEN n)
1240 : {
1241 2398196 : GEN pol = (GEN) data;
1242 2398196 : return F2xq_pow(x,n, pol);
1243 : }
1244 :
1245 : static GEN
1246 9639 : _F2xq_rand(void *data)
1247 : {
1248 9639 : pari_sp av=avma;
1249 9639 : GEN pol = (GEN) data;
1250 9639 : long d = F2x_degree(pol);
1251 : GEN z;
1252 : do
1253 : {
1254 9862 : set_avma(av);
1255 9862 : z = random_F2x(d,pol[1]);
1256 9862 : } while (lgpol(z)==0);
1257 9639 : return z;
1258 : }
1259 :
1260 : static GEN F2xq_easylog(void* E, GEN a, GEN g, GEN ord);
1261 :
1262 : static const struct bb_group F2xq_star={_F2xq_mul,_F2xq_pow,_F2xq_rand,hash_GEN,F2x_equal,F2x_equal1,F2xq_easylog};
1263 :
1264 : GEN
1265 399 : F2xq_order(GEN a, GEN ord, GEN T)
1266 : {
1267 399 : return gen_order(a,ord,(void*)T,&F2xq_star);
1268 : }
1269 :
1270 : static long
1271 272159 : F2x_is_smooth_squarefree(GEN f, long r)
1272 : {
1273 272159 : pari_sp av = avma;
1274 272159 : long i, df = F2x_degree(f);
1275 : GEN sx, a;
1276 272189 : if (!df) return 1;
1277 267277 : a = sx = polx_F2x(f[1]);
1278 267241 : for(i = 1;; i++)
1279 2246210 : {
1280 : long dg;
1281 : GEN g;
1282 2513451 : a = F2xq_sqr(a, f);
1283 2496278 : if (F2x_equal(a, sx)) return gc_long(av,1);
1284 2441947 : if (i==r) return gc_long(av,0);
1285 2262605 : g = F2x_gcd(f, F2x_add(a,sx));
1286 2270939 : dg = F2x_degree(g);
1287 2269743 : if (dg == df) return gc_long(av,1);
1288 2248168 : if (dg) { f = F2x_div(f, g); df -= dg; a = F2x_rem(a, f); }
1289 : }
1290 : }
1291 :
1292 : static long
1293 236881 : F2x_is_smooth(GEN g, long r)
1294 : {
1295 236881 : if (lgpol(g)==0) return 0;
1296 : while (1)
1297 35598 : {
1298 272463 : GEN f = F2x_gcd(g, F2x_deriv(g));
1299 272201 : if (!F2x_is_smooth_squarefree(F2x_div(g, f), r)) return 0;
1300 93032 : if (F2x_degree(f)==0) return 1;
1301 35543 : g = F2x_issquare(f) ? F2x_sqrt(f): f;
1302 : }
1303 : }
1304 :
1305 : static GEN
1306 15013 : F2x_factorel(GEN h)
1307 : {
1308 15013 : GEN F = F2x_factor(h);
1309 15014 : GEN F1 = gel(F, 1), F2 = gel(F, 2);
1310 15014 : long i, l1 = lg(F1)-1;
1311 15014 : GEN p2 = cgetg(l1+1, t_VECSMALL);
1312 15013 : GEN e2 = cgetg(l1+1, t_VECSMALL);
1313 70229 : for (i = 1; i <= l1; ++i)
1314 : {
1315 55216 : p2[i] = mael(F1, i, 2);
1316 55216 : e2[i] = F2[i];
1317 : }
1318 15013 : return mkmat2(p2, e2);
1319 : }
1320 :
1321 : static GEN
1322 27013 : mkF2(ulong x, long v) { return mkvecsmall2(v, x); }
1323 :
1324 : static GEN F2xq_log_Coppersmith_d(GEN W, GEN g, long r, long n, GEN T, GEN mo);
1325 :
1326 : static GEN
1327 71 : F2xq_log_from_rel(GEN W, GEN rel, long r, long n, GEN T, GEN m)
1328 : {
1329 71 : pari_sp av = avma;
1330 71 : long vT = get_F2x_var(T);
1331 71 : GEN F = gel(rel,1), E = gel(rel,2), o = gen_0;
1332 71 : long i, l = lg(F);
1333 595 : for(i=1; i<l; i++)
1334 : {
1335 524 : GEN R = gel(W, F[i]);
1336 524 : if (signe(R)==0) /* Already failed */
1337 0 : return NULL;
1338 524 : else if (signe(R)<0) /* Not yet tested */
1339 : {
1340 6 : setsigne(gel(W,F[i]),0);
1341 6 : R = F2xq_log_Coppersmith_d(W, mkF2(F[i],vT), r, n, T, m);
1342 6 : if (!R) return NULL;
1343 : }
1344 524 : o = Fp_add(o, mulis(R, E[i]), m);
1345 : }
1346 71 : return gc_INT(av, o);
1347 : }
1348 :
1349 : static GEN
1350 95 : F2xq_log_Coppersmith_d(GEN W, GEN g, long r, long n, GEN T, GEN mo)
1351 : {
1352 95 : pari_sp av = avma, av2;
1353 95 : long dT = get_F2x_degree(T), vT = get_F2x_var(T);
1354 95 : long dg = F2x_degree(g), k = r-1, m = maxss((dg-k)/2,0);
1355 95 : long i, j, l = dg-m, N;
1356 95 : GEN v = cgetg(k+m+1,t_MAT);
1357 95 : long h = dT>>n, d = dT-(h<<n);
1358 95 : GEN p1 = pol1_F2x(vT);
1359 95 : GEN R = F2x_add(F2x_shift(p1, dT), T);
1360 95 : GEN z = F2x_rem(F2x_shift(p1, h), g);
1361 1187 : for(i=1; i<=k+m; i++)
1362 : {
1363 1092 : gel(v,i) = F2x_to_F2v(F2x_shift(z,-l),m);
1364 1092 : z = F2x_rem(F2x_shift(z,1),g);
1365 : }
1366 95 : v = F2m_ker(v);
1367 1045 : for(i=1; i<=k; i++)
1368 950 : gel(v,i) = F2v_to_F2x(gel(v,i),vT);
1369 95 : N = 1<<k;
1370 95 : av2 = avma;
1371 38329 : for (i=1; i<N; i++)
1372 : {
1373 : GEN p,q,qh,a,b;
1374 38305 : set_avma(av2);
1375 38305 : q = pol0_F2x(vT);
1376 421355 : for(j=0; j<k; j++)
1377 383050 : if (i&(1UL<<j))
1378 180909 : q = F2x_add(q, gel(v,j+1));
1379 38305 : qh= F2x_shift(q,h);
1380 38305 : p = F2x_rem(qh,g);
1381 38305 : b = F2x_add(F2x_mul(R, F2x_pow2n(q, n)), F2x_shift(F2x_pow2n(p, n), d));
1382 38305 : if (lgpol(b)==0 || !F2x_is_smooth(b, r)) continue;
1383 71 : a = F2x_div(F2x_add(qh,p),g);
1384 71 : if (F2x_degree(F2x_gcd(a,q)) && F2x_degree(F2x_gcd(a,p))) continue;
1385 71 : if (!(lgpol(a)==0 || !F2x_is_smooth(a, r)))
1386 : {
1387 71 : GEN F = F2x_factorel(b);
1388 71 : GEN G = F2x_factorel(a);
1389 71 : GEN FG = vecsmall_concat(vecsmall_append(gel(F, 1), 2), gel(G, 1));
1390 71 : GEN E = vecsmall_concat(vecsmall_append(gel(F, 2), -d),
1391 71 : zv_z_mul(gel(G, 2),-(1L<<n)));
1392 71 : GEN R = famatsmall_reduce(mkmat2(FG, E));
1393 71 : GEN l = F2xq_log_from_rel(W, R, r, n, T, mo);
1394 71 : if (!l) continue;
1395 71 : l = Fp_div(l,int2n(n),mo);
1396 71 : if (dg <= r)
1397 : {
1398 7 : affii(l,gel(W,g[2]));
1399 7 : if (DEBUGLEVEL>1) err_printf("Found %lu\n", g[2]);
1400 : }
1401 71 : return gc_INT(av, l);
1402 : }
1403 : }
1404 24 : return gc_NULL(av);
1405 : }
1406 :
1407 : static GEN
1408 65 : F2xq_log_find_rel(GEN b, long r, GEN T, GEN *g, ulong *e)
1409 : {
1410 65 : pari_sp av = avma;
1411 : while (1)
1412 895 : {
1413 : GEN M;
1414 960 : *g = F2xq_mul(*g, b, T); (*e)++;
1415 960 : M = F2x_halfgcd(*g,T);
1416 960 : if (F2x_is_smooth(gcoeff(M,1,1), r))
1417 : {
1418 393 : GEN z = F2x_add(F2x_mul(gcoeff(M,1,1),*g), F2x_mul(gcoeff(M,1,2),T));
1419 393 : if (F2x_is_smooth(z, r))
1420 : {
1421 65 : GEN F = F2x_factorel(z);
1422 65 : GEN G = F2x_factorel(gcoeff(M,1,1));
1423 65 : GEN rel = mkmat2(vecsmall_concat(gel(F, 1),gel(G, 1)),
1424 65 : vecsmall_concat(gel(F, 2),zv_neg(gel(G, 2))));
1425 65 : return gc_all(av, 2, &rel, g);
1426 : }
1427 : }
1428 895 : if (gc_needed(av,2))
1429 : {
1430 0 : if (DEBUGMEM>1) pari_warn(warnmem,"F2xq_log_find_rel");
1431 0 : *g = gc_uptoleaf(av, *g);
1432 : }
1433 : }
1434 : }
1435 :
1436 : static GEN
1437 28 : F2xq_log_Coppersmith_rec(GEN W, long r2, GEN a, long r, long n, GEN T, GEN m)
1438 : {
1439 28 : long vT = get_F2x_var(T);
1440 28 : GEN b = polx_F2x(vT);
1441 28 : ulong AV = 0;
1442 28 : GEN g = a, bad = pol0_F2x(vT);
1443 : pari_timer ti;
1444 : while(1)
1445 37 : {
1446 : long i, l;
1447 : GEN V, F, E, Ao;
1448 65 : timer_start(&ti);
1449 65 : V = F2xq_log_find_rel(b, r2, T, &g, &AV);
1450 65 : if (DEBUGLEVEL>1) timer_printf(&ti,"%ld-smooth element",r2);
1451 65 : F = gel(V,1); E = gel(V,2);
1452 65 : l = lg(F);
1453 65 : Ao = gen_0;
1454 480 : for(i=1; i<l; i++)
1455 : {
1456 452 : GEN Fi = mkF2(F[i], vT);
1457 : GEN R;
1458 452 : if (F2x_degree(Fi) <= r)
1459 : {
1460 351 : if (signe(gel(W,F[i]))==0)
1461 0 : break;
1462 351 : else if (signe(gel(W,F[i]))<0)
1463 : {
1464 1 : setsigne(gel(W,F[i]),0);
1465 1 : R = F2xq_log_Coppersmith_d(W,Fi,r,n,T,m);
1466 : } else
1467 350 : R = gel(W,F[i]);
1468 : }
1469 : else
1470 : {
1471 101 : if (F2x_equal(Fi,bad)) break;
1472 88 : R = F2xq_log_Coppersmith_d(W,Fi,r,n,T,m);
1473 88 : if (!R) bad = Fi;
1474 : }
1475 439 : if (!R) break;
1476 415 : Ao = Fp_add(Ao, mulis(R, E[i]), m);
1477 : }
1478 65 : if (i==l) return subiu(Ao,AV);
1479 : }
1480 : }
1481 :
1482 : /* Coppersmith:
1483 : T*X^e = X^(h*2^n)-R
1484 : (u*x^h + v)^(2^n) = u^(2^n)*X^(h*2^n)+v^(2^n)
1485 : (u*x^h + v)^(2^n) = u^(2^n)*R+v^(2^n)
1486 : */
1487 :
1488 : static GEN
1489 147667 : rel_Coppersmith(GEN u, GEN v, long h, GEN R, long r, long n, long d)
1490 : {
1491 : GEN b, F, G, M;
1492 147667 : GEN a = F2x_add(F2x_shift(u, h), v);
1493 147691 : if (!F2x_is_smooth(a, r)) return NULL;
1494 49526 : b = F2x_add(F2x_mul(R, F2x_pow2n(u, n)), F2x_shift(F2x_pow2n(v, n),d));
1495 49529 : if (!F2x_is_smooth(b, r)) return NULL;
1496 7370 : F = F2x_factorel(a);
1497 7371 : G = F2x_factorel(b);
1498 14742 : M = mkmat2(vecsmall_concat(gel(F, 1), vecsmall_append(gel(G, 1), 2)),
1499 14741 : vecsmall_concat(zv_z_mul(gel(F, 2),1UL<<n), vecsmall_append(zv_neg(gel(G, 2)),d)));
1500 7371 : return famatsmall_reduce(M);
1501 : }
1502 :
1503 : GEN
1504 2044 : F2xq_log_Coppersmith_worker(GEN u, long i, GEN V, GEN R)
1505 : {
1506 2044 : long r = V[1], h = V[2], n = V[3], d = V[4];
1507 2044 : pari_sp ltop = avma;
1508 2044 : GEN v = mkF2(0,u[1]);
1509 2042 : GEN L = cgetg(2*i+1, t_VEC);
1510 2009 : pari_sp av = avma;
1511 : long j;
1512 2009 : long nbtest=0, rel = 1;
1513 148266 : for(j=1; j<=i; j++)
1514 : {
1515 146219 : v[2] = j;
1516 146219 : set_avma(av);
1517 146248 : if (F2x_degree(F2x_gcd(u,v))==0)
1518 : {
1519 73894 : GEN z = rel_Coppersmith(u, v, h, R, r, n, d);
1520 73889 : nbtest++;
1521 73889 : if (z) { gel(L, rel++) = z; av = avma; }
1522 73889 : if (i==j) continue;
1523 73875 : z = rel_Coppersmith(v, u, h, R, r, n, d);
1524 73889 : nbtest++;
1525 73889 : if (z) { gel(L, rel++) = z; av = avma; }
1526 : }
1527 : }
1528 2047 : setlg(L,rel);
1529 2047 : return gc_GEN(ltop, mkvec2(stoi(nbtest), L));
1530 : }
1531 :
1532 : static GEN
1533 14 : F2xq_log_Coppersmith(long nbrel, long r, long n, GEN T)
1534 : {
1535 14 : long dT = get_F2x_degree(T), vT = get_F2x_var(T);
1536 14 : long h = dT>>n, d = dT-(h<<n);
1537 14 : GEN R = F2x_add(F2x_shift(pol1_F2x(vT), dT), T);
1538 14 : GEN u = mkF2(0,vT);
1539 14 : long rel = 1, nbtest = 0;
1540 14 : GEN M = cgetg(nbrel+1, t_VEC);
1541 14 : long i = 0;
1542 14 : GEN worker = snm_closure(is_entry("_F2xq_log_Coppersmith_worker"),
1543 : mkvec2(mkvecsmall4(r, h, n, d), R));
1544 : struct pari_mt pt;
1545 14 : long running, pending = 0, stop=0;
1546 14 : mt_queue_start(&pt, worker);
1547 14 : if (DEBUGLEVEL) err_printf("Coppersmith (R = %ld): ",F2x_degree(R));
1548 2091 : while ((running = !stop) || pending)
1549 : {
1550 : GEN L, done;
1551 : long j, l;
1552 2077 : u[2] = i;
1553 2077 : mt_queue_submit(&pt, 0, running ? mkvec2(u, stoi(i)): NULL);
1554 2077 : done = mt_queue_get(&pt, NULL, &pending);
1555 2077 : if (!done) continue;
1556 2047 : L = gel(done, 2); nbtest += itos(gel(done,1));
1557 2047 : l = lg(L);
1558 2047 : if (l > 1)
1559 : {
1560 9117 : for (j=1; j<l; j++)
1561 : {
1562 7244 : if (rel>nbrel) break;
1563 7210 : gel(M,rel++) = gel(L,j);
1564 7210 : if (DEBUGLEVEL && (rel&511UL)==0)
1565 0 : err_printf("%ld%%[%ld] ",rel*100/nbrel,i);
1566 : }
1567 : }
1568 2047 : if (rel>nbrel) stop=1;
1569 2047 : i++;
1570 : }
1571 14 : mt_queue_end(&pt);
1572 14 : if (DEBUGLEVEL) err_printf(": %ld tests\n", nbtest);
1573 14 : return M;
1574 : }
1575 :
1576 : static GEN
1577 14 : smallirred_F2x(ulong n, long sv)
1578 : {
1579 14 : GEN a = zero_zv(nbits2lg(n+1)-1);
1580 14 : a[1] = sv; F2x_set(a,n); a[2]++;
1581 238 : while (!F2x_is_irred(a)) a[2]+=2;
1582 14 : return a;
1583 : }
1584 :
1585 : static GEN
1586 14 : check_kernel(long N, GEN M, long nbi, GEN T, GEN m)
1587 : {
1588 14 : pari_sp av = avma;
1589 14 : long dT = get_F2x_degree(T), vT = get_F2x_var(T);
1590 14 : GEN K = FpMs_leftkernel_elt(M, N, m);
1591 14 : long i, f=0, tbs;
1592 14 : long l = lg(K), lm = lgefint(m);
1593 14 : GEN idx = diviiexact(int2um1(dT), m);
1594 14 : GEN g = F2xq_pow(polx_F2x(vT), idx, T);
1595 : GEN tab;
1596 : pari_timer ti;
1597 14 : if (DEBUGLEVEL) timer_start(&ti);
1598 14 : K = FpC_Fp_mul(K, Fp_inv(gel(K,2), m), m);
1599 14 : tbs = maxss(1, expu(nbi/expi(m)));
1600 14 : tab = F2xq_pow_init(g, int2n(dT), tbs, T);
1601 57344 : for(i=1; i<l; i++)
1602 : {
1603 57330 : GEN k = gel(K,i);
1604 57330 : if (signe(k)==0 || !F2x_equal(F2xq_pow_table(tab, k, T),
1605 : F2xq_pow(mkF2(i,vT), idx, T)))
1606 52086 : gel(K,i) = cgetineg(lm);
1607 : else
1608 5244 : f++;
1609 : }
1610 14 : if (DEBUGLEVEL) timer_printf(&ti,"found %ld/%ld logs", f, nbi);
1611 14 : return gc_upto(av, K);
1612 : }
1613 :
1614 : static GEN
1615 14 : F2xq_log_index(GEN a0, GEN b0, GEN m, GEN T0)
1616 : {
1617 14 : pari_sp av = avma;
1618 14 : GEN M, S, a, b, Ao=NULL, Bo=NULL, W, e;
1619 : pari_timer ti;
1620 14 : long n = F2x_degree(T0), r = (long) (sqrt((double) 2*n))-(n>100);
1621 14 : GEN T = smallirred_F2x(n,T0[1]);
1622 14 : long d = 2, r2 = 3*r/2, d2 = 2;
1623 14 : long N = (1UL<<(r+1))-1UL;
1624 14 : long nbi = itos(ffsumnbirred(gen_2, r)), nbrel=nbi*5/4;
1625 14 : if (DEBUGLEVEL)
1626 : {
1627 0 : err_printf("F2xq_log: Parameters r=%ld r2=%ld\n", r,r2);
1628 0 : err_printf("F2xq_log: Size FB=%ld rel. needed=%ld\n", nbi, nbrel);
1629 0 : timer_start(&ti);
1630 : }
1631 14 : S = Flx_to_F2x(Flx_ffisom(F2x_to_Flx(T0),F2x_to_Flx(T),2));
1632 14 : a = F2x_F2xq_eval(a0, S, T);
1633 14 : b = F2x_F2xq_eval(b0, S, T);
1634 14 : if (DEBUGLEVEL) timer_printf(&ti,"model change");
1635 14 : M = F2xq_log_Coppersmith(nbrel,r,d,T);
1636 14 : if(DEBUGLEVEL)
1637 0 : timer_printf(&ti,"relations");
1638 14 : W = check_kernel(N, M, nbi, T, m);
1639 14 : timer_start(&ti);
1640 14 : Ao = F2xq_log_Coppersmith_rec(W, r2, a, r, d2, T, m);
1641 14 : if (DEBUGLEVEL) timer_printf(&ti,"smooth element");
1642 14 : Bo = F2xq_log_Coppersmith_rec(W, r2, b, r, d2, T, m);
1643 14 : if (DEBUGLEVEL) timer_printf(&ti,"smooth generator");
1644 14 : e = Fp_div(Ao, Bo, m);
1645 14 : if (!F2x_equal(F2xq_pow(b0,e,T0),a0)) pari_err_BUG("F2xq_log");
1646 14 : return gc_upto(av, e);
1647 : }
1648 :
1649 : static GEN
1650 559583 : F2xq_easylog(void* E, GEN a, GEN g, GEN ord)
1651 : {
1652 559583 : if (F2x_equal1(a)) return gen_0;
1653 525027 : if (F2x_equal(a,g)) return gen_1;
1654 524222 : if (typ(ord)!=t_INT) return NULL;
1655 262513 : if (expi(ord)<28) return NULL;
1656 14 : return F2xq_log_index(a,g,ord,(GEN)E);
1657 : }
1658 :
1659 : GEN
1660 543710 : F2xq_log(GEN a, GEN g, GEN ord, GEN T)
1661 : {
1662 543710 : GEN z, v = get_arith_ZZM(ord);
1663 543710 : ord = mkvec2(gel(v,1),ZM_famat_limit(gel(v,2),int2n(28)));
1664 543710 : z = gen_PH_log(a,g,ord,(void*)T,&F2xq_star);
1665 543710 : return z? z: cgetg(1,t_VEC);
1666 : }
1667 :
1668 : GEN
1669 211610 : F2xq_Artin_Schreier(GEN a, GEN T)
1670 : {
1671 211610 : pari_sp ltop=avma;
1672 211610 : long j,N = get_F2x_degree(T), vT = get_F2x_var(T);
1673 211610 : GEN Q = F2x_matFrobenius(T);
1674 1470889 : for (j=1; j<=N; j++)
1675 1259279 : F2m_flip(Q,j,j);
1676 211610 : F2v_add_inplace(gel(Q,1),a);
1677 211610 : Q = F2m_ker_sp(Q,0);
1678 211610 : if (lg(Q)!=2) return NULL;
1679 211610 : Q = gel(Q,1);
1680 211610 : Q[1] = vT;
1681 211610 : return gc_uptoleaf(ltop, F2x_renormalize(Q, lg(Q)));
1682 : }
1683 :
1684 : GEN
1685 61738 : F2xq_sqrt_fast(GEN c, GEN sqx, GEN T)
1686 : {
1687 : GEN c0, c1;
1688 61738 : F2x_even_odd(c, &c0, &c1);
1689 61736 : return F2x_add(c0, F2xq_mul(c1, sqx, T));
1690 : }
1691 :
1692 : static int
1693 19253 : F2x_is_x(GEN a) { return lg(a)==3 && a[2]==2; }
1694 :
1695 : GEN
1696 38713 : F2xq_sqrt(GEN a, GEN T)
1697 : {
1698 38713 : pari_sp av = avma;
1699 38713 : long n = get_F2x_degree(T), vT = get_F2x_var(T);
1700 : GEN sqx;
1701 38713 : if (n==1) return F2x_copy(a);
1702 38622 : if (n==2) return F2xq_sqr(a,T);
1703 19253 : sqx = F2xq_autpow(mkF2(4, vT), n-1, T);
1704 19253 : return gc_uptoleaf(av, F2x_is_x(a)? sqx: F2xq_sqrt_fast(a,sqx,T));
1705 : }
1706 :
1707 : GEN
1708 8348 : F2xq_sqrtn(GEN a, GEN n, GEN T, GEN *zeta)
1709 : {
1710 8348 : long dT = get_F2x_degree(T), vT = get_F2x_var(T);
1711 8348 : if (!lgpol(a))
1712 : {
1713 7 : if (signe(n) < 0) pari_err_INV("F2xq_sqrtn",a);
1714 0 : if (zeta)
1715 0 : *zeta=pol1_F2x(vT);
1716 0 : return pol0_F2x(vT);
1717 : }
1718 8341 : return gen_Shanks_sqrtn(a, n, int2um1(dT), zeta, (void*)T, &F2xq_star);
1719 : }
1720 :
1721 : GEN
1722 161 : gener_F2xq(GEN T, GEN *po)
1723 : {
1724 161 : long i, j, vT = get_F2x_var(T), f = get_F2x_degree(T);
1725 161 : pari_sp av0 = avma, av;
1726 : GEN g, L2, o, q;
1727 :
1728 161 : if (f == 1) {
1729 21 : if (po) *po = mkvec2(gen_1, trivial_fact());
1730 21 : return pol1_F2x(vT);
1731 : }
1732 140 : q = int2um1(f);
1733 140 : o = factor_pn_1(gen_2,f);
1734 140 : L2 = leafcopy( gel(o, 1) );
1735 399 : for (i = j = 1; i < lg(L2); i++)
1736 : {
1737 259 : if (absequaliu(gel(L2,i),2)) continue;
1738 259 : gel(L2,j++) = diviiexact(q, gel(L2,i));
1739 : }
1740 140 : setlg(L2, j);
1741 238 : for (av = avma;; set_avma(av))
1742 : {
1743 238 : g = random_F2x(f, vT);
1744 238 : if (F2x_degree(g) < 1) continue;
1745 469 : for (i = 1; i < j; i++)
1746 : {
1747 329 : GEN a = F2xq_pow(g, gel(L2,i), T);
1748 329 : if (F2x_equal1(a)) break;
1749 : }
1750 196 : if (i == j) break;
1751 : }
1752 140 : if (!po) g = gc_GEN(av0, g);
1753 : else {
1754 0 : *po = mkvec2(int2um1(f), o);
1755 0 : (void)gc_all(av0, 2, &g, po);
1756 : }
1757 140 : return g;
1758 : }
1759 :
1760 : static GEN
1761 756 : _F2xq_neg(void *E, GEN x) { (void) E; return F2x_copy(x); }
1762 : static GEN
1763 15799 : _F2xq_rmul(void *E, GEN x, GEN y) { (void) E; return F2x_mul(x,y); }
1764 : static GEN
1765 364 : _F2xq_inv(void *E, GEN x) { return F2xq_inv(x, (GEN) E); }
1766 : static int
1767 861 : _F2xq_equal0(GEN x) { return lgpol(x)==0; }
1768 : static GEN
1769 623 : _F2xq_s(void *E, long x)
1770 623 : { GEN T = (GEN) E;
1771 623 : long v = get_F2x_var(T);
1772 623 : return odd(x)? pol1_F2x(v): pol0_F2x(v);
1773 : }
1774 :
1775 : static const struct bb_field F2xq_field={_F2xq_red,_F2xq_add,_F2xq_rmul,_F2xq_neg,
1776 : _F2xq_inv,_F2xq_equal0,_F2xq_s};
1777 :
1778 1666 : const struct bb_field *get_F2xq_field(void **E, GEN T)
1779 : {
1780 1666 : *E = (void *) T;
1781 1666 : return &F2xq_field;
1782 : }
1783 :
1784 : /***********************************************************************/
1785 : /** **/
1786 : /** F2xV **/
1787 : /** **/
1788 : /***********************************************************************/
1789 : /* F2xV are t_VEC with F2x coefficients. */
1790 :
1791 : GEN
1792 38913 : FlxC_to_F2xC(GEN x) { pari_APPLY_type(t_COL, Flx_to_F2x(gel(x,i))) }
1793 : GEN
1794 0 : F2xC_to_FlxC(GEN x) { pari_APPLY_type(t_COL, F2x_to_Flx(gel(x,i))) }
1795 : GEN
1796 11137 : F2xC_to_ZXC(GEN x) { pari_APPLY_type(t_COL, F2x_to_ZX(gel(x,i))) }
1797 : GEN
1798 1789059 : F2xV_to_F2m(GEN x, long n) { pari_APPLY_type(t_MAT, F2x_to_F2v(gel(x,i), n)) }
1799 :
1800 : void
1801 30367 : F2xV_to_FlxV_inplace(GEN v)
1802 : {
1803 30367 : long i, l = lg(v);
1804 69659 : for(i = 1; i < l;i++) gel(v,i) = F2x_to_Flx(gel(v,i));
1805 30367 : }
1806 : void
1807 1435087 : F2xV_to_ZXV_inplace(GEN v)
1808 : {
1809 1435087 : long i, l = lg(v);
1810 2721684 : for(i = 1; i < l; i++) gel(v,i)= F2x_to_ZX(gel(v,i));
1811 1435090 : }
1812 :
1813 : /***********************************************************************/
1814 : /** **/
1815 : /** F2xX **/
1816 : /** **/
1817 : /***********************************************************************/
1818 :
1819 : GEN
1820 2711198 : F2xX_renormalize(GEN /*in place*/ x, long lx)
1821 2711198 : { return FlxX_renormalize(x, lx); }
1822 :
1823 : GEN
1824 446187 : pol1_F2xX(long v, long sv) { return pol1_FlxX(v, sv); }
1825 :
1826 : GEN
1827 441 : polx_F2xX(long v, long sv) { return polx_FlxX(v, sv); }
1828 :
1829 : long
1830 206465 : F2xY_degreex(GEN b)
1831 : {
1832 206465 : long deg = 0, i;
1833 206465 : if (!signe(b)) return -1;
1834 1340640 : for (i = 2; i < lg(b); ++i)
1835 1134175 : deg = maxss(deg, F2x_degree(gel(b, i)));
1836 206465 : return deg;
1837 : }
1838 :
1839 : GEN
1840 945 : FlxX_to_F2xX(GEN B)
1841 : {
1842 945 : long lb=lg(B);
1843 : long i;
1844 945 : GEN b=cgetg(lb,t_POL);
1845 945 : b[1]=evalsigne(1)|(((ulong)B[1])&VARNBITS);
1846 4718 : for (i=2; i<lb; i++)
1847 3773 : gel(b,i) = Flx_to_F2x(gel(B,i));
1848 945 : return F2xX_renormalize(b, lb);
1849 : }
1850 :
1851 : GEN
1852 4991 : ZXX_to_F2xX(GEN B, long v)
1853 : {
1854 4991 : long lb=lg(B);
1855 : long i;
1856 4991 : GEN b=cgetg(lb,t_POL);
1857 4991 : b[1]=evalsigne(1)|(((ulong)B[1])&VARNBITS);
1858 23492 : for (i=2; i<lb; i++)
1859 18501 : switch (typ(gel(B,i)))
1860 : {
1861 8721 : case t_INT:
1862 8721 : gel(b,i) = Z_to_F2x(gel(B,i), evalvarn(v));
1863 8721 : break;
1864 9780 : case t_POL:
1865 9780 : gel(b,i) = ZX_to_F2x(gel(B,i));
1866 9780 : break;
1867 : }
1868 4991 : return F2xX_renormalize(b, lb);
1869 : }
1870 :
1871 : GEN
1872 56 : F2xX_to_FlxX(GEN B)
1873 : {
1874 56 : long i, lb = lg(B);
1875 56 : GEN b = cgetg(lb,t_POL);
1876 266 : for (i=2; i<lb; i++)
1877 210 : gel(b,i) = F2x_to_Flx(gel(B,i));
1878 56 : b[1] = B[1]; return b;
1879 : }
1880 :
1881 : GEN
1882 1470 : F2xX_to_ZXX(GEN B)
1883 : {
1884 1470 : long i, lb = lg(B);
1885 1470 : GEN b = cgetg(lb,t_POL);
1886 4991 : for (i=2; i<lb; i++)
1887 : {
1888 3521 : GEN c = gel(B,i);
1889 3521 : gel(b,i) = lgpol(c) ? F2x_equal1(c) ? gen_1 : F2x_to_ZX(c) : gen_0;
1890 : }
1891 1470 : b[1] = B[1]; return b;
1892 : }
1893 :
1894 : GEN
1895 80465 : F2xX_deriv(GEN z)
1896 : {
1897 80465 : long i,l = lg(z)-1;
1898 : GEN x;
1899 80465 : if (l < 2) l = 2;
1900 80465 : x = cgetg(l, t_POL); x[1] = z[1];
1901 527436 : for (i=2; i<l; i++) gel(x,i) = odd(i) ? pol0_F2x(mael(z,i+1,1)): gel(z,i+1);
1902 80465 : return F2xX_renormalize(x,l);
1903 : }
1904 :
1905 : static GEN
1906 1186 : F2xX_addspec(GEN x, GEN y, long lx, long ly)
1907 : {
1908 : long i,lz;
1909 : GEN z;
1910 1186 : if (ly>lx) swapspec(x,y, lx,ly);
1911 1186 : lz = lx+2; z = cgetg(lz, t_POL);
1912 139499 : for (i=0; i<ly; i++) gel(z,i+2) = F2x_add(gel(x,i), gel(y,i));
1913 1186 : for ( ; i<lx; i++) gel(z,i+2) = F2x_copy(gel(x,i));
1914 1186 : z[1] = 0; return F2xX_renormalize(z, lz);
1915 : }
1916 :
1917 : GEN
1918 423367 : F2xX_add(GEN x, GEN y)
1919 : {
1920 : long i,lz;
1921 : GEN z;
1922 423367 : long lx=lg(x);
1923 423367 : long ly=lg(y);
1924 423367 : if (ly>lx) swapspec(x,y, lx,ly);
1925 423367 : lz = lx; z = cgetg(lz, t_POL); z[1]=x[1];
1926 1501362 : for (i=2; i<ly; i++) gel(z,i) = F2x_add(gel(x,i), gel(y,i));
1927 1680677 : for ( ; i<lx; i++) gel(z,i) = F2x_copy(gel(x,i));
1928 423367 : return F2xX_renormalize(z, lz);
1929 : }
1930 :
1931 : GEN
1932 0 : F2xX_F2x_add(GEN x, GEN y)
1933 : {
1934 0 : long i, lz = lg(y);
1935 : GEN z;
1936 0 : if (signe(y) == 0) return scalarpol(x, varn(y));
1937 0 : z = cgetg(lz,t_POL); z[1] = y[1];
1938 0 : gel(z,2) = F2x_add(gel(y,2), x);
1939 0 : if (lz == 3) z = F2xX_renormalize(z,lz);
1940 : else
1941 0 : for(i=3;i<lz;i++) gel(z,i) = F2x_copy(gel(y,i));
1942 0 : return z;
1943 : }
1944 :
1945 : GEN
1946 481488 : F2xX_F2x_mul(GEN P, GEN U)
1947 : {
1948 481488 : long i, lP = lg(P);
1949 481488 : GEN res = cgetg(lP,t_POL);
1950 481488 : res[1] = P[1];
1951 2352287 : for(i=2; i<lP; i++)
1952 1870799 : gel(res,i) = F2x_mul(U,gel(P,i));
1953 481488 : return F2xX_renormalize(res, lP);
1954 : }
1955 :
1956 : GEN
1957 136416 : F2xY_F2xqV_evalx(GEN P, GEN x, GEN T)
1958 : {
1959 136416 : long i, lP = lg(P);
1960 136416 : GEN res = cgetg(lP,t_POL);
1961 136416 : res[1] = P[1];
1962 617666 : for(i=2; i<lP; i++)
1963 481250 : gel(res,i) = F2x_F2xqV_eval(gel(P,i), x, T);
1964 136416 : return F2xX_renormalize(res, lP);
1965 : }
1966 :
1967 : GEN
1968 0 : F2xY_F2xq_evalx(GEN P, GEN x, GEN T)
1969 : {
1970 0 : pari_sp av = avma;
1971 0 : long n = brent_kung_optpow(get_F2x_degree(T)-1,lgpol(P),1);
1972 0 : GEN xp = F2xq_powers(x, n, T);
1973 0 : return gc_upto(av, F2xY_F2xqV_evalx(P, xp, T));
1974 : }
1975 :
1976 : static GEN
1977 6038 : F2xX_to_Kronecker_spec(GEN P, long n, long d)
1978 : {
1979 6038 : long i, k, l, N = 2*d + 1;
1980 6038 : long dP = n+1;
1981 : GEN x;
1982 6038 : if (n == 0) return pol0_Flx(P[1]&VARNBITS);
1983 6038 : l = nbits2nlong(N*dP+d+1);
1984 6038 : x = zero_zv(l+1);
1985 368117 : for (k=i=0; i<n; i++, k+=N)
1986 : {
1987 362079 : GEN c = gel(P,i);
1988 362079 : F2x_addshiftip(x, c, k);
1989 : }
1990 6038 : x[1] = P[1]&VARNBITS; return F2x_renormalize(x, l+2);
1991 : }
1992 :
1993 : GEN
1994 310456 : F2xX_to_Kronecker(GEN P, long d)
1995 : {
1996 310456 : long i, k, l, N = 2*d + 1;
1997 310456 : long dP = degpol(P);
1998 : GEN x;
1999 310456 : if (dP < 0) return pol0_Flx(P[1]&VARNBITS);
2000 309148 : l = nbits2nlong(N*dP+d+1);
2001 309148 : x = zero_zv(l+1);
2002 1717227 : for (k=i=0; i<=dP; i++, k+=N)
2003 : {
2004 1408079 : GEN c = gel(P,i+2);
2005 1408079 : F2x_addshiftip(x, c, k);
2006 : }
2007 309148 : x[1] = P[1]&VARNBITS; return F2x_renormalize(x, l+2);
2008 : }
2009 :
2010 : static GEN
2011 1609211 : F2x_slice(GEN x, long n, long d)
2012 : {
2013 1609211 : ulong ib, il=dvmduBIL(n, &ib);
2014 1609211 : ulong db, dl=dvmduBIL(d, &db);
2015 1609211 : long lN = dl+2+(db?1:0);
2016 1609211 : GEN t = cgetg(lN,t_VECSMALL);
2017 1609211 : t[1] = x[1];
2018 1609211 : if (ib)
2019 : {
2020 1443444 : ulong i, ic = BITS_IN_LONG-ib;
2021 1443444 : ulong r = uel(x,2+il)>>ib;
2022 1444012 : for(i=0; i<dl; i++)
2023 : {
2024 568 : uel(t,2+i) = (uel(x,3+il+i)<<ic)|r;
2025 568 : r = uel(x,3+il+i)>>ib;
2026 : }
2027 1443444 : if (db)
2028 1443444 : uel(t,2+i) = (uel(x,3+il+i)<<ic)|r;
2029 : }
2030 : else
2031 : {
2032 : long i;
2033 331682 : for(i=2; i<lN; i++)
2034 165915 : uel(t,i) = uel(x,il+i);
2035 : }
2036 1609211 : if (db) uel(t,lN-1) &= (1UL<<db)-1;
2037 1609211 : return F2x_renormalize(t, lN);
2038 : }
2039 :
2040 : GEN
2041 158247 : Kronecker_to_F2xqX(GEN z, GEN T)
2042 : {
2043 158247 : long lz = F2x_degree(z)+1;
2044 158247 : long i, j, N = get_F2x_degree(T)*2 + 1;
2045 158247 : long lx = lz / (N-2);
2046 158247 : GEN x = cgetg(lx+3,t_POL);
2047 158247 : x[1] = z[1];
2048 1767458 : for (i=0, j=2; i<lz; i+=N, j++)
2049 : {
2050 1609211 : GEN t = F2x_slice(z,i,minss(lz-i,N));
2051 1609211 : t[1] = T[1];
2052 1609211 : gel(x,j) = F2x_rem(t, T);
2053 : }
2054 158247 : return F2xX_renormalize(x, j);
2055 : }
2056 :
2057 : GEN
2058 0 : F2xX_to_F2xC(GEN x, long N, long sv)
2059 : {
2060 : long i, l;
2061 : GEN z;
2062 0 : l = lg(x)-1; x++;
2063 0 : if (l > N+1) l = N+1; /* truncate higher degree terms */
2064 0 : z = cgetg(N+1,t_COL);
2065 0 : for (i=1; i<l ; i++) gel(z,i) = gel(x,i);
2066 0 : for ( ; i<=N; i++) gel(z,i) = pol0_F2x(sv);
2067 0 : return z;
2068 : }
2069 :
2070 : GEN
2071 0 : F2xXV_to_F2xM(GEN v, long n, long sv)
2072 : {
2073 0 : long j, N = lg(v);
2074 0 : GEN y = cgetg(N, t_MAT);
2075 0 : for (j=1; j<N; j++) gel(y,j) = F2xX_to_F2xC(gel(v,j), n, sv);
2076 0 : return y;
2077 : }
2078 :
2079 : /***********************************************************************/
2080 : /** **/
2081 : /** F2xXV/F2xXC **/
2082 : /** **/
2083 : /***********************************************************************/
2084 :
2085 : GEN
2086 1330 : FlxXC_to_F2xXC(GEN x) { pari_APPLY_type(t_COL, FlxX_to_F2xX(gel(x,i))); }
2087 : GEN
2088 2611 : F2xXC_to_ZXXC(GEN x) { pari_APPLY_type(t_COL, F2xX_to_ZXX(gel(x,i))); }
2089 :
2090 : /***********************************************************************/
2091 : /** **/
2092 : /** F2xqX **/
2093 : /** **/
2094 : /***********************************************************************/
2095 :
2096 : static GEN
2097 783356 : get_F2xqX_red(GEN T, GEN *B)
2098 : {
2099 783356 : if (typ(T)!=t_VEC) { *B=NULL; return T; }
2100 2842 : *B = gel(T,1); return gel(T,2);
2101 : }
2102 :
2103 : GEN
2104 2842 : random_F2xqX(long d1, long v, GEN T)
2105 : {
2106 2842 : long dT = get_F2x_degree(T), vT = get_F2x_var(T);
2107 2842 : long i, d = d1+2;
2108 2842 : GEN y = cgetg(d,t_POL); y[1] = evalsigne(1) | evalvarn(v);
2109 19068 : for (i=2; i<d; i++) gel(y,i) = random_F2x(dT, vT);
2110 2842 : return FlxX_renormalize(y,d);
2111 : }
2112 :
2113 : GEN
2114 1004041 : F2xqX_red(GEN z, GEN T)
2115 : {
2116 : GEN res;
2117 1004041 : long i, l = lg(z);
2118 1004041 : res = cgetg(l,t_POL); res[1] = z[1];
2119 5667612 : for(i=2;i<l;i++) gel(res,i) = F2x_rem(gel(z,i),T);
2120 1004041 : return F2xX_renormalize(res,l);
2121 : }
2122 :
2123 : GEN
2124 6993 : F2xqX_F2xq_mul(GEN P, GEN U, GEN T)
2125 : {
2126 6993 : long i, lP = lg(P);
2127 6993 : GEN res = cgetg(lP,t_POL);
2128 6993 : res[1] = P[1];
2129 39165 : for(i=2; i<lP; i++)
2130 32172 : gel(res,i) = F2xq_mul(U,gel(P,i), T);
2131 6993 : return F2xX_renormalize(res, lP);
2132 : }
2133 :
2134 : GEN
2135 206010 : F2xqX_F2xq_mul_to_monic(GEN P, GEN U, GEN T)
2136 : {
2137 206010 : long i, lP = lg(P);
2138 206010 : GEN res = cgetg(lP,t_POL);
2139 206010 : res[1] = P[1];
2140 1129716 : for(i=2; i<lP-1; i++) gel(res,i) = F2xq_mul(U,gel(P,i), T);
2141 206010 : gel(res,lP-1) = pol1_F2x(T[1]);
2142 206010 : return F2xX_renormalize(res, lP);
2143 : }
2144 :
2145 : GEN
2146 206024 : F2xqX_normalize(GEN z, GEN T)
2147 : {
2148 206024 : GEN p1 = leading_coeff(z);
2149 206024 : if (!lgpol(z) || (!degpol(p1) && p1[1] == 1)) return z;
2150 206010 : return F2xqX_F2xq_mul_to_monic(z, F2xq_inv(p1,T), T);
2151 : }
2152 :
2153 : GEN
2154 155228 : F2xqX_mul(GEN x, GEN y, GEN T)
2155 : {
2156 155228 : pari_sp ltop=avma;
2157 : GEN z, kx, ky;
2158 155228 : long d = get_F2x_degree(T);
2159 155228 : kx= F2xX_to_Kronecker(x, d);
2160 155228 : ky= F2xX_to_Kronecker(y, d);
2161 155228 : z = F2x_mul(ky, kx);
2162 155228 : z = Kronecker_to_F2xqX(z, T);
2163 155228 : return gc_upto(ltop, z);
2164 : }
2165 :
2166 : static GEN
2167 3019 : F2xqX_mulspec(GEN x, GEN y, GEN T, long nx, long ny)
2168 : {
2169 3019 : pari_sp ltop=avma;
2170 : GEN z, kx, ky;
2171 3019 : long dT = get_F2x_degree(T);
2172 3019 : kx= F2xX_to_Kronecker_spec(x, nx, dT);
2173 3019 : ky= F2xX_to_Kronecker_spec(y, ny, dT);
2174 3019 : z = F2x_mul(ky, kx);
2175 3019 : z = Kronecker_to_F2xqX(z,T);
2176 3019 : return gc_upto(ltop,z);
2177 : }
2178 :
2179 : GEN
2180 105350 : F2xqX_sqr(GEN x, GEN T)
2181 : {
2182 105350 : long d = degpol(x), l = 2*d+3;
2183 : GEN z;
2184 105350 : if (!signe(x)) return pol_0(varn(x));
2185 105343 : z = cgetg(l,t_POL);
2186 105343 : z[1] = x[1];
2187 105343 : if (d > 0)
2188 : {
2189 105245 : GEN u = pol0_F2x(T[1]);
2190 : long i,j;
2191 268968 : for (i=2,j=2; i<d+2; i++,j+=2)
2192 : {
2193 163723 : gel(z, j) = F2xq_sqr(gel(x, i), T);
2194 163723 : gel(z, j+1) = u;
2195 : }
2196 : }
2197 105343 : gel(z, 2+2*d) = F2xq_sqr(gel(x, 2+d), T);
2198 105343 : return FlxX_renormalize(z, l);
2199 : }
2200 :
2201 : static GEN
2202 882 : _F2xqX_mul(void *data,GEN a,GEN b) { return F2xqX_mul(a,b, (GEN) data); }
2203 : static GEN
2204 0 : _F2xqX_sqr(void *data,GEN a) { return F2xqX_sqr(a, (GEN) data); }
2205 : GEN
2206 0 : F2xqX_powu(GEN x, ulong n, GEN T)
2207 0 : { return gen_powu(x, n, (void*)T, &_F2xqX_sqr, &_F2xqX_mul); }
2208 :
2209 : GEN
2210 7 : F2xqXV_prod(GEN V, GEN T)
2211 : {
2212 7 : return gen_product(V, (void*)T, &_F2xqX_mul);
2213 : }
2214 :
2215 : static GEN
2216 7 : F2xqV_roots_to_deg1(GEN x, GEN T, long v)
2217 : {
2218 7 : long sv = get_Flx_var(T);
2219 896 : pari_APPLY_same(deg1pol_shallow(pol1_F2x(sv),gel(x,i), v))
2220 : }
2221 :
2222 : GEN
2223 7 : F2xqV_roots_to_pol(GEN V, GEN T, long v)
2224 : {
2225 7 : pari_sp ltop = avma;
2226 7 : GEN W = F2xqV_roots_to_deg1(V, T, v);
2227 7 : return gc_upto(ltop, F2xqXV_prod(W, T));
2228 : }
2229 :
2230 : static GEN
2231 545227 : F2xqX_divrem_basecase(GEN x, GEN y, GEN T, GEN *pr)
2232 : {
2233 545227 : long vx = varn(x), dx = degpol(x), dy = degpol(y), dz, i, j, sx, lr;
2234 : pari_sp av0, av;
2235 : GEN z, p1, rem, lead;
2236 :
2237 545227 : if (!signe(y)) pari_err_INV("F2xqX_divrem",y);
2238 545227 : if (dx < dy)
2239 : {
2240 0 : if (pr)
2241 : {
2242 0 : av0 = avma; x = F2xqX_red(x, T);
2243 0 : if (pr == ONLY_DIVIDES) { set_avma(av0); return signe(x)? NULL: pol_0(vx); }
2244 0 : if (pr == ONLY_REM) return x;
2245 0 : *pr = x;
2246 : }
2247 0 : return pol_0(vx);
2248 : }
2249 545227 : lead = leading_coeff(y);
2250 545227 : if (!dy) /* y is constant */
2251 : {
2252 115507 : if (pr && pr != ONLY_DIVIDES)
2253 : {
2254 105483 : if (pr == ONLY_REM) return pol_0(vx);
2255 21 : *pr = pol_0(vx);
2256 : }
2257 10045 : if (F2x_equal1(lead)) return gcopy(x);
2258 6986 : av0 = avma; x = F2xqX_F2xq_mul(x,F2xq_inv(lead,T),T);
2259 6986 : return gc_upto(av0,x);
2260 : }
2261 429720 : av0 = avma; dz = dx-dy;
2262 429720 : lead = F2x_equal1(lead)? NULL: gclone(F2xq_inv(lead,T));
2263 429720 : set_avma(av0);
2264 429720 : z = cgetg(dz+3,t_POL); z[1] = x[1];
2265 429720 : x += 2; y += 2; z += 2;
2266 :
2267 429720 : p1 = gel(x,dx); av = avma;
2268 429720 : gel(z,dz) = lead? gc_upto(av, F2xq_mul(p1,lead, T)): leafcopy(p1);
2269 1279347 : for (i=dx-1; i>=dy; i--)
2270 : {
2271 849627 : av = avma; p1 = gel(x,i);
2272 2661311 : for (j=i-dy+1; j<=i && j<=dz; j++)
2273 1811684 : p1 = F2x_add(p1, F2x_mul(gel(z,j),gel(y,i-j)));
2274 849627 : if (lead) p1 = F2x_mul(p1, lead);
2275 849627 : gel(z,i-dy) = gc_uptoleaf(av, F2x_rem(p1,T));
2276 : }
2277 429720 : if (!pr) { guncloneNULL(lead); return z-2; }
2278 :
2279 406574 : rem = (GEN)avma; av = (pari_sp)new_chunk(dx+3);
2280 629265 : for (sx=0; ; i--)
2281 : {
2282 629265 : p1 = gel(x,i);
2283 1900871 : for (j=0; j<=i && j<=dz; j++)
2284 1271606 : p1 = F2x_add(p1, F2x_mul(gel(z,j),gel(y,i-j)));
2285 629265 : p1 = F2x_rem(p1, T); if (lgpol(p1)) { sx = 1; break; }
2286 285607 : if (!i) break;
2287 222691 : set_avma(av);
2288 : }
2289 406574 : if (pr == ONLY_DIVIDES)
2290 : {
2291 0 : guncloneNULL(lead);
2292 0 : if (sx) return gc_NULL(av0);
2293 0 : return gc_const((pari_sp)rem, z-2);
2294 : }
2295 406574 : lr=i+3; rem -= lr; av = (pari_sp)rem;
2296 406574 : rem[0] = evaltyp(t_POL) | _evallg(lr);
2297 406574 : rem[1] = z[-1];
2298 406574 : rem += 2; gel(rem,i) = gc_uptoleaf(av, p1);
2299 1380974 : for (i--; i>=0; i--)
2300 : {
2301 974400 : av = avma; p1 = gel(x,i);
2302 3408580 : for (j=0; j<=i && j<=dz; j++)
2303 2434180 : p1 = F2x_add(p1, F2x_mul(gel(z,j),gel(y,i-j)));
2304 974400 : gel(rem,i) = gc_uptoleaf(av, F2x_rem(p1, T));
2305 : }
2306 406574 : rem -= 2;
2307 406574 : guncloneNULL(lead);
2308 406574 : if (!sx) (void)F2xX_renormalize(rem, lr);
2309 406574 : if (pr == ONLY_REM) return gc_upto(av0,rem);
2310 35 : *pr = rem; return z-2;
2311 : }
2312 :
2313 : static GEN
2314 2423 : F2xX_recipspec(GEN x, long l, long n, long vs)
2315 : {
2316 : long i;
2317 2423 : GEN z = cgetg(n+2,t_POL);
2318 2423 : z[1] = 0; z += 2;
2319 139712 : for(i=0; i<l; i++)
2320 137289 : gel(z,n-i-1) = F2x_copy(gel(x,i));
2321 2423 : for( ; i<n; i++)
2322 0 : gel(z,n-i-1) = pol0_F2x(vs);
2323 2423 : return F2xX_renormalize(z-2,n+2);
2324 : }
2325 :
2326 : static GEN
2327 0 : F2xqX_invBarrett_basecase(GEN T, GEN Q)
2328 : {
2329 0 : long i, l=lg(T)-1, lr = l-1, k;
2330 0 : long sv=Q[1];
2331 0 : GEN r=cgetg(lr,t_POL); r[1]=T[1];
2332 0 : gel(r,2) = pol1_F2x(sv);
2333 0 : for (i=3;i<lr;i++)
2334 : {
2335 0 : pari_sp ltop=avma;
2336 0 : GEN u = gel(T,l-i+2);
2337 0 : for (k=3;k<i;k++)
2338 0 : u = F2x_add(u, F2xq_mul(gel(T,l-i+k),gel(r,k),Q));
2339 0 : gel(r,i) = gc_upto(ltop, u);
2340 : }
2341 0 : r = F2xX_renormalize(r,lr);
2342 0 : return r;
2343 : }
2344 :
2345 : /* Return new lgpol */
2346 : static long
2347 3337 : F2xX_lgrenormalizespec(GEN x, long lx)
2348 : {
2349 : long i;
2350 3526 : for (i = lx-1; i>=0; i--)
2351 3526 : if (lgpol(gel(x,i))) break;
2352 3337 : return i+1;
2353 : }
2354 :
2355 : static GEN
2356 45 : F2xqX_invBarrett_Newton(GEN S, GEN T)
2357 : {
2358 45 : pari_sp av = avma;
2359 45 : long nold, lx, lz, lq, l = degpol(S), i, lQ;
2360 45 : GEN q, y, z, x = cgetg(l+2, t_POL) + 2;
2361 45 : long dT = get_F2x_degree(T);
2362 45 : ulong mask = quadratic_prec_mask(l-2); /* assume l > 2 */
2363 5337 : for (i=0;i<l;i++) gel(x,i) = pol0_F2x(T[1]);
2364 45 : q = F2xX_recipspec(S+2,l+1,l+1,dT);
2365 45 : lQ = lgpol(q); q+=2;
2366 : /* We work on _spec_ FlxX's, all the l[xzq] below are lgpol's */
2367 :
2368 : /* initialize */
2369 45 : gel(x,0) = F2xq_inv(gel(q,0),T);
2370 45 : if (lQ>1 && F2x_degree(gel(q,1)) >= dT)
2371 0 : gel(q,1) = F2x_rem(gel(q,1), T);
2372 45 : if (lQ>1 && lgpol(gel(q,1)))
2373 38 : {
2374 38 : GEN u = gel(q, 1);
2375 38 : if (!F2x_equal1(gel(x,0))) u = F2xq_mul(u, F2xq_sqr(gel(x,0), T), T);
2376 38 : else u = F2x_copy(u);
2377 38 : gel(x,1) = u; lx = 2;
2378 : }
2379 : else
2380 7 : lx = 1;
2381 45 : nold = 1;
2382 367 : for (; mask > 1; )
2383 : { /* set x -= x(x*q - 1) + O(t^(nnew + 1)), knowing x*q = 1 + O(t^(nold+1)) */
2384 322 : long i, lnew, nnew = nold << 1;
2385 :
2386 322 : if (mask & 1) nnew--;
2387 322 : mask >>= 1;
2388 :
2389 322 : lnew = nnew + 1;
2390 322 : lq = F2xX_lgrenormalizespec(q, minss(lQ,lnew));
2391 322 : z = F2xqX_mulspec(x, q, T, lx, lq); /* FIXME: high product */
2392 322 : lz = lgpol(z); if (lz > lnew) lz = lnew;
2393 322 : z += 2;
2394 : /* subtract 1 [=>first nold words are 0]: renormalize so that z(0) != 0 */
2395 644 : for (i = nold; i < lz; i++) if (lgpol(gel(z,i))) break;
2396 322 : nold = nnew;
2397 322 : if (i >= lz) continue; /* z-1 = 0(t^(nnew + 1)) */
2398 :
2399 : /* z + i represents (x*q - 1) / t^i */
2400 322 : lz = F2xX_lgrenormalizespec (z+i, lz-i);
2401 322 : z = F2xqX_mulspec(x, z+i, T, lx, lz); /* FIXME: low product */
2402 322 : lz = lgpol(z); z += 2;
2403 322 : if (lz > lnew-i) lz = F2xX_lgrenormalizespec(z, lnew-i);
2404 :
2405 322 : lx = lz+ i;
2406 322 : y = x + i; /* x -= z * t^i, in place */
2407 5479 : for (i = 0; i < lz; i++) gel(y,i) = gel(z,i);
2408 : }
2409 45 : x -= 2; setlg(x, lx + 2); x[1] = S[1];
2410 45 : return gc_GEN(av, x);
2411 : }
2412 :
2413 : GEN
2414 45 : F2xqX_invBarrett(GEN T, GEN Q)
2415 : {
2416 45 : pari_sp ltop=avma;
2417 45 : long l=lg(T), v = varn(T);
2418 : GEN r;
2419 45 : GEN c = gel(T,l-1);
2420 45 : if (l<5) return pol_0(v);
2421 45 : if (l<=F2xqX_INVBARRETT_LIMIT)
2422 : {
2423 0 : if (!F2x_equal1(c))
2424 : {
2425 0 : GEN ci = F2xq_inv(c,Q);
2426 0 : T = F2xqX_F2xq_mul(T, ci, Q);
2427 0 : r = F2xqX_invBarrett_basecase(T,Q);
2428 0 : r = F2xqX_F2xq_mul(r,ci,Q);
2429 : } else
2430 0 : r = F2xqX_invBarrett_basecase(T,Q);
2431 : } else
2432 45 : r = F2xqX_invBarrett_Newton(T,Q);
2433 45 : return gc_upto(ltop, r);
2434 : }
2435 :
2436 : GEN
2437 219975 : F2xqX_get_red(GEN S, GEN T)
2438 : {
2439 219975 : if (typ(S)==t_POL && lg(S)>F2xqX_BARRETT_LIMIT)
2440 42 : retmkvec2(F2xqX_invBarrett(S, T), S);
2441 219933 : return S;
2442 : }
2443 :
2444 : /* Compute x mod S where 2 <= degpol(S) <= l+1 <= 2*(degpol(S)-1)
2445 : * * and mg is the Barrett inverse of S. */
2446 : static GEN
2447 1189 : F2xqX_divrem_Barrettspec(GEN x, long l, GEN mg, GEN S, GEN T, GEN *pr)
2448 : {
2449 : GEN q, r;
2450 1189 : long lt = degpol(S); /*We discard the leading term*/
2451 : long ld, lm, lT, lmg;
2452 1189 : ld = l-lt;
2453 1189 : lm = minss(ld, lgpol(mg));
2454 1189 : lT = F2xX_lgrenormalizespec(S+2,lt);
2455 1189 : lmg = F2xX_lgrenormalizespec(mg+2,lm);
2456 1189 : q = F2xX_recipspec(x+lt,ld,ld,0); /* q = rec(x) lq<=ld*/
2457 1189 : q = F2xqX_mulspec(q+2,mg+2,T,lgpol(q),lmg); /* q = rec(x) * mg lq<=ld+lm*/
2458 1189 : q = F2xX_recipspec(q+2,minss(ld,lgpol(q)),ld,0);/* q = rec (rec(x) * mg) lq<=ld*/
2459 1189 : if (!pr) return q;
2460 1186 : r = F2xqX_mulspec(q+2,S+2,T,lgpol(q),lT); /* r = q*pol lr<=ld+lt*/
2461 1186 : r = F2xX_addspec(x,r+2,lt,minss(lt,lgpol(r)));/* r = x - r lr<=lt */
2462 1186 : if (pr == ONLY_REM) return r;
2463 3 : *pr = r; return q;
2464 : }
2465 :
2466 : static GEN
2467 1186 : F2xqX_divrem_Barrett(GEN x, GEN mg, GEN S, GEN T, GEN *pr)
2468 : {
2469 1186 : GEN q = NULL, r = F2xqX_red(x, T);
2470 1186 : long l = lgpol(r), lt = degpol(S), lm = 2*lt-1, v = varn(S);
2471 : long i;
2472 1186 : if (l <= lt)
2473 : {
2474 0 : if (pr == ONLY_REM) return r;
2475 0 : if (pr == ONLY_DIVIDES) return signe(r)? NULL: pol_0(v);
2476 0 : if (pr) *pr = r;
2477 0 : return pol_0(v);
2478 : }
2479 1186 : if (lt <= 1)
2480 0 : return F2xqX_divrem_basecase(x,S,T,pr);
2481 1186 : if (pr != ONLY_REM && l>lm)
2482 : {
2483 3 : long vT = get_F2x_var(T);
2484 3 : q = cgetg(l-lt+2, t_POL); q[1] = S[1];
2485 375 : for (i=0;i<l-lt;i++) gel(q+2,i) = pol0_F2x(vT);
2486 : }
2487 1189 : while (l>lm)
2488 : {
2489 3 : GEN zr, zq = F2xqX_divrem_Barrettspec(r+2+l-lm,lm,mg,S,T,&zr);
2490 3 : long lz = lgpol(zr);
2491 3 : if (pr != ONLY_REM)
2492 : {
2493 3 : long lq = lgpol(zq);
2494 231 : for(i=0; i<lq; i++) gel(q+2+l-lm,i) = gel(zq,2+i);
2495 : }
2496 234 : for(i=0; i<lz; i++) gel(r+2+l-lm,i) = gel(zr,2+i);
2497 3 : l = l-lm+lz;
2498 : }
2499 1186 : if (pr == ONLY_REM)
2500 : {
2501 1183 : if (l > lt)
2502 1183 : r = F2xqX_divrem_Barrettspec(r+2,l,mg,S,T,ONLY_REM);
2503 : else
2504 0 : r = F2xX_renormalize(r, lg(r));
2505 1183 : setvarn(r, v); return F2xX_renormalize(r, lg(r));
2506 : }
2507 3 : if (l > lt)
2508 : {
2509 3 : GEN zq = F2xqX_divrem_Barrettspec(r+2,l,mg,S,T,pr? &r: NULL);
2510 3 : if (!q) q = zq;
2511 : else
2512 : {
2513 3 : long lq = lgpol(zq);
2514 147 : for(i=0; i<lq; i++) gel(q+2,i) = gel(zq,2+i);
2515 : }
2516 : }
2517 0 : else if (pr)
2518 0 : r = F2xX_renormalize(r, l+2);
2519 3 : setvarn(q, v); q = F2xX_renormalize(q, lg(q));
2520 3 : if (pr == ONLY_DIVIDES) return signe(r)? NULL: q;
2521 3 : if (pr) { setvarn(r, v); *pr = r; }
2522 3 : return q;
2523 : }
2524 :
2525 : GEN
2526 33229 : F2xqX_divrem(GEN x, GEN S, GEN T, GEN *pr)
2527 : {
2528 : GEN B, y;
2529 : long dy, dx, d;
2530 33229 : if (pr==ONLY_REM) return F2xqX_rem(x, S, T);
2531 33229 : y = get_F2xqX_red(S, &B);
2532 33229 : dy = degpol(y); dx = degpol(x); d = dx-dy;
2533 33229 : if (!B && d+3 < F2xqX_DIVREM_BARRETT_LIMIT)
2534 33226 : return F2xqX_divrem_basecase(x,y,T,pr);
2535 : else
2536 : {
2537 3 : pari_sp av=avma;
2538 3 : GEN mg = B? B: F2xqX_invBarrett(y, T);
2539 3 : GEN q = F2xqX_divrem_Barrett(x,mg,y,T,pr);
2540 3 : if (!q) return gc_NULL(av);
2541 3 : if (!pr || pr==ONLY_DIVIDES) return gc_GEN(av, q);
2542 0 : return gc_all(av,2,&q,pr);
2543 : }
2544 : }
2545 :
2546 : GEN
2547 750127 : F2xqX_rem(GEN x, GEN S, GEN T)
2548 : {
2549 750127 : GEN B, y = get_F2xqX_red(S, &B);
2550 750127 : long dy = degpol(y), dx = degpol(x), d = dx-dy;
2551 750127 : if (d < 0) return F2xqX_red(x, T);
2552 513184 : if (!B && d+3 < F2xqX_REM_BARRETT_LIMIT)
2553 512001 : return F2xqX_divrem_basecase(x,y, T, ONLY_REM);
2554 : else
2555 : {
2556 1183 : pari_sp av=avma;
2557 1183 : GEN mg = B? B: F2xqX_invBarrett(y, T);
2558 1183 : GEN r = F2xqX_divrem_Barrett(x, mg, y, T, ONLY_REM);
2559 1183 : return gc_upto(av, r);
2560 : }
2561 : }
2562 :
2563 : static GEN
2564 0 : F2xqX_addmulmul(GEN u, GEN v, GEN x, GEN y, GEN T)
2565 : {
2566 0 : return F2xX_add(F2xqX_mul(u, x, T),F2xqX_mul(v, y, T));
2567 : }
2568 :
2569 : INLINE GEN
2570 0 : F2xXn_red(GEN a, long n) { return FlxXn_red(a, n); }
2571 :
2572 : static GEN
2573 0 : F2xqXM_F2xqX_mul2(GEN M, GEN x, GEN y, GEN T)
2574 : {
2575 0 : GEN res = cgetg(3, t_COL);
2576 0 : gel(res, 1) = F2xqX_addmulmul(gcoeff(M,1,1), gcoeff(M,1,2), x, y, T);
2577 0 : gel(res, 2) = F2xqX_addmulmul(gcoeff(M,2,1), gcoeff(M,2,2), x, y, T);
2578 0 : return res;
2579 : }
2580 :
2581 : static GEN
2582 0 : F2xqXM_mul2(GEN A, GEN B, GEN T)
2583 : {
2584 0 : GEN A11=gcoeff(A,1,1),A12=gcoeff(A,1,2), B11=gcoeff(B,1,1),B12=gcoeff(B,1,2);
2585 0 : GEN A21=gcoeff(A,2,1),A22=gcoeff(A,2,2), B21=gcoeff(B,2,1),B22=gcoeff(B,2,2);
2586 0 : GEN M1 = F2xqX_mul(F2xX_add(A11,A22), F2xX_add(B11,B22), T);
2587 0 : GEN M2 = F2xqX_mul(F2xX_add(A21,A22), B11, T);
2588 0 : GEN M3 = F2xqX_mul(A11, F2xX_add(B12,B22), T);
2589 0 : GEN M4 = F2xqX_mul(A22, F2xX_add(B21,B11), T);
2590 0 : GEN M5 = F2xqX_mul(F2xX_add(A11,A12), B22, T);
2591 0 : GEN M6 = F2xqX_mul(F2xX_add(A21,A11), F2xX_add(B11,B12), T);
2592 0 : GEN M7 = F2xqX_mul(F2xX_add(A12,A22), F2xX_add(B21,B22), T);
2593 0 : GEN T1 = F2xX_add(M1,M4), T2 = F2xX_add(M7,M5);
2594 0 : GEN T3 = F2xX_add(M1,M2), T4 = F2xX_add(M3,M6);
2595 0 : retmkmat22(F2xX_add(T1,T2), F2xX_add(M3,M5),
2596 : F2xX_add(M2,M4), F2xX_add(T3,T4));
2597 : }
2598 :
2599 : /* Return [0,1;1,-q]*M */
2600 : static GEN
2601 0 : F2xqX_F2xqXM_qmul(GEN q, GEN M, GEN T)
2602 : {
2603 0 : GEN u = F2xqX_mul(gcoeff(M,2,1), q, T);
2604 0 : GEN v = F2xqX_mul(gcoeff(M,2,2), q, T);
2605 0 : retmkmat22(gcoeff(M,2,1), gcoeff(M,2,2),
2606 : F2xX_add(gcoeff(M,1,1), u), F2xX_add(gcoeff(M,1,2), v));
2607 : }
2608 :
2609 : static GEN
2610 0 : matid2_F2xXM(long v, long sv)
2611 0 : { retmkmat22(pol1_F2xX(v, sv),pol_0(v),pol_0(v),pol1_F2xX(v, sv)); }
2612 :
2613 : static GEN
2614 0 : matJ2_F2xXM(long v, long sv)
2615 0 : { retmkmat22(pol_0(v),pol1_F2xX(v, sv),pol1_F2xX(v, sv),pol_0(v)); }
2616 :
2617 : struct F2xqX_res
2618 : {
2619 : GEN res, lc;
2620 : long deg0, deg1;
2621 : };
2622 :
2623 : INLINE void
2624 0 : F2xqX_halfres_update(long da, long db, long dr, GEN T, struct F2xqX_res *res)
2625 : {
2626 0 : if (dr >= 0)
2627 : {
2628 0 : if (!F2x_equal1(res->lc))
2629 : {
2630 0 : res->lc = F2xq_powu(res->lc, da - dr, T);
2631 0 : res->res = F2xq_mul(res->res, res->lc, T);
2632 : }
2633 : } else
2634 : {
2635 0 : if (db == 0)
2636 : {
2637 0 : if (!F2x_equal1(res->lc))
2638 : {
2639 0 : res->lc = F2xq_powu(res->lc, da, T);
2640 0 : res->res = F2xq_mul(res->res, res->lc, T);
2641 : }
2642 : } else
2643 0 : res->res = pol0_F2x(get_F2x_var(T));
2644 : }
2645 0 : }
2646 :
2647 : static GEN
2648 7 : F2xqX_halfres_basecase(GEN a, GEN b, GEN T, GEN *pa, GEN *pb, struct F2xqX_res *res)
2649 : {
2650 7 : pari_sp av=avma;
2651 : GEN u,u1,v,v1, M;
2652 7 : long vx = varn(a), vT = get_F2x_var(T), n = lgpol(a)>>1;
2653 7 : u1 = v = pol_0(vx);
2654 7 : u = v1 = pol1_F2xX(vx, vT);
2655 7 : while (lgpol(b)>n)
2656 : {
2657 : GEN r, q;
2658 0 : q = F2xqX_divrem(a,b, T, &r);
2659 0 : if (res)
2660 : {
2661 0 : long da = degpol(a), db = degpol(b), dr = degpol(r);
2662 0 : res->lc = gel(b,db+2);
2663 0 : if (dr >= n)
2664 0 : F2xqX_halfres_update(da, db, dr, T, res);
2665 : else
2666 : {
2667 0 : res->deg0 = da;
2668 0 : res->deg1 = db;
2669 : }
2670 : }
2671 0 : a = b; b = r; swap(u,u1); swap(v,v1);
2672 0 : u1 = F2xX_add(u1, F2xqX_mul(u, q, T));
2673 0 : v1 = F2xX_add(v1, F2xqX_mul(v, q, T));
2674 0 : if (gc_needed(av,2))
2675 : {
2676 0 : if (DEBUGMEM>1) pari_warn(warnmem,"F2xqX_halfgcd (d = %ld)",degpol(b));
2677 0 : if (res)
2678 0 : (void)gc_all(av, 8, &a,&b,&u1,&v1,&u,&v,&res->res,&res->lc);
2679 : else
2680 0 : (void)gc_all(av, 6, &a,&b,&u1,&v1,&u,&v);
2681 : }
2682 : }
2683 7 : M = mkmat22(u,v,u1,v1); *pa = a; *pb = b;
2684 0 : return res ? gc_all(av, 5, &M, pa, pb, &res->res, &res->lc)
2685 7 : : gc_all(av, 3, &M, pa, pb);
2686 : }
2687 :
2688 : static GEN F2xqX_halfres_i(GEN x, GEN y, GEN T, GEN *a, GEN *b, struct F2xqX_res *res);
2689 :
2690 : static GEN
2691 0 : F2xqX_halfres_split(GEN x, GEN y, GEN T, GEN *a, GEN *b, struct F2xqX_res *res)
2692 : {
2693 0 : pari_sp av = avma;
2694 : GEN Q, R, S, V1, V2;
2695 : GEN x1, y1, r, q;
2696 0 : long l = lgpol(x), n = l>>1, k, vT = get_F2x_var(T);
2697 0 : if (lgpol(y) <= n)
2698 0 : { *a = RgX_copy(x); *b = RgX_copy(y); return matid2_F2xXM(varn(x),vT); }
2699 0 : if (res)
2700 : {
2701 0 : res->lc = leading_coeff(y);
2702 0 : res->deg0 -= n;
2703 0 : res->deg1 -= n;
2704 : }
2705 0 : R = F2xqX_halfres_i(F2xX_shift(x,-n, vT),F2xX_shift(y,-n, vT), T, a, b, res);
2706 0 : if (res)
2707 : {
2708 0 : res->deg0 += n;
2709 0 : res->deg1 += n;
2710 : }
2711 0 : V1 = F2xqXM_F2xqX_mul2(R, Flxn_red(x,n), Flxn_red(y,n), T);
2712 0 : x1 = F2xX_add(F2xX_shift(*a,n,vT), gel(V1,1));
2713 0 : y1 = F2xX_add(F2xX_shift(*b,n,vT), gel(V1,2));
2714 0 : if (lgpol(y1) <= n)
2715 : {
2716 0 : *a = x1; *b = y1;
2717 0 : return res ? gc_all(av, 5, &R, a, b, &res->res, &res->lc)
2718 0 : : gc_all(av, 3, &R, a, b, &res->res, &res->lc);
2719 : }
2720 0 : k = 2*n-degpol(y1);
2721 0 : q = F2xqX_divrem(x1, y1, T, &r);
2722 0 : if (res)
2723 : {
2724 0 : long dx1 = degpol(x1), dy1 = degpol(y1), dr = degpol(r);
2725 0 : if (dy1 < degpol(y))
2726 0 : F2xqX_halfres_update(res->deg0, res->deg1, dy1, T, res);
2727 0 : res->lc = leading_coeff(y1);
2728 0 : res->deg0 = dx1;
2729 0 : res->deg1 = dy1;
2730 0 : if (dr >= n)
2731 : {
2732 0 : F2xqX_halfres_update(dx1, dy1, dr, T, res);
2733 0 : res->deg0 = dy1;
2734 0 : res->deg1 = dr;
2735 : }
2736 0 : res->deg0 -= k;
2737 0 : res->deg1 -= k;
2738 : }
2739 0 : S = F2xqX_halfres_i(F2xX_shift(y1,-k, vT), F2xX_shift(r,-k, vT), T, a, b, res);
2740 0 : if (res)
2741 : {
2742 0 : res->deg0 += k;
2743 0 : res->deg1 += k;
2744 : }
2745 0 : Q = F2xqXM_mul2(S,F2xqX_F2xqXM_qmul(q, R, T), T);
2746 0 : V2 = F2xqXM_F2xqX_mul2(S, F2xXn_red(y1,k), F2xXn_red(r,k), T);
2747 0 : *a = F2xX_add(F2xX_shift(*a,k,vT), gel(V2,1));
2748 0 : *b = F2xX_add(F2xX_shift(*b,k,vT), gel(V2,2));
2749 0 : return res ? gc_all(av, 5, &Q, a, b, &res->res, &res->lc)
2750 0 : : gc_all(av, 3, &Q, a, b, &res->res, &res->lc);
2751 : }
2752 :
2753 : static GEN
2754 7 : F2xqX_halfres_i(GEN x, GEN y, GEN T, GEN *a, GEN *b, struct F2xqX_res *res)
2755 : {
2756 7 : if (lgpol(x) < F2xqX_HALFGCD_LIMIT)
2757 7 : return F2xqX_halfres_basecase(x, y, T, a, b, res);
2758 0 : return F2xqX_halfres_split(x, y, T, a, b, res);
2759 : }
2760 :
2761 : static GEN
2762 7 : F2xqX_halfgcd_all_i(GEN x, GEN y, GEN T, GEN *pa, GEN *pb)
2763 : {
2764 : GEN a, b;
2765 7 : GEN R = F2xqX_halfres_i(x, y, T, &a, &b, NULL);
2766 7 : if (pa) *pa = a;
2767 7 : if (pb) *pb = b;
2768 7 : return R;
2769 : }
2770 :
2771 : /* Return M in GL_2(F_2[X]/(T)[Y]) such that:
2772 : if [a',b']~=M*[a,b]~ then degpol(a')>= (lgpol(a)>>1) >degpol(b')
2773 : */
2774 :
2775 : GEN
2776 7 : F2xqX_halfgcd_all(GEN x, GEN y, GEN T, GEN *a, GEN *b)
2777 : {
2778 7 : pari_sp av = avma;
2779 : GEN R,q,r;
2780 7 : if (!signe(x))
2781 : {
2782 0 : if (a) *a = RgX_copy(y);
2783 0 : if (b) *b = RgX_copy(x);
2784 0 : return matJ2_F2xXM(varn(x), get_F2x_var(T));
2785 : }
2786 7 : if (degpol(y)<degpol(x)) return F2xqX_halfgcd_all_i(x, y, T, a, b);
2787 7 : q = F2xqX_divrem(y, x, T, &r);
2788 7 : R = F2xqX_halfgcd_all_i(x, r, T, a, b);
2789 7 : gcoeff(R,1,1) = F2xX_add(gcoeff(R,1,1), F2xqX_mul(q, gcoeff(R,1,2), T));
2790 7 : gcoeff(R,2,1) = F2xX_add(gcoeff(R,2,1), F2xqX_mul(q, gcoeff(R,2,2), T));
2791 7 : return !a && b ? gc_all(av, 2, &R, b): gc_all(av, 1+!!a+!!b, &R, a, b);
2792 : }
2793 :
2794 : GEN
2795 0 : F2xqX_halfgcd(GEN x, GEN y, GEN T)
2796 0 : { return F2xqX_halfgcd_all(x, y, T, NULL, NULL); }
2797 :
2798 : static GEN
2799 169365 : F2xqX_gcd_basecase(GEN a, GEN b, GEN T)
2800 : {
2801 169365 : pari_sp av = avma, av0=avma;
2802 697921 : while (signe(b))
2803 : {
2804 : GEN c;
2805 528556 : if (gc_needed(av0,2))
2806 : {
2807 0 : if (DEBUGMEM>1) pari_warn(warnmem,"F2xqX_gcd (d = %ld)",degpol(b));
2808 0 : (void)gc_all(av0,2, &a,&b);
2809 : }
2810 528556 : av = avma; c = F2xqX_rem(a, b, T); a=b; b=c;
2811 : }
2812 169365 : return gc_const(av, a);
2813 : }
2814 :
2815 : GEN
2816 169750 : F2xqX_gcd(GEN x, GEN y, GEN T)
2817 : {
2818 169750 : pari_sp av = avma;
2819 169750 : x = F2xqX_red(x, T);
2820 169750 : y = F2xqX_red(y, T);
2821 169750 : if (!signe(x)) return gc_upto(av, y);
2822 169365 : while (lgpol(y)>=F2xqX_GCD_LIMIT)
2823 : {
2824 0 : if (lgpol(y)<=(lgpol(x)>>1))
2825 : {
2826 0 : GEN r = F2xqX_rem(x, y, T);
2827 0 : x = y; y = r;
2828 : }
2829 0 : (void) F2xqX_halfgcd_all(x, y, T, &x, &y);
2830 0 : if (gc_needed(av,2))
2831 : {
2832 0 : if (DEBUGMEM>1) pari_warn(warnmem,"F2xqX_gcd (y = %ld)",degpol(y));
2833 0 : (void)gc_all(av,2,&x,&y);
2834 : }
2835 : }
2836 169365 : return gc_upto(av, F2xqX_gcd_basecase(x, y, T));
2837 : }
2838 :
2839 : static GEN
2840 14 : F2xqX_extgcd_basecase(GEN a, GEN b, GEN T, GEN *ptu, GEN *ptv)
2841 : {
2842 14 : pari_sp av=avma;
2843 : GEN u,v,d,d1,v1;
2844 14 : long vx = varn(a);
2845 14 : d = a; d1 = b;
2846 14 : v = pol_0(vx); v1 = pol1_F2xX(vx, get_F2x_var(T));
2847 63 : while (signe(d1))
2848 : {
2849 49 : GEN r, q = F2xqX_divrem(d, d1, T, &r);
2850 49 : v = F2xX_add(v,F2xqX_mul(q,v1,T));
2851 49 : u=v; v=v1; v1=u;
2852 49 : u=r; d=d1; d1=u;
2853 49 : if (gc_needed(av,2))
2854 : {
2855 0 : if (DEBUGMEM>1) pari_warn(warnmem,"F2xqX_extgcd (d = %ld)",degpol(d));
2856 0 : (void)gc_all(av,5, &d,&d1,&u,&v,&v1);
2857 : }
2858 : }
2859 14 : if (ptu) *ptu = F2xqX_div(F2xX_add(d,F2xqX_mul(b,v, T)), a, T);
2860 14 : *ptv = v; return d;
2861 : }
2862 :
2863 : static GEN
2864 0 : F2xqX_extgcd_halfgcd(GEN x, GEN y, GEN T, GEN *ptu, GEN *ptv)
2865 : {
2866 : GEN u,v;
2867 0 : GEN V = cgetg(expu(lgpol(y))+2,t_VEC);
2868 0 : long i, n = 0, vs = varn(x), vT = get_F2x_var(T);
2869 0 : while (lgpol(y)>=F2xqX_EXTGCD_LIMIT)
2870 : {
2871 0 : if (lgpol(y)<=(lgpol(x)>>1))
2872 : {
2873 0 : GEN r, q = F2xqX_divrem(x, y, T, &r);
2874 0 : x = y; y = r;
2875 0 : gel(V,++n) = mkmat22(pol_0(vs),pol1_F2xX(vs,vT),pol1_F2xX(vs,vT),RgX_copy(q));
2876 : } else
2877 0 : gel(V,++n) = F2xqX_halfgcd_all(x, y, T, &x, &y);
2878 : }
2879 0 : y = F2xqX_extgcd_basecase(x,y, T, &u,&v);
2880 0 : for (i = n; i>1; i--)
2881 : {
2882 0 : GEN R = gel(V,i);
2883 0 : GEN u1 = F2xqX_addmulmul(u, v, gcoeff(R,1,1), gcoeff(R,2,1), T);
2884 0 : GEN v1 = F2xqX_addmulmul(u, v, gcoeff(R,1,2), gcoeff(R,2,2), T);
2885 0 : u = u1; v = v1;
2886 : }
2887 : {
2888 0 : GEN R = gel(V,1);
2889 0 : if (ptu)
2890 0 : *ptu = F2xqX_addmulmul(u, v, gcoeff(R,1,1), gcoeff(R,2,1), T);
2891 0 : *ptv = F2xqX_addmulmul(u, v, gcoeff(R,1,2), gcoeff(R,2,2), T);
2892 : }
2893 0 : return y;
2894 : }
2895 :
2896 : /* x and y in Z[Y][X], return lift(gcd(x mod T,p, y mod T,p)). Set u and v st
2897 : * ux + vy = gcd (mod T,p) */
2898 : GEN
2899 14 : F2xqX_extgcd(GEN x, GEN y, GEN T, GEN *ptu, GEN *ptv)
2900 : {
2901 14 : pari_sp av = avma;
2902 : GEN d;
2903 14 : x = F2xqX_red(x, T);
2904 14 : y = F2xqX_red(y, T);
2905 14 : if (lgpol(y)>=F2xqX_EXTGCD_LIMIT)
2906 0 : d = F2xqX_extgcd_halfgcd(x, y, T, ptu, ptv);
2907 : else
2908 14 : d = F2xqX_extgcd_basecase(x, y, T, ptu, ptv);
2909 14 : return gc_all(av, ptu?3:2, &d, ptv, ptu);
2910 : }
2911 :
2912 : static GEN
2913 0 : F2xqX_halfres(GEN x, GEN y, GEN T, GEN *a, GEN *b, GEN *r)
2914 : {
2915 : struct F2xqX_res res;
2916 : GEN V;
2917 : long dB;
2918 :
2919 0 : res.res = *r;
2920 0 : res.lc = leading_coeff(y);
2921 0 : res.deg0 = degpol(x);
2922 0 : res.deg1 = degpol(y);
2923 0 : V = F2xqX_halfres_i(x, y, T, a, b, &res);
2924 0 : dB = degpol(*b);
2925 0 : if (dB < degpol(y))
2926 0 : F2xqX_halfres_update(res.deg0, res.deg1, dB, T, &res);
2927 0 : *r = res.res;
2928 0 : return V;
2929 : }
2930 :
2931 : /* Res(A,B) = Res(B,R) * lc(B)^(a-r) * (-1)^(ab), with R=A%B, a=deg(A) ...*/
2932 : static GEN
2933 21 : F2xqX_resultant_basecase(GEN a, GEN b, GEN T)
2934 : {
2935 21 : pari_sp av = avma;
2936 21 : long vT = get_F2x_var(T), da,db,dc;
2937 21 : GEN c,lb, res = pol1_F2x(vT);
2938 :
2939 21 : if (!signe(a) || !signe(b)) return pol0_F2x(vT);
2940 :
2941 21 : da = degpol(a);
2942 21 : db = degpol(b);
2943 21 : if (db > da)
2944 0 : swapspec(a,b, da,db);
2945 21 : if (!da) return pol1_F2x(vT); /* = res * a[2] ^ db, since 0 <= db <= da = 0 */
2946 49 : while (db)
2947 : {
2948 28 : lb = gel(b,db+2);
2949 28 : c = F2xqX_rem(a,b, T);
2950 28 : a = b; b = c; dc = degpol(c);
2951 28 : if (dc < 0) { set_avma(av); return pol0_F2x(vT); }
2952 :
2953 28 : if (!equali1(lb)) res = F2xq_mul(res, F2xq_powu(lb, da - dc, T), T);
2954 28 : if (gc_needed(av,2))
2955 : {
2956 0 : if (DEBUGMEM>1) pari_warn(warnmem,"F2xqX_resultant (da = %ld)",da);
2957 0 : (void)gc_all(av,3, &a,&b,&res);
2958 : }
2959 28 : da = db; /* = degpol(a) */
2960 28 : db = dc; /* = degpol(b) */
2961 : }
2962 21 : res = F2xq_mul(res, F2xq_powu(gel(b,2), da, T), T);
2963 21 : return gc_upto(av, res);
2964 : }
2965 :
2966 : /* Res(A,B) = Res(B,R) * lc(B)^(a-r) * (-1)^(ab), with R=A%B, a=deg(A) ...*/
2967 : GEN
2968 21 : F2xqX_resultant(GEN x, GEN y, GEN T)
2969 : {
2970 21 : pari_sp av = avma;
2971 21 : long dx, dy, vT = get_F2x_var(T);
2972 21 : GEN res = pol1_F2x(vT);
2973 21 : if (!signe(x) || !signe(y)) return pol0_F2x(vT);
2974 21 : dx = degpol(x); dy = degpol(y);
2975 21 : if (dx < dy)
2976 7 : swap(x,y);
2977 21 : while (lgpol(y) >= F2xqX_GCD_LIMIT)
2978 : {
2979 0 : if (lgpol(y)<=(lgpol(x)>>1))
2980 : {
2981 0 : GEN r = F2xqX_rem(x, y, T);
2982 0 : long dx = degpol(x), dy = degpol(y), dr = degpol(r);
2983 0 : GEN ly = gel(y,dy+2);
2984 0 : if (!F2x_equal1(ly))
2985 0 : res = F2xq_mul(res, F2xq_powu(ly, dx - dr, T), T);
2986 0 : x = y; y = r;
2987 : }
2988 0 : (void) F2xqX_halfres(x, y, T, &x, &y, &res);
2989 0 : if (gc_needed(av,2))
2990 : {
2991 0 : if (DEBUGMEM>1) pari_warn(warnmem,"F2xqX_resultant (y = %ld)",degpol(y));
2992 0 : (void)gc_all(av,3,&x,&y,&res);
2993 : }
2994 : }
2995 21 : res = F2xq_mul(res, F2xqX_resultant_basecase(x, y, T), T);
2996 21 : return gc_upto(av, res);
2997 : }
2998 :
2999 : /* disc P = (-1)^(n(n-1)/2) lc(P)^(n - deg P' - 2) Res(P,P'), n = deg P */
3000 : GEN
3001 14 : F2xqX_disc(GEN P, GEN T)
3002 : {
3003 14 : pari_sp av = avma;
3004 14 : GEN L, dP = F2xX_deriv(P), D = F2xqX_resultant(P, dP, T);
3005 : long dd;
3006 14 : if (!lgpol(D)) return pol_0(get_F2x_var(T));
3007 14 : dd = degpol(P) - 2 - degpol(dP); /* >= -1; > -1 iff p | deg(P) */
3008 14 : L = leading_coeff(P);
3009 14 : if (dd && !F2x_equal1(L))
3010 0 : D = (dd == -1)? F2xq_div(D,L,T): F2xq_mul(D, F2xq_powu(L, dd, T), T);
3011 14 : return gc_upto(av, D);
3012 : }
3013 :
3014 : /***********************************************************************/
3015 : /** **/
3016 : /** F2xqXQ **/
3017 : /** **/
3018 : /***********************************************************************/
3019 :
3020 : GEN
3021 114240 : F2xqXQ_mul(GEN x, GEN y, GEN S, GEN T) {
3022 114240 : return F2xqX_rem(F2xqX_mul(x,y,T),S,T);
3023 : }
3024 :
3025 : GEN
3026 104279 : F2xqXQ_sqr(GEN x, GEN S, GEN T) {
3027 104279 : return F2xqX_rem(F2xqX_sqr(x,T),S,T);
3028 : }
3029 :
3030 : GEN
3031 7 : F2xqXQ_invsafe(GEN x, GEN S, GEN T)
3032 : {
3033 7 : GEN V, z = F2xqX_extgcd(get_F2xqX_mod(S), x, T, NULL, &V);
3034 7 : if (degpol(z)) return NULL;
3035 7 : z = F2xq_invsafe(gel(z,2),T);
3036 7 : if (!z) return NULL;
3037 7 : return F2xqX_F2xq_mul(V, z, T);
3038 : }
3039 :
3040 : GEN
3041 7 : F2xqXQ_inv(GEN x, GEN S, GEN T)
3042 : {
3043 7 : pari_sp av = avma;
3044 7 : GEN U = F2xqXQ_invsafe(x, S, T);
3045 7 : if (!U) pari_err_INV("F2xqXQ_inv",x);
3046 7 : return gc_upto(av, U);
3047 : }
3048 :
3049 : struct _F2xqXQ {
3050 : GEN T, S;
3051 : };
3052 :
3053 : static GEN
3054 345030 : _F2xqXQ_add(void *data, GEN x, GEN y) {
3055 : (void) data;
3056 345030 : return F2xX_add(x,y);
3057 : }
3058 : static GEN
3059 481488 : _F2xqXQ_cmul(void *data, GEN P, long a, GEN x) {
3060 : (void) data;
3061 481488 : return F2xX_F2x_mul(x,gel(P,a+2));
3062 : }
3063 : static GEN
3064 351246 : _F2xqXQ_red(void *data, GEN x) {
3065 351246 : struct _F2xqXQ *d = (struct _F2xqXQ*) data;
3066 351246 : return F2xqX_red(x, d->T);
3067 : }
3068 : static GEN
3069 114184 : _F2xqXQ_mul(void *data, GEN x, GEN y) {
3070 114184 : struct _F2xqXQ *d = (struct _F2xqXQ*) data;
3071 114184 : return F2xqXQ_mul(x,y, d->S,d->T);
3072 : }
3073 : static GEN
3074 33250 : _F2xqXQ_sqr(void *data, GEN x) {
3075 33250 : struct _F2xqXQ *d = (struct _F2xqXQ*) data;
3076 33250 : return F2xqXQ_sqr(x, d->S,d->T);
3077 : }
3078 : static GEN
3079 7 : _F2xqXQ_zero(void *data) {
3080 7 : struct _F2xqXQ *d = (struct _F2xqXQ*) data;
3081 7 : return pol_0(get_F2xqX_var(d->S));
3082 : }
3083 : static GEN
3084 374773 : _F2xqXQ_one(void *data) {
3085 374773 : struct _F2xqXQ *d = (struct _F2xqXQ*) data;
3086 374773 : return pol1_F2xX(get_F2xqX_var(d->S),get_F2x_var(d->T));
3087 : }
3088 :
3089 : static struct bb_algebra F2xqXQ_algebra = { _F2xqXQ_red,
3090 : _F2xqXQ_add, _F2xqXQ_add, _F2xqXQ_mul,_F2xqXQ_sqr,_F2xqXQ_one,_F2xqXQ_zero };
3091 :
3092 : GEN
3093 7 : F2xqXQ_pow(GEN x, GEN n, GEN S, GEN T)
3094 : {
3095 : struct _F2xqXQ D;
3096 7 : long s = signe(n);
3097 7 : if (!s) return pol1_F2xX(get_F2xqX_var(S), get_F2x_var(T));
3098 7 : if (s < 0) x = F2xqXQ_inv(x,S,T);
3099 7 : if (is_pm1(n)) return s < 0 ? x : gcopy(x);
3100 7 : if (degpol(x) >= get_F2xqX_degree(S)) x = F2xqX_rem(x,S,T);
3101 7 : D.T = F2x_get_red(T);
3102 7 : D.S = F2xqX_get_red(S, T);
3103 7 : return gen_pow(x, n, (void*)&D, &_F2xqXQ_sqr, &_F2xqXQ_mul);
3104 : }
3105 :
3106 : GEN
3107 7714 : F2xqXQ_powers(GEN x, long l, GEN S, GEN T)
3108 : {
3109 : struct _F2xqXQ D;
3110 7714 : int use_sqr = 2*degpol(x) >= get_F2xqX_degree(S);
3111 7714 : D.T = F2x_get_red(T);
3112 7714 : D.S = F2xqX_get_red(S, T);
3113 7714 : return gen_powers(x, l, use_sqr, (void*)&D, &_F2xqXQ_sqr, &_F2xqXQ_mul,&_F2xqXQ_one);
3114 : }
3115 :
3116 : GEN
3117 14413 : F2xqX_F2xqXQV_eval(GEN P, GEN V, GEN S, GEN T)
3118 : {
3119 : struct _F2xqXQ D;
3120 14413 : D.T = F2x_get_red(T);
3121 14413 : D.S = F2xqX_get_red(S, T);
3122 14413 : return gen_bkeval_powers(P, degpol(P), V, (void*)&D, &F2xqXQ_algebra,
3123 : _F2xqXQ_cmul);
3124 : }
3125 :
3126 : GEN
3127 122052 : F2xqX_F2xqXQ_eval(GEN Q, GEN x, GEN S, GEN T)
3128 : {
3129 : struct _F2xqXQ D;
3130 122052 : int use_sqr = 2*degpol(x) >= get_F2xqX_degree(S);
3131 122052 : D.T = F2x_get_red(T);
3132 122052 : D.S = F2xqX_get_red(S, T);
3133 122052 : return gen_bkeval(Q, degpol(Q), x, use_sqr, (void*)&D, &F2xqXQ_algebra,
3134 : _F2xqXQ_cmul);
3135 : }
3136 :
3137 : static GEN
3138 88809 : F2xqXQ_autpow_sqr(void * E, GEN x)
3139 : {
3140 88809 : struct _F2xqXQ *D = (struct _F2xqXQ *)E;
3141 88809 : GEN T = D->T;
3142 88809 : GEN phi = gel(x,1), S = gel(x,2);
3143 88809 : long n = brent_kung_optpow(get_F2x_degree(T)-1,lgpol(S)+1,1);
3144 88809 : GEN V = F2xq_powers(phi, n, T);
3145 88809 : GEN phi2 = F2x_F2xqV_eval(phi, V, T);
3146 88809 : GEN Sphi = F2xY_F2xqV_evalx(S, V, T);
3147 88809 : GEN S2 = F2xqX_F2xqXQ_eval(Sphi, S, D->S, T);
3148 88809 : return mkvec2(phi2, S2);
3149 : }
3150 :
3151 : static GEN
3152 33243 : F2xqXQ_autpow_mul(void * E, GEN x, GEN y)
3153 : {
3154 33243 : struct _F2xqXQ *D = (struct _F2xqXQ *)E;
3155 33243 : GEN T = D->T;
3156 33243 : GEN phi1 = gel(x,1), S1 = gel(x,2);
3157 33243 : GEN phi2 = gel(y,1), S2 = gel(y,2);
3158 33243 : long n = brent_kung_optpow(get_F2x_degree(T)-1,lgpol(S1)+1,1);
3159 33243 : GEN V = F2xq_powers(phi2, n, T);
3160 33243 : GEN phi3 = F2x_F2xqV_eval(phi1,V,T);
3161 33243 : GEN Sphi = F2xY_F2xqV_evalx(S1,V,T);
3162 33243 : GEN S3 = F2xqX_F2xqXQ_eval(Sphi, S2, D->S, T);
3163 33243 : return mkvec2(phi3, S3);
3164 : }
3165 :
3166 : GEN
3167 70434 : F2xqXQ_autpow(GEN aut, long n, GEN S, GEN T)
3168 : {
3169 : struct _F2xqXQ D;
3170 70434 : D.T = F2x_get_red(T);
3171 70434 : D.S = F2xqX_get_red(S, T);
3172 70434 : return gen_powu(aut,n,&D,F2xqXQ_autpow_sqr,F2xqXQ_autpow_mul);
3173 : }
3174 :
3175 : static GEN
3176 7182 : F2xqXQ_auttrace_mul(void *E, GEN x, GEN y)
3177 : {
3178 7182 : struct _F2xqXQ *D = (struct _F2xqXQ *) E;
3179 7182 : GEN T = D->T;
3180 7182 : GEN phi1 = gel(x,1), S1 = gel(x,2), a1 = gel(x,3);
3181 7182 : GEN phi2 = gel(y,1), S2 = gel(y,2), a2 = gel(y,3);
3182 7182 : long n2 = brent_kung_optpow(get_F2x_degree(T)-1, lgpol(S1)+lgpol(a1)+1, 1);
3183 7182 : GEN V2 = F2xq_powers(phi2, n2, T);
3184 7182 : GEN phi3 = F2x_F2xqV_eval(phi1, V2, T);
3185 7182 : GEN Sphi = F2xY_F2xqV_evalx(S1, V2, T);
3186 7182 : GEN aphi = F2xY_F2xqV_evalx(a1, V2, T);
3187 7182 : long n = brent_kung_optpow(maxss(degpol(Sphi),degpol(aphi)),2,1);
3188 7182 : GEN V = F2xqXQ_powers(S2, n, D->S, T);
3189 7182 : GEN S3 = F2xqX_F2xqXQV_eval(Sphi, V, D->S, T);
3190 7182 : GEN aS = F2xqX_F2xqXQV_eval(aphi, V, D->S, T);
3191 7182 : GEN a3 = F2xX_add(aS, a2);
3192 7182 : return mkvec3(phi3, S3, a3);
3193 : }
3194 :
3195 : static GEN
3196 4893 : F2xqXQ_auttrace_sqr(void *E, GEN x) { return F2xqXQ_auttrace_mul(E, x, x); }
3197 : GEN
3198 2723 : F2xqXQ_auttrace(GEN aut, long n, GEN S, GEN T)
3199 : {
3200 : struct _F2xqXQ D;
3201 2723 : D.T = F2x_get_red(T);
3202 2723 : D.S = F2xqX_get_red(S, T);
3203 2723 : return gen_powu(aut,n,&D,F2xqXQ_auttrace_sqr,F2xqXQ_auttrace_mul);
3204 : }
3205 :
3206 : GEN
3207 63 : F2xqXQV_red(GEN x, GEN S, GEN T)
3208 273 : { pari_APPLY_type(t_VEC, F2xqX_rem(gel(x,i), S, T)) }
|
