Line data Source code
1 : /* Copyright (C) 2004 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. It is distributed in the hope that it will be useful, but WITHOUT
8 : ANY WARRANTY WHATSOEVER.
9 :
10 : Check the License for details. You should have received a copy of it, along
11 : with the package; see the file 'COPYING'. If not, write to the Free Software
12 : Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
13 :
14 : #include "pari.h"
15 : #include "paripriv.h"
16 :
17 : /* Not so fast arithmetic with polynomials with small coefficients. */
18 :
19 : static GEN
20 578889053 : get_Flx_red(GEN T, GEN *B)
21 : {
22 578889053 : if (typ(T)!=t_VEC) { *B=NULL; return T; }
23 3816295 : *B = gel(T,1); return gel(T,2);
24 : }
25 :
26 : /***********************************************************************/
27 : /** **/
28 : /** Flx **/
29 : /** **/
30 : /***********************************************************************/
31 : /* Flx objects are defined as follows:
32 : Let l an ulong. An Flx is a t_VECSMALL:
33 : x[0] = codeword
34 : x[1] = evalvarn(variable number) (signe is not stored).
35 : x[2] = a_0 x[3] = a_1, etc.
36 : With 0 <= a_i < l
37 :
38 : signe(x) is not valid. Use degpol(x)>=0 instead.
39 : */
40 : /***********************************************************************/
41 : /** **/
42 : /** Conversion from Flx **/
43 : /** **/
44 : /***********************************************************************/
45 :
46 : GEN
47 43175500 : Flx_to_ZX(GEN z)
48 : {
49 43175500 : long i, l = lg(z);
50 43175500 : GEN x = cgetg(l,t_POL);
51 43175596 : for (i=2; i<l; i++) gel(x,i) = utoi(z[i]);
52 43175468 : x[1] = evalsigne(l-2!=0)| z[1]; return x;
53 : }
54 :
55 : GEN
56 26341 : Flx_to_FlxX(GEN z, long sv)
57 : {
58 26341 : long i, l = lg(z);
59 26341 : GEN x = cgetg(l,t_POL);
60 26341 : for (i=2; i<l; i++) gel(x,i) = Fl_to_Flx(z[i], sv);
61 26341 : x[1] = evalsigne(l-2!=0)| z[1]; return x;
62 : }
63 :
64 : GEN
65 128169 : Flv_to_ZV(GEN x)
66 128169 : { pari_APPLY_type(t_VEC, utoi(x[i])) }
67 :
68 : GEN
69 20857212 : Flc_to_ZC(GEN x)
70 20857212 : { pari_APPLY_type(t_COL, utoi(x[i])) }
71 :
72 : GEN
73 8330422 : Flm_to_ZM(GEN x)
74 8330422 : { pari_APPLY_type(t_MAT, Flc_to_ZC(gel(x,i))) }
75 :
76 : GEN
77 123364 : Flc_to_ZC_inplace(GEN z)
78 : {
79 123364 : long i, l = lg(z);
80 123364 : for (i=1; i<l; i++) gel(z,i) = utoi(z[i]);
81 123364 : settyp(z, t_COL);
82 123364 : return z;
83 : }
84 :
85 : GEN
86 56166 : Flm_to_ZM_inplace(GEN z)
87 : {
88 56166 : long i, l = lg(z);
89 56166 : for (i=1; i<l; i++) Flc_to_ZC_inplace(gel(z, i));
90 56166 : return z;
91 : }
92 :
93 : /* same as Flx_to_ZX, in place */
94 : GEN
95 44364194 : Flx_to_ZX_inplace(GEN z)
96 : {
97 44364194 : long i, l = lg(z);
98 44364194 : for (i=2; i<l; i++) gel(z,i) = utoi(z[i]);
99 44364086 : settyp(z, t_POL); z[1]=evalsigne(l-2!=0)|z[1]; return z;
100 : }
101 :
102 : /*Flx_to_Flv=zx_to_zv*/
103 : GEN
104 3623926 : Flx_to_Flv(GEN x, long N)
105 : {
106 : long i, l;
107 3623926 : GEN z = cgetg(N+1,t_VECSMALL);
108 3623917 : if (typ(x) != t_VECSMALL) pari_err_TYPE("Flx_to_Flv",x);
109 3623924 : l = lg(x)-1; x++;
110 3623924 : for (i=1; i<l ; i++) z[i]=x[i];
111 3623924 : for ( ; i<=N; i++) z[i]=0;
112 3623924 : return z;
113 : }
114 :
115 : /*Flv_to_Flx=zv_to_zx*/
116 : GEN
117 133465 : Flv_to_Flx(GEN x, long sv)
118 : {
119 133465 : long i, l=lg(x)+1;
120 133465 : GEN z = cgetg(l,t_VECSMALL); z[1]=sv;
121 133465 : x--;
122 133465 : for (i=2; i<l ; i++) z[i]=x[i];
123 133465 : return Flx_renormalize(z,l);
124 : }
125 :
126 : /*Flm_to_FlxV=zm_to_zxV*/
127 : GEN
128 1596 : Flm_to_FlxV(GEN x, long sv)
129 1596 : { pari_APPLY_type(t_VEC, Flv_to_Flx(gel(x,i), sv)) }
130 :
131 : /*FlxC_to_ZXC=zxC_to_ZXC*/
132 : GEN
133 41386 : FlxC_to_ZXC(GEN x)
134 41386 : { pari_APPLY_type(t_COL, Flx_to_ZX(gel(x,i))) }
135 :
136 : /*FlxC_to_ZXC=zxV_to_ZXV*/
137 : GEN
138 161627 : FlxV_to_ZXV(GEN x)
139 161627 : { pari_APPLY_type(t_VEC, Flx_to_ZX(gel(x,i))) }
140 :
141 : /*FlxM_to_ZXM=zxM_to_ZXM*/
142 : GEN
143 4557 : FlxM_to_ZXM(GEN x)
144 4557 : { pari_APPLY_same(FlxC_to_ZXC(gel(x,i))) }
145 :
146 : GEN
147 0 : FlxM_Flx_add_shallow(GEN x, GEN y, ulong p)
148 : {
149 0 : long l = lg(x), i, j;
150 0 : GEN z = cgetg(l,t_MAT);
151 :
152 0 : if (l==1) return z;
153 0 : if (l != lgcols(x)) pari_err_OP( "+", x, y);
154 0 : for (i=1; i<l; i++)
155 : {
156 0 : GEN zi = cgetg(l,t_COL), xi = gel(x,i);
157 0 : gel(z,i) = zi;
158 0 : for (j=1; j<l; j++) gel(zi,j) = gel(xi,j);
159 0 : gel(zi,i) = Flx_add(gel(zi,i), y, p);
160 : }
161 0 : return z;
162 : }
163 :
164 : /***********************************************************************/
165 : /** **/
166 : /** Conversion to Flx **/
167 : /** **/
168 : /***********************************************************************/
169 : /* Take an integer and return a scalar polynomial mod p, with evalvarn=vs */
170 : GEN
171 9648857 : Fl_to_Flx(ulong x, long sv)
172 : {
173 9648857 : return x? mkvecsmall2(sv, x): pol0_Flx(sv);
174 : }
175 :
176 : /* a X^d */
177 : GEN
178 185996 : monomial_Flx(ulong a, long d, long vs)
179 : {
180 : GEN P;
181 185996 : if (a==0) return pol0_Flx(vs);
182 185996 : P = const_vecsmall(d+2, 0);
183 185996 : P[1] = vs; P[d+2] = a;
184 185996 : return P;
185 : }
186 :
187 : GEN
188 1076469 : Z_to_Flx(GEN x, ulong p, long sv)
189 : {
190 1076469 : long u = umodiu(x,p);
191 1076844 : return u? mkvecsmall2(sv, u): pol0_Flx(sv);
192 : }
193 :
194 : /* return x[0 .. dx] mod p as t_VECSMALL. Assume x a t_POL*/
195 : GEN
196 178807998 : ZX_to_Flx(GEN x, ulong p)
197 : {
198 178807998 : long i, lx = lg(x);
199 178807998 : GEN a = cgetg(lx, t_VECSMALL);
200 178810399 : a[1]=((ulong)x[1])&VARNBITS;
201 178810399 : for (i=2; i<lx; i++) a[i] = umodiu(gel(x,i), p);
202 178808063 : return Flx_renormalize(a,lx);
203 : }
204 :
205 : /* return x[0 .. dx] mod p as t_VECSMALL. Assume x a t_POL*/
206 : GEN
207 3723445 : zx_to_Flx(GEN x, ulong p)
208 : {
209 3723445 : long i, lx = lg(x);
210 3723445 : GEN a = cgetg(lx, t_VECSMALL);
211 3723445 : a[1] = x[1];
212 3723445 : for (i=2; i<lx; i++) uel(a,i) = umodsu(x[i], p);
213 3723445 : return Flx_renormalize(a,lx);
214 : }
215 :
216 : ulong
217 50881208 : Rg_to_Fl(GEN x, ulong p)
218 : {
219 50881208 : switch(typ(x))
220 : {
221 23972541 : case t_INT: return umodiu(x, p);
222 : case t_FRAC: {
223 32619 : ulong z = umodiu(gel(x,1), p);
224 32619 : if (!z) return 0;
225 29924 : return Fl_div(z, umodiu(gel(x,2), p), p);
226 : }
227 49 : case t_PADIC: return padic_to_Fl(x, p);
228 : case t_INTMOD: {
229 26875999 : GEN q = gel(x,1), a = gel(x,2);
230 26875999 : if (absequaliu(q, p)) return itou(a);
231 0 : if (!dvdiu(q,p)) pari_err_MODULUS("Rg_to_Fl", q, utoi(p));
232 0 : return umodiu(a, p);
233 : }
234 0 : default: pari_err_TYPE("Rg_to_Fl",x);
235 : return 0; /* LCOV_EXCL_LINE */
236 : }
237 : }
238 :
239 : ulong
240 1098164 : Rg_to_F2(GEN x)
241 : {
242 1098164 : switch(typ(x))
243 : {
244 255784 : case t_INT: return mpodd(x);
245 : case t_FRAC:
246 0 : if (!mpodd(gel(x,2))) (void)Fl_inv(0,2); /* error */
247 0 : return mpodd(gel(x,1));
248 : case t_PADIC:
249 0 : if (!absequaliu(gel(x,2),2)) pari_err_OP("",x, mkintmodu(1,2));
250 0 : if (valp(x) < 0) (void)Fl_inv(0,2);
251 0 : return valp(x) & 1;
252 : case t_INTMOD: {
253 842380 : GEN q = gel(x,1), a = gel(x,2);
254 842380 : if (mpodd(q)) pari_err_MODULUS("Rg_to_F2", q, gen_2);
255 842380 : return mpodd(a);
256 : }
257 0 : default: pari_err_TYPE("Rg_to_F2",x);
258 : return 0; /* LCOV_EXCL_LINE */
259 : }
260 : }
261 :
262 : GEN
263 2724458 : RgX_to_Flx(GEN x, ulong p)
264 : {
265 2724458 : long i, lx = lg(x);
266 2724458 : GEN a = cgetg(lx, t_VECSMALL);
267 2724458 : a[1]=((ulong)x[1])&VARNBITS;
268 2724458 : for (i=2; i<lx; i++) a[i] = Rg_to_Fl(gel(x,i), p);
269 2724458 : return Flx_renormalize(a,lx);
270 : }
271 :
272 : /* If x is a POLMOD, assume modulus is a multiple of T. */
273 : GEN
274 1807693 : Rg_to_Flxq(GEN x, GEN T, ulong p)
275 : {
276 1807693 : long ta, tx = typ(x), v = T[1];
277 : GEN a, b;
278 1807693 : if (is_const_t(tx))
279 : {
280 1743433 : if (tx == t_FFELT) return FF_to_Flxq(x);
281 1017265 : return Fl_to_Flx(Rg_to_Fl(x, p), v);
282 : }
283 64260 : switch(tx)
284 : {
285 : case t_POLMOD:
286 707 : b = gel(x,1);
287 707 : a = gel(x,2); ta = typ(a);
288 707 : if (is_const_t(ta)) return Fl_to_Flx(Rg_to_Fl(a, p), v);
289 609 : b = RgX_to_Flx(b, p); if (b[1] != v) break;
290 609 : a = RgX_to_Flx(a, p); if (Flx_equal(b,T)) return a;
291 0 : if (lgpol(Flx_rem(b,T,p))==0) return Flx_rem(a, T, p);
292 0 : break;
293 : case t_POL:
294 63553 : x = RgX_to_Flx(x,p);
295 63553 : if (x[1] != v) break;
296 63553 : return Flx_rem(x, T, p);
297 : case t_RFRAC:
298 0 : a = Rg_to_Flxq(gel(x,1), T,p);
299 0 : b = Rg_to_Flxq(gel(x,2), T,p);
300 0 : return Flxq_div(a,b, T,p);
301 : }
302 0 : pari_err_TYPE("Rg_to_Flxq",x);
303 : return NULL; /* LCOV_EXCL_LINE */
304 : }
305 :
306 : /***********************************************************************/
307 : /** **/
308 : /** Basic operation on Flx **/
309 : /** **/
310 : /***********************************************************************/
311 : /* = zx_renormalize. Similar to normalizepol, in place */
312 : GEN
313 1407182140 : Flx_renormalize(GEN /*in place*/ x, long lx)
314 : {
315 : long i;
316 1609419097 : for (i = lx-1; i>1; i--)
317 1560965380 : if (x[i]) break;
318 1407182140 : stackdummy((pari_sp)(x + lg(x)), (pari_sp)(x + i+1));
319 1407764025 : setlg(x, i+1); return x;
320 : }
321 :
322 : GEN
323 287023 : Flx_red(GEN z, ulong p)
324 : {
325 287023 : long i, l = lg(z);
326 287023 : GEN x = cgetg(l, t_VECSMALL);
327 287660 : x[1] = z[1];
328 287660 : for (i=2; i<l; i++) x[i] = uel(z,i)%p;
329 287660 : return Flx_renormalize(x,l);
330 : }
331 :
332 : GEN
333 1092515 : random_Flx(long d1, long vs, ulong p)
334 : {
335 1092515 : long i, d = d1+2;
336 1092515 : GEN y = cgetg(d,t_VECSMALL); y[1] = vs;
337 1092515 : for (i=2; i<d; i++) y[i] = random_Fl(p);
338 1092515 : return Flx_renormalize(y,d);
339 : }
340 :
341 : static GEN
342 6837 : Flx_addspec(GEN x, GEN y, ulong p, long lx, long ly)
343 : {
344 : long i,lz;
345 : GEN z;
346 :
347 6837 : if (ly>lx) swapspec(x,y, lx,ly);
348 6837 : lz = lx+2; z = cgetg(lz, t_VECSMALL) + 2;
349 6837 : for (i=0; i<ly; i++) z[i] = Fl_add(x[i], y[i], p);
350 6837 : for ( ; i<lx; i++) z[i] = x[i];
351 6837 : z -= 2; return Flx_renormalize(z, lz);
352 : }
353 :
354 : GEN
355 51529605 : Flx_add(GEN x, GEN y, ulong p)
356 : {
357 : long i,lz;
358 : GEN z;
359 51529605 : long lx=lg(x);
360 51529605 : long ly=lg(y);
361 51529605 : if (ly>lx) swapspec(x,y, lx,ly);
362 51529605 : lz = lx; z = cgetg(lz, t_VECSMALL); z[1]=x[1];
363 51526694 : for (i=2; i<ly; i++) z[i] = Fl_add(x[i], y[i], p);
364 51531359 : for ( ; i<lx; i++) z[i] = x[i];
365 51531359 : return Flx_renormalize(z, lz);
366 : }
367 :
368 : GEN
369 7312370 : Flx_Fl_add(GEN y, ulong x, ulong p)
370 : {
371 : GEN z;
372 : long lz, i;
373 7312370 : if (!lgpol(y))
374 273224 : return Fl_to_Flx(x,y[1]);
375 7038703 : lz=lg(y);
376 7038703 : z=cgetg(lz,t_VECSMALL);
377 7038588 : z[1]=y[1];
378 7038588 : z[2] = Fl_add(y[2],x,p);
379 39261784 : for(i=3;i<lz;i++)
380 32222889 : z[i] = y[i];
381 7038895 : if (lz==3) z = Flx_renormalize(z,lz);
382 7038798 : return z;
383 : }
384 :
385 : static GEN
386 2073323 : Flx_subspec(GEN x, GEN y, ulong p, long lx, long ly)
387 : {
388 : long i,lz;
389 : GEN z;
390 :
391 2073323 : if (ly <= lx)
392 : {
393 2073323 : lz = lx+2; z = cgetg(lz, t_VECSMALL)+2;
394 2075192 : for (i=0; i<ly; i++) z[i] = Fl_sub(x[i],y[i],p);
395 2073358 : for ( ; i<lx; i++) z[i] = x[i];
396 : }
397 : else
398 : {
399 0 : lz = ly+2; z = cgetg(lz, t_VECSMALL)+2;
400 0 : for (i=0; i<lx; i++) z[i] = Fl_sub(x[i],y[i],p);
401 0 : for ( ; i<ly; i++) z[i] = Fl_neg(y[i],p);
402 : }
403 2073358 : return Flx_renormalize(z-2, lz);
404 : }
405 :
406 : GEN
407 70839724 : Flx_sub(GEN x, GEN y, ulong p)
408 : {
409 70839724 : long i,lz,lx = lg(x), ly = lg(y);
410 : GEN z;
411 :
412 70839724 : if (ly <= lx)
413 : {
414 38860519 : lz = lx; z = cgetg(lz, t_VECSMALL);
415 38858799 : for (i=2; i<ly; i++) z[i] = Fl_sub(x[i],y[i],p);
416 38855973 : for ( ; i<lx; i++) z[i] = x[i];
417 : }
418 : else
419 : {
420 31979205 : lz = ly; z = cgetg(lz, t_VECSMALL);
421 31979298 : for (i=2; i<lx; i++) z[i] = Fl_sub(x[i],y[i],p);
422 31979202 : for ( ; i<ly; i++) z[i] = y[i]? (long)(p - y[i]): y[i];
423 : }
424 70835175 : z[1]=x[1]; return Flx_renormalize(z, lz);
425 : }
426 :
427 : static GEN
428 1074409 : Flx_negspec(GEN x, ulong p, long l)
429 : {
430 : long i;
431 1074409 : GEN z = cgetg(l+2, t_VECSMALL) + 2;
432 1074631 : for (i=0; i<l; i++) z[i] = Fl_neg(x[i], p);
433 1074703 : return z-2;
434 : }
435 :
436 :
437 : GEN
438 1074422 : Flx_neg(GEN x, ulong p)
439 : {
440 1074422 : GEN z = Flx_negspec(x+2, p, lgpol(x));
441 1074701 : z[1] = x[1];
442 1074701 : return z;
443 : }
444 :
445 : GEN
446 1531 : Flx_neg_inplace(GEN x, ulong p)
447 : {
448 1531 : long i, l = lg(x);
449 360208 : for (i=2; i<l; i++)
450 358677 : if (x[i]) x[i] = p - x[i];
451 1531 : return x;
452 : }
453 :
454 : GEN
455 1872936 : Flx_double(GEN y, ulong p)
456 : {
457 : long i, l;
458 1872936 : GEN z = cgetg_copy(y, &l); z[1] = y[1];
459 1872936 : for(i=2; i<l; i++) z[i] = Fl_double(y[i], p);
460 1872936 : return Flx_renormalize(z, l);
461 : }
462 : GEN
463 670867 : Flx_triple(GEN y, ulong p)
464 : {
465 : long i, l;
466 670867 : GEN z = cgetg_copy(y, &l); z[1] = y[1];
467 670867 : for(i=2; i<l; i++) z[i] = Fl_triple(y[i], p);
468 670867 : return Flx_renormalize(z, l);
469 : }
470 : GEN
471 37697055 : Flx_Fl_mul(GEN y, ulong x, ulong p)
472 : {
473 : GEN z;
474 : long i, l;
475 37697055 : if (!x) return pol0_Flx(y[1]);
476 28341346 : z = cgetg_copy(y, &l); z[1] = y[1];
477 28340717 : if (HIGHWORD(x | p))
478 166936 : for(i=2; i<l; i++) z[i] = Fl_mul(y[i], x, p);
479 : else
480 28173781 : for(i=2; i<l; i++) z[i] = (y[i] * x) % p;
481 28340717 : return Flx_renormalize(z, l);
482 : }
483 : GEN
484 6591196 : Flx_Fl_mul_to_monic(GEN y, ulong x, ulong p)
485 : {
486 : GEN z;
487 : long i, l;
488 6591196 : z = cgetg_copy(y, &l); z[1] = y[1];
489 6589151 : if (HIGHWORD(x | p))
490 2010190 : for(i=2; i<l-1; i++) z[i] = Fl_mul(y[i], x, p);
491 : else
492 4578961 : for(i=2; i<l-1; i++) z[i] = (y[i] * x) % p;
493 6589146 : z[l-1] = 1; return z;
494 : }
495 :
496 : /* Return a*x^n if n>=0 and a\x^(-n) if n<0 */
497 : GEN
498 5328095 : Flx_shift(GEN a, long n)
499 : {
500 5328095 : long i, l = lg(a);
501 : GEN b;
502 5328095 : if (l==2 || !n) return Flx_copy(a);
503 5304565 : if (l+n<=2) return pol0_Flx(a[1]);
504 5302869 : b = cgetg(l+n, t_VECSMALL);
505 5302988 : b[1] = a[1];
506 5302988 : if (n < 0)
507 1576964 : for (i=2-n; i<l; i++) b[i+n] = a[i];
508 : else
509 : {
510 3726024 : for (i=0; i<n; i++) b[2+i] = 0;
511 3726024 : for (i=2; i<l; i++) b[i+n] = a[i];
512 : }
513 5302988 : return b;
514 : }
515 :
516 : GEN
517 38040527 : Flx_normalize(GEN z, ulong p)
518 : {
519 38040527 : long l = lg(z)-1;
520 38040527 : ulong p1 = z[l]; /* leading term */
521 38040527 : if (p1 == 1) return z;
522 6586037 : return Flx_Fl_mul_to_monic(z, Fl_inv(p1,p), p);
523 : }
524 :
525 : /* return (x * X^d) + y. Assume d > 0, x > 0 and y >= 0 */
526 : static GEN
527 3542 : Flx_addshift(GEN x, GEN y, ulong p, long d)
528 : {
529 3542 : GEN xd,yd,zd = (GEN)avma;
530 3542 : long a,lz,ny = lgpol(y), nx = lgpol(x);
531 3542 : long vs = x[1];
532 :
533 3542 : x += 2; y += 2; a = ny-d;
534 3542 : if (a <= 0)
535 : {
536 7 : lz = (a>nx)? ny+2: nx+d+2;
537 7 : (void)new_chunk(lz); xd = x+nx; yd = y+ny;
538 7 : while (xd > x) *--zd = *--xd;
539 7 : x = zd + a;
540 7 : while (zd > x) *--zd = 0;
541 : }
542 : else
543 : {
544 3535 : xd = new_chunk(d); yd = y+d;
545 3535 : x = Flx_addspec(x,yd,p, nx,a);
546 3535 : lz = (a>nx)? ny+2: lg(x)+d;
547 3535 : x += 2; while (xd > x) *--zd = *--xd;
548 : }
549 3542 : while (yd > y) *--zd = *--yd;
550 3542 : *--zd = vs;
551 3542 : *--zd = evaltyp(t_VECSMALL) | evallg(lz); return zd;
552 : }
553 :
554 : /* shift polynomial + gerepile */
555 : /* Do not set evalvarn*/
556 : static GEN
557 428556249 : Flx_shiftip(pari_sp av, GEN x, long v)
558 : {
559 428556249 : long i, lx = lg(x), ly;
560 : GEN y;
561 428556249 : if (!v || lx==2) return gerepileuptoleaf(av, x);
562 97336348 : ly = lx + v; /* result length */
563 97336348 : (void)new_chunk(ly); /* check that result fits */
564 97510998 : x += lx; y = (GEN)av;
565 97510998 : for (i = 2; i<lx; i++) *--y = *--x;
566 97510998 : for (i = 0; i< v; i++) *--y = 0;
567 97510998 : y -= 2; y[0] = evaltyp(t_VECSMALL) | evallg(ly);
568 97472101 : avma = (pari_sp)y; return y;
569 : }
570 :
571 : #define BITS_IN_QUARTULONG (BITS_IN_HALFULONG >> 1)
572 : #define QUARTMASK ((1UL<<BITS_IN_QUARTULONG)-1UL)
573 : #define LLQUARTWORD(x) ((x) & QUARTMASK)
574 : #define HLQUARTWORD(x) (((x) >> BITS_IN_QUARTULONG) & QUARTMASK)
575 : #define LHQUARTWORD(x) (((x) >> (2*BITS_IN_QUARTULONG)) & QUARTMASK)
576 : #define HHQUARTWORD(x) (((x) >> (3*BITS_IN_QUARTULONG)) & QUARTMASK)
577 : INLINE long
578 473767928 : maxlengthcoeffpol(ulong p, long n)
579 : {
580 473767928 : pari_sp ltop = avma;
581 473767928 : GEN z = muliu(sqru(p-1), n);
582 473030525 : long l = lgefint(z);
583 473030525 : avma = ltop;
584 473030525 : if (l==3 && HIGHWORD(z[2])==0)
585 : {
586 145578642 : if (HLQUARTWORD(z[2]) == 0) return -1;
587 43879481 : else return 0;
588 : }
589 327451883 : return l-2;
590 : }
591 :
592 : INLINE ulong
593 684309410 : Flx_mullimb_ok(GEN x, GEN y, ulong p, long a, long b)
594 : { /* Assume OK_ULONG*/
595 684309410 : ulong p1 = 0;
596 : long i;
597 2204489964 : for (i=a; i<b; i++)
598 1520180554 : if (y[i])
599 : {
600 1392962209 : p1 += y[i] * x[-i];
601 1392962209 : if (p1 & HIGHBIT) p1 %= p;
602 : }
603 684309410 : return p1 % p;
604 : }
605 :
606 : INLINE ulong
607 756047557 : Flx_mullimb(GEN x, GEN y, ulong p, ulong pi, long a, long b)
608 : {
609 756047557 : ulong p1 = 0;
610 : long i;
611 2379279462 : for (i=a; i<b; i++)
612 1622901480 : if (y[i])
613 1577175708 : p1 = Fl_addmul_pre(p1, y[i], x[-i], p, pi);
614 756377982 : return p1;
615 : }
616 :
617 : /* assume nx >= ny > 0 */
618 : static GEN
619 183626733 : Flx_mulspec_basecase(GEN x, GEN y, ulong p, long nx, long ny)
620 : {
621 : long i,lz,nz;
622 : GEN z;
623 :
624 183626733 : lz = nx+ny+1; nz = lz-2;
625 183626733 : z = cgetg(lz, t_VECSMALL) + 2; /* x:y:z [i] = term of degree i */
626 183723707 : if (SMALL_ULONG(p))
627 : {
628 102909743 : for (i=0; i<ny; i++)z[i] = Flx_mullimb_ok(x+i,y,p,0,i+1);
629 103015082 : for ( ; i<nx; i++) z[i] = Flx_mullimb_ok(x+i,y,p,0,ny);
630 103075534 : for ( ; i<nz; i++) z[i] = Flx_mullimb_ok(x+i,y,p,i-nx+1,ny);
631 : }
632 : else
633 : {
634 80813964 : ulong pi = get_Fl_red(p);
635 80835085 : for (i=0; i<ny; i++)z[i] = Flx_mullimb(x+i,y,p,pi,0,i+1);
636 80772377 : for ( ; i<nx; i++) z[i] = Flx_mullimb(x+i,y,p,pi,0,ny);
637 80776573 : for ( ; i<nz; i++) z[i] = Flx_mullimb(x+i,y,p,pi,i-nx+1,ny);
638 : }
639 183887402 : z -= 2; return Flx_renormalize(z, lz);
640 : }
641 :
642 : static GEN
643 49736995 : int_to_Flx(GEN z, ulong p)
644 : {
645 49736995 : long i, l = lgefint(z);
646 49736995 : GEN x = cgetg(l, t_VECSMALL);
647 49838936 : for (i=2; i<l; i++) x[i] = uel(z,i)%p;
648 49838936 : return Flx_renormalize(x, l);
649 : }
650 :
651 : INLINE GEN
652 5802299 : Flx_mulspec_mulii(GEN a, GEN b, ulong p, long na, long nb)
653 : {
654 5802299 : GEN z=muliispec(a,b,na,nb);
655 5820532 : return int_to_Flx(z,p);
656 : }
657 :
658 : static GEN
659 29920818 : Flx_to_int_halfspec(GEN a, long na)
660 : {
661 : long j;
662 29920818 : long n = (na+1)>>1UL;
663 29920818 : GEN V = cgetipos(2+n);
664 : GEN w;
665 284132420 : for (w = int_LSW(V), j=0; j+1<na; j+=2, w=int_nextW(w))
666 254211445 : *w = a[j]|(a[j+1]<<BITS_IN_HALFULONG);
667 29920975 : if (j<na)
668 21259393 : *w = a[j];
669 29920975 : return V;
670 : }
671 :
672 : static GEN
673 21209626 : int_to_Flx_half(GEN z, ulong p)
674 : {
675 : long i;
676 21209626 : long lx = (lgefint(z)-2)*2+2;
677 21209626 : GEN w, x = cgetg(lx, t_VECSMALL);
678 323750746 : for (w = int_LSW(z), i=2; i<lx; i+=2, w=int_nextW(w))
679 : {
680 302541107 : x[i] = LOWWORD((ulong)*w)%p;
681 302541107 : x[i+1] = HIGHWORD((ulong)*w)%p;
682 : }
683 21209639 : return Flx_renormalize(x, lx);
684 : }
685 :
686 : static GEN
687 8733957 : Flx_mulspec_halfmulii(GEN a, GEN b, ulong p, long na, long nb)
688 : {
689 8733957 : GEN A = Flx_to_int_halfspec(a,na);
690 8734059 : GEN B = Flx_to_int_halfspec(b,nb);
691 8734059 : GEN z = mulii(A,B);
692 8734055 : return int_to_Flx_half(z,p);
693 : }
694 :
695 : static GEN
696 80465494 : Flx_to_int_quartspec(GEN a, long na)
697 : {
698 : long j;
699 80465494 : long n = (na+3)>>2UL;
700 80465494 : GEN V = cgetipos(2+n);
701 : GEN w;
702 266143496 : for (w = int_LSW(V), j=0; j+3<na; j+=4, w=int_nextW(w))
703 185673648 : *w = a[j]|(a[j+1]<<BITS_IN_QUARTULONG)|(a[j+2]<<(2*BITS_IN_QUARTULONG))|(a[j+3]<<(3*BITS_IN_QUARTULONG));
704 80469848 : switch (na-j)
705 : {
706 : case 3:
707 24830393 : *w = a[j]|(a[j+1]<<BITS_IN_QUARTULONG)|(a[j+2]<<(2*BITS_IN_QUARTULONG));
708 24830393 : break;
709 : case 2:
710 24188006 : *w = a[j]|(a[j+1]<<BITS_IN_QUARTULONG);
711 24188006 : break;
712 : case 1:
713 21339285 : *w = a[j];
714 21339285 : break;
715 : case 0:
716 10138053 : break;
717 : }
718 80469848 : return V;
719 : }
720 :
721 : static GEN
722 45514087 : int_to_Flx_quart(GEN z, ulong p)
723 : {
724 : long i;
725 45514087 : long lx = (lgefint(z)-2)*4+2;
726 45514087 : GEN w, x = cgetg(lx, t_VECSMALL);
727 292922636 : for (w = int_LSW(z), i=2; i<lx; i+=4, w=int_nextW(w))
728 : {
729 247398687 : x[i] = LLQUARTWORD((ulong)*w)%p;
730 247398687 : x[i+1] = HLQUARTWORD((ulong)*w)%p;
731 247398687 : x[i+2] = LHQUARTWORD((ulong)*w)%p;
732 247398687 : x[i+3] = HHQUARTWORD((ulong)*w)%p;
733 : }
734 45523949 : return Flx_renormalize(x, lx);
735 : }
736 :
737 : static GEN
738 34961423 : Flx_mulspec_quartmulii(GEN a, GEN b, ulong p, long na, long nb)
739 : {
740 34961423 : GEN A = Flx_to_int_quartspec(a,na);
741 34970835 : GEN B = Flx_to_int_quartspec(b,nb);
742 34969734 : GEN z = mulii(A,B);
743 34966621 : return int_to_Flx_quart(z,p);
744 : }
745 :
746 : /*Eval x in 2^(k*BIL) in linear time, k==2 or 3*/
747 : static GEN
748 39313981 : Flx_eval2BILspec(GEN x, long k, long l)
749 : {
750 39313981 : long i, lz = k*l, ki;
751 39313981 : GEN pz = cgetipos(2+lz);
752 824987758 : for (i=0; i < lz; i++)
753 785542981 : *int_W(pz,i) = 0UL;
754 431614400 : for (i=0, ki=0; i<l; i++, ki+=k)
755 392169623 : *int_W(pz,ki) = x[i];
756 39444777 : return int_normalize(pz,0);
757 : }
758 :
759 : static GEN
760 29211660 : Z_mod2BIL_Flx_2(GEN x, long d, ulong p)
761 : {
762 29211660 : long i, offset, lm = lgefint(x)-2, l = d+3;
763 29211660 : ulong pi = get_Fl_red(p);
764 29173941 : GEN pol = cgetg(l, t_VECSMALL);
765 29299044 : pol[1] = 0;
766 541717560 : for (i=0, offset=0; offset+1 < lm; i++, offset += 2)
767 512842425 : pol[i+2] = remll_pre(*int_W(x,offset+1), *int_W(x,offset), p, pi);
768 28875135 : if (offset < lm)
769 20886218 : pol[i+2] = (*int_W(x,offset)) % p;
770 28875135 : return Flx_renormalize(pol,l);
771 : }
772 :
773 : static GEN
774 11195 : Z_mod2BIL_Flx_3(GEN x, long d, ulong p)
775 : {
776 11195 : long i, offset, lm = lgefint(x)-2, l = d+3;
777 11195 : ulong pi = get_Fl_red(p);
778 11195 : GEN pol = cgetg(l, t_VECSMALL);
779 11194 : pol[1] = 0;
780 4293052 : for (i=0, offset=0; offset+2 < lm; i++, offset += 3)
781 8563714 : pol[i+2] = remlll_pre(*int_W(x,offset+2), *int_W(x,offset+1),
782 4281857 : *int_W(x,offset), p, pi);
783 11195 : if (offset+1 < lm)
784 9481 : pol[i+2] = remll_pre(*int_W(x,offset+1), *int_W(x,offset), p, pi);
785 1714 : else if (offset < lm)
786 1714 : pol[i+2] = (*int_W(x,offset)) % p;
787 11195 : return Flx_renormalize(pol,l);
788 : }
789 :
790 : static GEN
791 29238882 : Z_mod2BIL_Flx(GEN x, long bs, long d, ulong p)
792 : {
793 29238882 : return bs==2 ? Z_mod2BIL_Flx_2(x, d, p): Z_mod2BIL_Flx_3(x, d, p);
794 : }
795 :
796 : static GEN
797 10182127 : Flx_mulspec_mulii_inflate(GEN x, GEN y, long N, ulong p, long nx, long ny)
798 : {
799 10182127 : pari_sp av = avma;
800 10182127 : GEN z = mulii(Flx_eval2BILspec(x,N,nx), Flx_eval2BILspec(y,N,ny));
801 10208278 : return gerepileupto(av, Z_mod2BIL_Flx(z, N, nx+ny-2, p));
802 : }
803 :
804 : /* fast product (Karatsuba) of polynomials a,b. These are not real GENs, a+2,
805 : * b+2 were sent instead. na, nb = number of terms of a, b.
806 : * Only c, c0, c1, c2 are genuine GEN.
807 : */
808 : static GEN
809 260933403 : Flx_mulspec(GEN a, GEN b, ulong p, long na, long nb)
810 : {
811 : GEN a0,c,c0;
812 260933403 : long n0, n0a, i, v = 0;
813 : pari_sp av;
814 :
815 260933403 : while (na && !a[0]) { a++; na--; v++; }
816 260933403 : while (nb && !b[0]) { b++; nb--; v++; }
817 260933403 : if (na < nb) swapspec(a,b, na,nb);
818 260933403 : if (!nb) return pol0_Flx(0);
819 :
820 243365214 : av = avma;
821 243365214 : switch (maxlengthcoeffpol(p,nb))
822 : {
823 : case -1:
824 67086734 : if (na>=Flx_MUL_QUARTMULII_LIMIT)
825 34955458 : return Flx_shiftip(av,Flx_mulspec_quartmulii(a,b,p,na,nb), v);
826 32131276 : break;
827 : case 0:
828 19087053 : if (na>=Flx_MUL_HALFMULII_LIMIT)
829 8733887 : return Flx_shiftip(av,Flx_mulspec_halfmulii(a,b,p,na,nb), v);
830 10353166 : break;
831 : case 1:
832 68079950 : if (na>=Flx_MUL_MULII_LIMIT)
833 5803501 : return Flx_shiftip(av,Flx_mulspec_mulii(a,b,p,na,nb), v);
834 62276449 : break;
835 : case 2:
836 86459546 : if (na>=Flx_MUL_MULII2_LIMIT)
837 10172726 : return Flx_shiftip(av,Flx_mulspec_mulii_inflate(a,b,2,p,na,nb), v);
838 76286820 : break;
839 : case 3:
840 2586773 : if (na>70)
841 8972 : return Flx_shiftip(av,Flx_mulspec_mulii_inflate(a,b,3,p,na,nb), v);
842 2577801 : break;
843 : }
844 183609383 : if (nb < Flx_MUL_KARATSUBA_LIMIT)
845 183607852 : return Flx_shiftip(av,Flx_mulspec_basecase(a,b,p,na,nb), v);
846 1531 : i=(na>>1); n0=na-i; na=i;
847 1531 : a0=a+n0; n0a=n0;
848 1531 : while (n0a && !a[n0a-1]) n0a--;
849 :
850 1531 : if (nb > n0)
851 : {
852 : GEN b0,c1,c2;
853 : long n0b;
854 :
855 1531 : nb -= n0; b0 = b+n0; n0b = n0;
856 1531 : while (n0b && !b[n0b-1]) n0b--;
857 1531 : c = Flx_mulspec(a,b,p,n0a,n0b);
858 1531 : c0 = Flx_mulspec(a0,b0,p,na,nb);
859 :
860 1531 : c2 = Flx_addspec(a0,a,p,na,n0a);
861 1531 : c1 = Flx_addspec(b0,b,p,nb,n0b);
862 :
863 1531 : c1 = Flx_mul(c1,c2,p);
864 1531 : c2 = Flx_add(c0,c,p);
865 :
866 1531 : c2 = Flx_neg_inplace(c2,p);
867 1531 : c2 = Flx_add(c1,c2,p);
868 1531 : c0 = Flx_addshift(c0,c2 ,p, n0);
869 : }
870 : else
871 : {
872 0 : c = Flx_mulspec(a,b,p,n0a,nb);
873 0 : c0 = Flx_mulspec(a0,b,p,na,nb);
874 : }
875 1531 : c0 = Flx_addshift(c0,c,p,n0);
876 1531 : return Flx_shiftip(av,c0, v);
877 : }
878 :
879 :
880 : GEN
881 256739596 : Flx_mul(GEN x, GEN y, ulong p)
882 : {
883 256739596 : GEN z = Flx_mulspec(x+2,y+2,p, lgpol(x),lgpol(y));
884 256835399 : z[1] = x[1]; return z;
885 : }
886 :
887 : static GEN
888 101063503 : Flx_sqrspec_basecase(GEN x, ulong p, long nx)
889 : {
890 : long i, lz, nz;
891 : ulong p1;
892 : GEN z;
893 :
894 101063503 : if (!nx) return pol0_Flx(0);
895 101063503 : lz = (nx << 1) + 1, nz = lz-2;
896 101063503 : z = cgetg(lz, t_VECSMALL) + 2;
897 100985979 : if (SMALL_ULONG(p))
898 : {
899 55696257 : z[0] = x[0]*x[0]%p;
900 125724137 : for (i=1; i<nx; i++)
901 : {
902 69833132 : p1 = Flx_mullimb_ok(x+i,x,p,0, (i+1)>>1);
903 70027880 : p1 <<= 1;
904 70027880 : if ((i&1) == 0) p1 += x[i>>1] * x[i>>1];
905 70027880 : z[i] = p1 % p;
906 : }
907 126610634 : for ( ; i<nz; i++)
908 : {
909 70334559 : p1 = Flx_mullimb_ok(x+i,x,p,i-nx+1, (i+1)>>1);
910 70719629 : p1 <<= 1;
911 70719629 : if ((i&1) == 0) p1 += x[i>>1] * x[i>>1];
912 70719629 : z[i] = p1 % p;
913 : }
914 : }
915 : else
916 : {
917 45289722 : ulong pi = get_Fl_red(p);
918 45285086 : z[0] = Fl_sqr_pre(x[0], p, pi);
919 214934081 : for (i=1; i<nx; i++)
920 : {
921 169658587 : p1 = Flx_mullimb(x+i,x,p,pi,0, (i+1)>>1);
922 169736132 : p1 = Fl_add(p1, p1, p);
923 169649383 : if ((i&1) == 0) p1 = Fl_add(p1, Fl_sqr_pre(x[i>>1], p, pi), p);
924 169642532 : z[i] = p1;
925 : }
926 214960211 : for ( ; i<nz; i++)
927 : {
928 169667821 : p1 = Flx_mullimb(x+i,x,p,pi,i-nx+1, (i+1)>>1);
929 169871972 : p1 = Fl_add(p1, p1, p);
930 169809598 : if ((i&1) == 0) p1 = Fl_add(p1, Fl_sqr_pre(x[i>>1], p, pi), p);
931 169684717 : z[i] = p1;
932 : }
933 : }
934 101568465 : z -= 2; return Flx_renormalize(z, lz);
935 : }
936 :
937 : static GEN
938 43506209 : Flx_sqrspec_sqri(GEN a, ulong p, long na)
939 : {
940 43506209 : GEN z=sqrispec(a,na);
941 44116927 : return int_to_Flx(z,p);
942 : }
943 :
944 : static GEN
945 12270232 : Flx_sqrspec_halfsqri(GEN a, ulong p, long na)
946 : {
947 12270232 : GEN z = sqri(Flx_to_int_halfspec(a,na));
948 12270294 : return int_to_Flx_half(z,p);
949 : }
950 :
951 : static GEN
952 10547494 : Flx_sqrspec_quartsqri(GEN a, ulong p, long na)
953 : {
954 10547494 : GEN z = sqri(Flx_to_int_quartspec(a,na));
955 10548072 : return int_to_Flx_quart(z,p);
956 : }
957 :
958 : static GEN
959 18974350 : Flx_sqrspec_sqri_inflate(GEN x, long N, ulong p, long nx)
960 : {
961 18974350 : pari_sp av = avma;
962 18974350 : GEN z = sqri(Flx_eval2BILspec(x,N,nx));
963 19047346 : return gerepileupto(av, Z_mod2BIL_Flx(z, N, (nx-1)*2, p));
964 : }
965 :
966 : static GEN
967 186376460 : Flx_sqrspec(GEN a, ulong p, long na)
968 : {
969 : GEN a0, c, c0;
970 186376460 : long n0, n0a, i, v = 0;
971 : pari_sp av;
972 :
973 186376460 : while (na && !a[0]) { a++; na--; v += 2; }
974 186376460 : if (!na) return pol0_Flx(0);
975 :
976 186287700 : av = avma;
977 186287700 : switch(maxlengthcoeffpol(p,na))
978 : {
979 : case -1:
980 21369127 : if (na>=Flx_SQR_QUARTSQRI_LIMIT)
981 10547569 : return Flx_shiftip(av, Flx_sqrspec_quartsqri(a,p,na), v);
982 10821558 : break;
983 : case 0:
984 18948159 : if (na>=Flx_SQR_HALFSQRI_LIMIT)
985 12270236 : return Flx_shiftip(av, Flx_sqrspec_halfsqri(a,p,na), v);
986 6677923 : break;
987 : case 1:
988 80491225 : if (na>=Flx_SQR_SQRI_LIMIT)
989 43529339 : return Flx_shiftip(av, Flx_sqrspec_sqri(a,p,na), v);
990 36961886 : break;
991 : case 2:
992 64411734 : if (na>=Flx_SQR_SQRI2_LIMIT)
993 18973858 : return Flx_shiftip(av, Flx_sqrspec_sqri_inflate(a,2,p,na), v);
994 45437876 : break;
995 : case 3:
996 1209885 : if (na>70)
997 2223 : return Flx_shiftip(av, Flx_sqrspec_sqri_inflate(a,3,p,na), v);
998 1207662 : break;
999 : }
1000 101081338 : if (na < Flx_SQR_KARATSUBA_LIMIT)
1001 101081098 : return Flx_shiftip(av, Flx_sqrspec_basecase(a,p,na), v);
1002 240 : i=(na>>1); n0=na-i; na=i;
1003 240 : a0=a+n0; n0a=n0;
1004 240 : while (n0a && !a[n0a-1]) n0a--;
1005 :
1006 240 : c = Flx_sqrspec(a,p,n0a);
1007 240 : c0= Flx_sqrspec(a0,p,na);
1008 240 : if (p == 2) n0 *= 2;
1009 : else
1010 : {
1011 240 : GEN c1, t = Flx_addspec(a0,a,p,na,n0a);
1012 240 : t = Flx_sqr(t,p);
1013 240 : c1= Flx_add(c0,c, p);
1014 240 : c1= Flx_sub(t, c1, p);
1015 240 : c0 = Flx_addshift(c0,c1,p,n0);
1016 : }
1017 240 : c0 = Flx_addshift(c0,c,p,n0);
1018 240 : return Flx_shiftip(av,c0,v);
1019 : }
1020 :
1021 : GEN
1022 186323003 : Flx_sqr(GEN x, ulong p)
1023 : {
1024 186323003 : GEN z = Flx_sqrspec(x+2,p, lgpol(x));
1025 186998179 : z[1] = x[1]; return z;
1026 : }
1027 :
1028 : GEN
1029 6122 : Flx_powu(GEN x, ulong n, ulong p)
1030 : {
1031 6122 : GEN y = pol1_Flx(x[1]), z;
1032 : ulong m;
1033 6113 : if (n == 0) return y;
1034 6113 : m = n; z = x;
1035 : for (;;)
1036 : {
1037 39133 : if (m&1UL) y = Flx_mul(y,z, p);
1038 22645 : m >>= 1; if (!m) return y;
1039 16530 : z = Flx_sqr(z, p);
1040 : }
1041 : }
1042 :
1043 : GEN
1044 13085 : Flx_halve(GEN y, ulong p)
1045 : {
1046 : GEN z;
1047 : long i, l;
1048 13085 : z = cgetg_copy(y, &l); z[1] = y[1];
1049 13085 : for(i=2; i<l; i++) uel(z,i) = Fl_halve(uel(y,i), p);
1050 13085 : return z;
1051 : }
1052 :
1053 : static GEN
1054 5215255 : Flx_recipspec(GEN x, long l, long n)
1055 : {
1056 : long i;
1057 5215255 : GEN z=cgetg(n+2,t_VECSMALL)+2;
1058 204542016 : for(i=0; i<l; i++)
1059 199326429 : z[n-i-1] = x[i];
1060 7985022 : for( ; i<n; i++)
1061 2769435 : z[n-i-1] = 0;
1062 5215587 : return Flx_renormalize(z-2,n+2);
1063 : }
1064 :
1065 : GEN
1066 0 : Flx_recip(GEN x)
1067 : {
1068 0 : GEN z=Flx_recipspec(x+2,lgpol(x),lgpol(x));
1069 0 : z[1]=x[1];
1070 0 : return z;
1071 : }
1072 :
1073 : /* Return h^degpol(P) P(x / h) */
1074 : GEN
1075 701 : Flx_rescale(GEN P, ulong h, ulong p)
1076 : {
1077 701 : long i, l = lg(P);
1078 701 : GEN Q = cgetg(l,t_VECSMALL);
1079 701 : ulong hi = h;
1080 701 : Q[l-1] = P[l-1];
1081 5204 : for (i=l-2; i>=2; i--)
1082 : {
1083 5204 : Q[i] = Fl_mul(P[i], hi, p);
1084 5204 : if (i == 2) break;
1085 4503 : hi = Fl_mul(hi,h, p);
1086 : }
1087 701 : Q[1] = P[1]; return Q;
1088 : }
1089 :
1090 : static long
1091 45489246 : Flx_multhreshold(GEN T, ulong p, long quart, long half, long mul, long mul2, long kara)
1092 : {
1093 45489246 : long na = lgpol(T);
1094 45488694 : switch (maxlengthcoeffpol(p,na))
1095 : {
1096 : case -1:
1097 13328537 : if (na>=Flx_MUL_QUARTMULII_LIMIT)
1098 7144183 : return na>=quart;
1099 6184354 : break;
1100 : case 0:
1101 5846651 : if (na>=Flx_MUL_HALFMULII_LIMIT)
1102 3204675 : return na>=half;
1103 2641976 : break;
1104 : case 1:
1105 12442680 : if (na>=Flx_MUL_MULII_LIMIT)
1106 4546025 : return na>=mul;
1107 7896655 : break;
1108 : case 2:
1109 12700194 : if (na>=Flx_MUL_MULII2_LIMIT)
1110 988659 : return na>=mul2;
1111 11711535 : break;
1112 : case 3:
1113 1168526 : if (na>=70)
1114 1349 : return na>=70;
1115 1167177 : break;
1116 : }
1117 29601485 : return na>=kara;
1118 : }
1119 :
1120 : /*
1121 : * x/polrecip(P)+O(x^n)
1122 : */
1123 : static GEN
1124 88999 : Flx_invBarrett_basecase(GEN T, ulong p)
1125 : {
1126 88999 : long i, l=lg(T)-1, lr=l-1, k;
1127 88999 : GEN r=cgetg(lr,t_VECSMALL); r[1] = T[1];
1128 88999 : r[2] = 1;
1129 88999 : if (SMALL_ULONG(p))
1130 3955837 : for (i=3;i<lr;i++)
1131 : {
1132 3869475 : ulong u = uel(T, l-i+2);
1133 116931133 : for (k=3; k<i; k++)
1134 113061658 : { u += uel(T,l-i+k) * uel(r, k); if (u & HIGHBIT) u %= p; }
1135 3869475 : r[i] = Fl_neg(u % p, p);
1136 : }
1137 : else
1138 51750 : for (i=3;i<lr;i++)
1139 : {
1140 49113 : ulong u = Fl_neg(uel(T,l-i+2), p);
1141 521376 : for (k=3; k<i; k++)
1142 472263 : u = Fl_sub(u, Fl_mul(uel(T,l-i+k), uel(r,k), p), p);
1143 49113 : r[i] = u;
1144 : }
1145 88999 : return Flx_renormalize(r,lr);
1146 : }
1147 :
1148 : /* Return new lgpol */
1149 : static long
1150 4211378 : Flx_lgrenormalizespec(GEN x, long lx)
1151 : {
1152 : long i;
1153 13224493 : for (i = lx-1; i>=0; i--)
1154 13224527 : if (x[i]) break;
1155 4211378 : return i+1;
1156 : }
1157 : static GEN
1158 4348 : Flx_invBarrett_Newton(GEN T, ulong p)
1159 : {
1160 4348 : long nold, lx, lz, lq, l = degpol(T), lQ;
1161 4348 : GEN q, y, z, x = zero_zv(l+1) + 2;
1162 4348 : ulong mask = quadratic_prec_mask(l-2); /* assume l > 2 */
1163 : pari_sp av;
1164 :
1165 4348 : y = T+2;
1166 4348 : q = Flx_recipspec(y,l+1,l+1); lQ = lgpol(q); q+=2;
1167 4349 : av = avma;
1168 : /* We work on _spec_ Flx's, all the l[xzq12] below are lgpol's */
1169 :
1170 : /* initialize */
1171 4349 : x[0] = Fl_inv(q[0], p);
1172 4349 : if (lQ>1 && q[1])
1173 2044 : {
1174 2043 : ulong u = q[1];
1175 2043 : if (x[0] != 1) u = Fl_mul(u, Fl_sqr(x[0],p), p);
1176 2044 : x[1] = p - u; lx = 2;
1177 : }
1178 : else
1179 2306 : lx = 1;
1180 4350 : nold = 1;
1181 32060 : for (; mask > 1; avma = av)
1182 : { /* set x -= x(x*q - 1) + O(t^(nnew + 1)), knowing x*q = 1 + O(t^(nold+1)) */
1183 27712 : long i, lnew, nnew = nold << 1;
1184 :
1185 27712 : if (mask & 1) nnew--;
1186 27712 : mask >>= 1;
1187 :
1188 27712 : lnew = nnew + 1;
1189 27712 : lq = Flx_lgrenormalizespec(q, minss(lQ, lnew));
1190 27713 : z = Flx_mulspec(x, q, p, lx, lq); /* FIXME: high product */
1191 27711 : lz = lgpol(z); if (lz > lnew) lz = lnew;
1192 27716 : z += 2;
1193 : /* subtract 1 [=>first nold words are 0]: renormalize so that z(0) != 0 */
1194 27716 : for (i = nold; i < lz; i++) if (z[i]) break;
1195 27716 : nold = nnew;
1196 27716 : if (i >= lz) continue; /* z-1 = 0(t^(nnew + 1)) */
1197 :
1198 : /* z + i represents (x*q - 1) / t^i */
1199 19309 : lz = Flx_lgrenormalizespec (z+i, lz-i);
1200 19309 : z = Flx_mulspec(x, z+i, p, lx, lz); /* FIXME: low product */
1201 19314 : lz = lgpol(z); z += 2;
1202 19313 : if (lz > lnew-i) lz = Flx_lgrenormalizespec(z, lnew-i);
1203 :
1204 19313 : lx = lz+ i;
1205 19313 : y = x + i; /* x -= z * t^i, in place */
1206 19313 : for (i = 0; i < lz; i++) y[i] = Fl_neg(z[i], p);
1207 : }
1208 4348 : x -= 2; setlg(x, lx + 2); x[1] = T[1];
1209 4348 : return x;
1210 : }
1211 :
1212 : /* x/polrecip(T)+O(x^deg(T)) */
1213 : GEN
1214 93349 : Flx_invBarrett(GEN T, ulong p)
1215 : {
1216 93349 : pari_sp ltop=avma;
1217 93349 : long l=lg(T);
1218 : GEN r;
1219 93349 : if (l<5) return pol0_Flx(T[1]);
1220 93347 : if (!Flx_multhreshold(T,p, Flx_INVBARRETT_QUARTMULII_LIMIT,
1221 : Flx_INVBARRETT_HALFMULII_LIMIT,
1222 : Flx_INVBARRETT_MULII_LIMIT,
1223 : Flx_INVBARRETT_MULII2_LIMIT,
1224 : Flx_INVBARRETT_KARATSUBA_LIMIT))
1225 : {
1226 88999 : ulong c = T[l-1];
1227 88999 : if (c!=1)
1228 : {
1229 529 : ulong ci = Fl_inv(c,p);
1230 529 : T=Flx_Fl_mul(T, ci, p);
1231 529 : r=Flx_invBarrett_basecase(T,p);
1232 529 : r=Flx_Fl_mul(r,ci,p);
1233 : }
1234 : else
1235 88470 : r=Flx_invBarrett_basecase(T,p);
1236 : }
1237 : else
1238 4349 : r = Flx_invBarrett_Newton(T,p);
1239 93346 : return gerepileuptoleaf(ltop, r);
1240 : }
1241 :
1242 : GEN
1243 45510788 : Flx_get_red(GEN T, ulong p)
1244 : {
1245 45510788 : if (typ(T)!=t_VECSMALL || !Flx_multhreshold(T,p,
1246 : Flx_BARRETT_QUARTMULII_LIMIT,
1247 : Flx_BARRETT_HALFMULII_LIMIT,
1248 : Flx_BARRETT_MULII_LIMIT,
1249 : Flx_BARRETT_MULII2_LIMIT,
1250 : Flx_BARRETT_KARATSUBA_LIMIT))
1251 45415071 : return T;
1252 92431 : retmkvec2(Flx_invBarrett(T,p),T);
1253 : }
1254 :
1255 : /* separate from Flx_divrem for maximal speed. */
1256 : static GEN
1257 448531443 : Flx_rem_basecase(GEN x, GEN y, ulong p)
1258 : {
1259 : pari_sp av;
1260 : GEN z, c;
1261 : long dx,dy,dy1,dz,i,j;
1262 : ulong p1,inv;
1263 448531443 : long vs=x[1];
1264 :
1265 448531443 : dy = degpol(y); if (!dy) return pol0_Flx(x[1]);
1266 440387065 : dx = degpol(x);
1267 440237532 : dz = dx-dy; if (dz < 0) return Flx_copy(x);
1268 440237532 : x += 2; y += 2;
1269 440237532 : inv = y[dy];
1270 440237532 : if (inv != 1UL) inv = Fl_inv(inv,p);
1271 441123157 : for (dy1=dy-1; dy1>=0 && !y[dy1]; dy1--);
1272 :
1273 441123157 : c = cgetg(dy+3, t_VECSMALL); c[1]=vs; c += 2; av=avma;
1274 440287667 : z = cgetg(dz+3, t_VECSMALL); z[1]=vs; z += 2;
1275 :
1276 439991958 : if (SMALL_ULONG(p))
1277 : {
1278 262046615 : z[dz] = (inv*x[dx]) % p;
1279 1022479614 : for (i=dx-1; i>=dy; --i)
1280 : {
1281 760432999 : p1 = p - x[i]; /* compute -p1 instead of p1 (pb with ulongs otherwise) */
1282 4651682964 : for (j=i-dy1; j<=i && j<=dz; j++)
1283 : {
1284 3891249965 : p1 += z[j]*y[i-j];
1285 3891249965 : if (p1 & HIGHBIT) p1 %= p;
1286 : }
1287 760432999 : p1 %= p;
1288 760432999 : z[i-dy] = p1? ((p - p1)*inv) % p: 0;
1289 : }
1290 1849843024 : for (i=0; i<dy; i++)
1291 : {
1292 1587912971 : p1 = z[0]*y[i];
1293 6633035456 : for (j=maxss(1,i-dy1); j<=i && j<=dz; j++)
1294 : {
1295 5045122485 : p1 += z[j]*y[i-j];
1296 5045122485 : if (p1 & HIGHBIT) p1 %= p;
1297 : }
1298 1586790642 : c[i] = Fl_sub(x[i], p1%p, p);
1299 : }
1300 : }
1301 : else
1302 : {
1303 177945343 : ulong pi = get_Fl_red(p);
1304 177870967 : z[dz] = Fl_mul_pre(inv, x[dx], p, pi);
1305 581560021 : for (i=dx-1; i>=dy; --i)
1306 : {
1307 404159251 : p1 = p - x[i]; /* compute -p1 instead of p1 (pb with ulongs otherwise) */
1308 1695970053 : for (j=i-dy1; j<=i && j<=dz; j++)
1309 1290431548 : p1 = Fl_addmul_pre(p1, z[j], y[i - j], p, pi);
1310 405538505 : z[i-dy] = p1? Fl_mul_pre(p - p1, inv, p, pi): 0;
1311 : }
1312 1220145356 : for (i=0; i<dy; i++)
1313 : {
1314 1042785306 : p1 = Fl_mul_pre(z[0],y[i],p,pi);
1315 2996062568 : for (j=maxss(1,i-dy1); j<=i && j<=dz; j++)
1316 1949186545 : p1 = Fl_addmul_pre(p1, z[j], y[i - j], p, pi);
1317 1035081837 : c[i] = Fl_sub(x[i], p1, p);
1318 : }
1319 : }
1320 439290103 : i = dy-1; while (i>=0 && !c[i]) i--;
1321 439290103 : avma=av;
1322 439290103 : return Flx_renormalize(c-2, i+3);
1323 : }
1324 :
1325 : /* as FpX_divrem but working only on ulong types.
1326 : * if relevant, *pr is the last object on stack */
1327 : static GEN
1328 26478231 : Flx_divrem_basecase(GEN x, GEN y, ulong p, GEN *pr)
1329 : {
1330 : GEN z,q,c;
1331 : long dx,dy,dy1,dz,i,j;
1332 : ulong p1,inv;
1333 26478231 : long sv=x[1];
1334 :
1335 26478231 : dy = degpol(y);
1336 26478548 : if (dy<0) pari_err_INV("Flx_divrem",y);
1337 26485881 : if (pr == ONLY_REM) return Flx_rem_basecase(x, y, p);
1338 26485879 : if (!dy)
1339 : {
1340 4315774 : if (pr && pr != ONLY_DIVIDES) *pr = pol0_Flx(sv);
1341 4315774 : if (y[2] == 1UL) return Flx_copy(x);
1342 2721831 : return Flx_Fl_mul(x, Fl_inv(y[2], p), p);
1343 : }
1344 22170105 : dx = degpol(x);
1345 22170168 : dz = dx-dy;
1346 22170168 : if (dz < 0)
1347 : {
1348 233441 : q = pol0_Flx(sv);
1349 233441 : if (pr && pr != ONLY_DIVIDES) *pr = Flx_copy(x);
1350 233441 : return q;
1351 : }
1352 21936727 : x += 2;
1353 21936727 : y += 2;
1354 21936727 : z = cgetg(dz + 3, t_VECSMALL); z[1] = sv; z += 2;
1355 21936571 : inv = uel(y, dy);
1356 21936571 : if (inv != 1UL) inv = Fl_inv(inv,p);
1357 21937145 : for (dy1=dy-1; dy1>=0 && !y[dy1]; dy1--);
1358 :
1359 21937145 : if (SMALL_ULONG(p))
1360 : {
1361 21031848 : z[dz] = (inv*x[dx]) % p;
1362 57861070 : for (i=dx-1; i>=dy; --i)
1363 : {
1364 36829222 : p1 = p - x[i]; /* compute -p1 instead of p1 (pb with ulongs otherwise) */
1365 179464373 : for (j=i-dy1; j<=i && j<=dz; j++)
1366 : {
1367 142635151 : p1 += z[j]*y[i-j];
1368 142635151 : if (p1 & HIGHBIT) p1 %= p;
1369 : }
1370 36829222 : p1 %= p;
1371 36829222 : z[i-dy] = p1? (long) ((p - p1)*inv) % p: 0;
1372 : }
1373 : }
1374 : else
1375 : {
1376 905297 : z[dz] = Fl_mul(inv, x[dx], p);
1377 7352524 : for (i=dx-1; i>=dy; --i)
1378 : { /* compute -p1 instead of p1 (pb with ulongs otherwise) */
1379 6447226 : p1 = p - uel(x,i);
1380 36620280 : for (j=i-dy1; j<=i && j<=dz; j++)
1381 30173053 : p1 = Fl_add(p1, Fl_mul(z[j],y[i-j],p), p);
1382 6447227 : z[i-dy] = p1? Fl_mul(p - p1, inv, p): 0;
1383 : }
1384 : }
1385 21937146 : q = Flx_renormalize(z-2, dz+3);
1386 21937229 : if (!pr) return q;
1387 :
1388 17247737 : c = cgetg(dy + 3, t_VECSMALL); c[1] = sv; c += 2;
1389 17247737 : if (SMALL_ULONG(p))
1390 : {
1391 196069993 : for (i=0; i<dy; i++)
1392 : {
1393 179658872 : p1 = (ulong)z[0]*y[i];
1394 402995816 : for (j=maxss(1,i-dy1); j<=i && j<=dz; j++)
1395 : {
1396 223336944 : p1 += (ulong)z[j]*y[i-j];
1397 223336944 : if (p1 & HIGHBIT) p1 %= p;
1398 : }
1399 179658872 : c[i] = Fl_sub(x[i], p1%p, p);
1400 : }
1401 : }
1402 : else
1403 : {
1404 9742176 : for (i=0; i<dy; i++)
1405 : {
1406 8905560 : p1 = Fl_mul(z[0],y[i],p);
1407 54772205 : for (j=maxss(1,i-dy1); j<=i && j<=dz; j++)
1408 45866645 : p1 = Fl_add(p1, Fl_mul(z[j],y[i-j],p), p);
1409 8905560 : c[i] = Fl_sub(x[i], p1, p);
1410 : }
1411 : }
1412 17247737 : i=dy-1; while (i>=0 && !c[i]) i--;
1413 17247737 : c = Flx_renormalize(c-2, i+3);
1414 17247737 : if (pr == ONLY_DIVIDES)
1415 259 : { if (lg(c) != 2) return NULL; }
1416 : else
1417 17247478 : *pr = c;
1418 17247660 : return q;
1419 : }
1420 :
1421 :
1422 : /* Compute x mod T where 2 <= degpol(T) <= l+1 <= 2*(degpol(T)-1)
1423 : * and mg is the Barrett inverse of T. */
1424 : static GEN
1425 2073379 : Flx_divrem_Barrettspec(GEN x, long l, GEN mg, GEN T, ulong p, GEN *pr)
1426 : {
1427 : GEN q, r;
1428 2073379 : long lt = degpol(T); /*We discard the leading term*/
1429 : long ld, lm, lT, lmg;
1430 2073368 : ld = l-lt;
1431 2073368 : lm = minss(ld, lgpol(mg));
1432 2073350 : lT = Flx_lgrenormalizespec(T+2,lt);
1433 2073349 : lmg = Flx_lgrenormalizespec(mg+2,lm);
1434 2073332 : q = Flx_recipspec(x+lt,ld,ld); /* q = rec(x) lz<=ld*/
1435 2073335 : q = Flx_mulspec(q+2,mg+2,p,lgpol(q),lmg); /* q = rec(x) * mg lz<=ld+lm*/
1436 2073394 : q = Flx_recipspec(q+2,minss(ld,lgpol(q)),ld);/* q = rec (rec(x) * mg) lz<=ld*/
1437 2073356 : if (!pr) return q;
1438 2073356 : r = Flx_mulspec(q+2,T+2,p,lgpol(q),lT); /* r = q*pol lz<=ld+lt*/
1439 2073380 : r = Flx_subspec(x,r+2,p,lt,minss(lt,lgpol(r)));/* r = x - q*pol lz<=lt */
1440 2073329 : if (pr == ONLY_REM) return r;
1441 5443 : *pr = r; return q;
1442 : }
1443 :
1444 : static GEN
1445 2067907 : Flx_divrem_Barrett_noGC(GEN x, GEN mg, GEN T, ulong p, GEN *pr)
1446 : {
1447 2067907 : long l = lgpol(x), lt = degpol(T), lm = 2*lt-1;
1448 2067905 : GEN q = NULL, r;
1449 : long i;
1450 2067905 : if (l <= lt)
1451 : {
1452 0 : if (pr == ONLY_REM) return Flx_copy(x);
1453 0 : if (pr == ONLY_DIVIDES) return lgpol(x)? NULL: pol0_Flx(x[1]);
1454 0 : if (pr) *pr = Flx_copy(x);
1455 0 : return pol0_Flx(x[1]);
1456 : }
1457 2067905 : if (lt <= 1)
1458 2 : return Flx_divrem_basecase(x,T,p,pr);
1459 2067903 : if (pr != ONLY_REM && l>lm)
1460 0 : q = zero_zv(l-lt+1);
1461 2067903 : r = Flx_copy(x);
1462 4141399 : while (l>lm)
1463 : {
1464 5395 : GEN zr, zq = Flx_divrem_Barrettspec(r+2+l-lm,lm,mg,T,p,&zr);
1465 5395 : long lz = lgpol(zr);
1466 5395 : if (pr != ONLY_REM)
1467 : {
1468 0 : long lq = lgpol(zq);
1469 0 : for(i=0; i<lq; i++) q[2+l-lm+i] = zq[2+i];
1470 : }
1471 5395 : for(i=0; i<lz; i++) r[2+l-lm+i] = zr[2+i];
1472 5395 : l = l-lm+lz;
1473 : }
1474 2068002 : if (pr != ONLY_REM)
1475 : {
1476 48 : if (l > lt)
1477 : {
1478 48 : GEN zq = Flx_divrem_Barrettspec(r+2,l,mg,T,p,&r);
1479 48 : if (!q) q = zq;
1480 : else
1481 : {
1482 0 : long lq = lgpol(zq);
1483 0 : for(i=0; i<lq; i++) q[2+i] = zq[2+i];
1484 : }
1485 : }
1486 : else
1487 0 : r = Flx_renormalize(r, l+2);
1488 : }
1489 : else
1490 : {
1491 2067954 : if (l > lt)
1492 2067950 : r = Flx_divrem_Barrettspec(r+2,l,mg,T,p,ONLY_REM);
1493 : else
1494 4 : r = Flx_renormalize(r, l+2);
1495 2067873 : r[1] = x[1]; return Flx_renormalize(r, lg(r));
1496 : }
1497 48 : if (pr) { r[1] = x[1]; r = Flx_renormalize(r, lg(r)); }
1498 48 : q[1] = x[1]; q = Flx_renormalize(q, lg(q));
1499 48 : if (pr == ONLY_DIVIDES) return lgpol(r)? NULL: q;
1500 48 : if (pr) *pr = r;
1501 48 : return q;
1502 : }
1503 :
1504 : GEN
1505 63545507 : Flx_divrem(GEN x, GEN T, ulong p, GEN *pr)
1506 : {
1507 63545507 : GEN B, y = get_Flx_red(T, &B);
1508 63544885 : long dy = degpol(y), dx = degpol(x), d = dx-dy;
1509 63541499 : if (pr==ONLY_REM) return Flx_rem(x, y, p);
1510 26480200 : if (!B && d+3 < Flx_DIVREM_BARRETT_LIMIT)
1511 26480152 : return Flx_divrem_basecase(x,y,p,pr);
1512 : else
1513 : {
1514 48 : pari_sp av=avma;
1515 48 : GEN mg = B? B: Flx_invBarrett(y, p);
1516 48 : GEN q1 = Flx_divrem_Barrett_noGC(x,mg,y,p,pr);
1517 48 : if (!q1) {avma=av; return NULL;}
1518 48 : if (!pr || pr==ONLY_DIVIDES) return gerepileuptoleaf(av, q1);
1519 21 : gerepileall(av,2,&q1,pr);
1520 21 : return q1;
1521 : }
1522 : }
1523 :
1524 : GEN
1525 514986985 : Flx_rem(GEN x, GEN T, ulong p)
1526 : {
1527 514986985 : GEN B, y = get_Flx_red(T, &B);
1528 514904216 : long dy = degpol(y), dx = degpol(x), d = dx-dy;
1529 514523254 : if (d < 0) return Flx_copy(x);
1530 450802952 : if (!B && d+3 < Flx_REM_BARRETT_LIMIT)
1531 448735090 : return Flx_rem_basecase(x,y,p);
1532 : else
1533 : {
1534 2067862 : pari_sp av=avma;
1535 2067862 : GEN mg = B ? B: Flx_invBarrett(y, p);
1536 2067862 : GEN r = Flx_divrem_Barrett_noGC(x, mg, y, p, ONLY_REM);
1537 2067817 : return gerepileuptoleaf(av, r);
1538 : }
1539 : }
1540 :
1541 : /* reduce T mod (X^n - 1, p). Shallow function */
1542 : GEN
1543 4931552 : Flx_mod_Xnm1(GEN T, ulong n, ulong p)
1544 : {
1545 4931552 : long i, j, L = lg(T), l = n+2;
1546 : GEN S;
1547 4931552 : if (L <= l || n & ~LGBITS) return T;
1548 217 : S = cgetg(l, t_VECSMALL);
1549 217 : S[1] = T[1];
1550 217 : for (i = 2; i < l; i++) S[i] = T[i];
1551 560 : for (j = 2; i < L; i++) {
1552 343 : S[j] = Fl_add(S[j], T[i], p);
1553 343 : if (++j == l) j = 2;
1554 : }
1555 217 : return Flx_renormalize(S, l);
1556 : }
1557 : /* reduce T mod (X^n + 1, p). Shallow function */
1558 : GEN
1559 4809 : Flx_mod_Xn1(GEN T, ulong n, ulong p)
1560 : {
1561 4809 : long i, j, L = lg(T), l = n+2;
1562 : GEN S;
1563 4809 : if (L <= l || n & ~LGBITS) return T;
1564 168 : S = cgetg(l, t_VECSMALL);
1565 168 : S[1] = T[1];
1566 168 : for (i = 2; i < l; i++) S[i] = T[i];
1567 427 : for (j = 2; i < L; i++) {
1568 259 : S[j] = Fl_sub(S[j], T[i], p);
1569 259 : if (++j == l) j = 2;
1570 : }
1571 168 : return Flx_renormalize(S, l);
1572 : }
1573 :
1574 : struct _Flxq {
1575 : GEN aut;
1576 : GEN T;
1577 : ulong p;
1578 : };
1579 :
1580 : static GEN
1581 0 : _Flx_divrem(void * E, GEN x, GEN y, GEN *r)
1582 : {
1583 0 : struct _Flxq *D = (struct _Flxq*) E;
1584 0 : return Flx_divrem(x, y, D->p, r);
1585 : }
1586 : static GEN
1587 24360397 : _Flx_add(void * E, GEN x, GEN y) {
1588 24360397 : struct _Flxq *D = (struct _Flxq*) E;
1589 24360397 : return Flx_add(x, y, D->p);
1590 : }
1591 : static GEN
1592 9048148 : _Flx_mul(void *E, GEN x, GEN y) {
1593 9048148 : struct _Flxq *D = (struct _Flxq*) E;
1594 9048148 : return Flx_mul(x, y, D->p);
1595 : }
1596 : static GEN
1597 0 : _Flx_sqr(void *E, GEN x) {
1598 0 : struct _Flxq *D = (struct _Flxq*) E;
1599 0 : return Flx_sqr(x, D->p);
1600 : }
1601 :
1602 : static struct bb_ring Flx_ring = { _Flx_add,_Flx_mul,_Flx_sqr };
1603 :
1604 : GEN
1605 0 : Flx_digits(GEN x, GEN T, ulong p)
1606 : {
1607 0 : pari_sp av = avma;
1608 : struct _Flxq D;
1609 0 : long d = degpol(T), n = (lgpol(x)+d-1)/d;
1610 : GEN z;
1611 0 : D.p = p;
1612 0 : z = gen_digits(x,T,n,(void *)&D, &Flx_ring, _Flx_divrem);
1613 0 : return gerepileupto(av, z);
1614 : }
1615 :
1616 : GEN
1617 0 : FlxV_Flx_fromdigits(GEN x, GEN T, ulong p)
1618 : {
1619 0 : pari_sp av = avma;
1620 : struct _Flxq D;
1621 : GEN z;
1622 0 : D.p = p;
1623 0 : z = gen_fromdigits(x,T,(void *)&D, &Flx_ring);
1624 0 : return gerepileupto(av, z);
1625 : }
1626 :
1627 : long
1628 3133258 : Flx_val(GEN x)
1629 : {
1630 3133258 : long i, l=lg(x);
1631 3133258 : if (l==2) return LONG_MAX;
1632 3133258 : for (i=2; i<l && x[i]==0; i++) /*empty*/;
1633 3133258 : return i-2;
1634 : }
1635 : long
1636 22110072 : Flx_valrem(GEN x, GEN *Z)
1637 : {
1638 22110072 : long v, i, l=lg(x);
1639 : GEN y;
1640 22110072 : if (l==2) { *Z = Flx_copy(x); return LONG_MAX; }
1641 22110072 : for (i=2; i<l && x[i]==0; i++) /*empty*/;
1642 22110072 : v = i-2;
1643 22110072 : if (v == 0) { *Z = x; return 0; }
1644 35749 : l -= v;
1645 35749 : y = cgetg(l, t_VECSMALL); y[1] = x[1];
1646 35749 : for (i=2; i<l; i++) y[i] = x[i+v];
1647 35749 : *Z = y; return v;
1648 : }
1649 :
1650 : GEN
1651 5816604 : Flx_deriv(GEN z, ulong p)
1652 : {
1653 5816604 : long i,l = lg(z)-1;
1654 : GEN x;
1655 5816604 : if (l < 2) l = 2;
1656 5816604 : x = cgetg(l, t_VECSMALL); x[1] = z[1]; z++;
1657 5816484 : if (HIGHWORD(l | p))
1658 1228283 : for (i=2; i<l; i++) x[i] = Fl_mul((ulong)i-1, z[i], p);
1659 : else
1660 4588201 : for (i=2; i<l; i++) x[i] = ((i-1) * z[i]) % p;
1661 5816215 : return Flx_renormalize(x,l);
1662 : }
1663 :
1664 : GEN
1665 11851 : Flx_translate1(GEN P, ulong p)
1666 : {
1667 11851 : long i, k, n = degpol(P);
1668 11851 : GEN R = Flx_copy(P);
1669 51520 : for (i=1; i<=n; i++)
1670 146139 : for (k=n-i; k<n; k++)
1671 106470 : uel(R,k+2) = Fl_add(uel(R,k+2), uel(R,k+3), p);
1672 11851 : return R;
1673 : }
1674 :
1675 : GEN
1676 11851 : Flx_diff1(GEN P, ulong p)
1677 : {
1678 11851 : return Flx_sub(Flx_translate1(P, p), P, p);
1679 : }
1680 :
1681 : GEN
1682 74232 : Flx_deflate(GEN x0, long d)
1683 : {
1684 : GEN z, y, x;
1685 74232 : long i,id, dy, dx = degpol(x0);
1686 74232 : if (d == 1 || dx <= 0) return Flx_copy(x0);
1687 68149 : dy = dx/d;
1688 68149 : y = cgetg(dy+3, t_VECSMALL); y[1] = x0[1];
1689 68149 : z = y + 2;
1690 68149 : x = x0+ 2;
1691 68149 : for (i=id=0; i<=dy; i++,id+=d) z[i] = x[id];
1692 68149 : return y;
1693 : }
1694 :
1695 : GEN
1696 49155 : Flx_inflate(GEN x0, long d)
1697 : {
1698 49155 : long i, id, dy, dx = degpol(x0);
1699 49144 : GEN x = x0 + 2, z, y;
1700 49144 : if (dx <= 0) return Flx_copy(x0);
1701 47988 : dy = dx*d;
1702 47988 : y = cgetg(dy+3, t_VECSMALL); y[1] = x0[1];
1703 48036 : z = y + 2;
1704 48036 : for (i=0; i<=dy; i++) z[i] = 0;
1705 48036 : for (i=id=0; i<=dx; i++,id+=d) z[id] = x[i];
1706 48036 : return y;
1707 : }
1708 :
1709 : /* write p(X) = a_0(X^k) + X*a_1(X^k) + ... + X^(k-1)*a_{k-1}(X^k) */
1710 : GEN
1711 137543 : Flx_splitting(GEN p, long k)
1712 : {
1713 137543 : long n = degpol(p), v = p[1], m, i, j, l;
1714 : GEN r;
1715 :
1716 137539 : m = n/k;
1717 137539 : r = cgetg(k+1,t_VEC);
1718 649384 : for(i=1; i<=k; i++)
1719 : {
1720 511808 : gel(r,i) = cgetg(m+3, t_VECSMALL);
1721 511801 : mael(r,i,1) = v;
1722 : }
1723 3207271 : for (j=1, i=0, l=2; i<=n; i++)
1724 : {
1725 3069695 : mael(r,j,l) = p[2+i];
1726 3069695 : if (j==k) { j=1; l++; } else j++;
1727 : }
1728 649412 : for(i=1; i<=k; i++)
1729 511871 : gel(r,i) = Flx_renormalize(gel(r,i),i<j?l+1:l);
1730 137541 : return r;
1731 : }
1732 : static GEN
1733 181993 : Flx_halfgcd_basecase(GEN a, GEN b, ulong p)
1734 : {
1735 181993 : pari_sp av=avma;
1736 : GEN u,u1,v,v1;
1737 181993 : long vx = a[1];
1738 181993 : long n = lgpol(a)>>1;
1739 181993 : u1 = v = pol0_Flx(vx);
1740 181993 : u = v1 = pol1_Flx(vx);
1741 914462 : while (lgpol(b)>n)
1742 : {
1743 550476 : GEN r, q = Flx_divrem(a,b,p, &r);
1744 550476 : a = b; b = r; swap(u,u1); swap(v,v1);
1745 550476 : u1 = Flx_sub(u1, Flx_mul(u, q, p), p);
1746 550476 : v1 = Flx_sub(v1, Flx_mul(v, q ,p), p);
1747 550476 : if (gc_needed(av,2))
1748 : {
1749 0 : if (DEBUGMEM>1) pari_warn(warnmem,"Flx_halfgcd (d = %ld)",degpol(b));
1750 0 : gerepileall(av,6, &a,&b,&u1,&v1,&u,&v);
1751 : }
1752 : }
1753 181993 : return gerepilecopy(av, mkmat2(mkcol2(u,u1), mkcol2(v,v1)));
1754 : }
1755 : /* ux + vy */
1756 : static GEN
1757 5764 : Flx_addmulmul(GEN u, GEN v, GEN x, GEN y, ulong p)
1758 5764 : { return Flx_add(Flx_mul(u,x, p), Flx_mul(v,y, p), p); }
1759 :
1760 : static GEN
1761 2879 : FlxM_Flx_mul2(GEN M, GEN x, GEN y, ulong p)
1762 : {
1763 2879 : GEN res = cgetg(3, t_COL);
1764 2879 : gel(res, 1) = Flx_addmulmul(gcoeff(M,1,1), gcoeff(M,1,2), x, y, p);
1765 2879 : gel(res, 2) = Flx_addmulmul(gcoeff(M,2,1), gcoeff(M,2,2), x, y, p);
1766 2879 : return res;
1767 : }
1768 :
1769 : #if 0
1770 : static GEN
1771 : FlxM_mul2_old(GEN M, GEN N, ulong p)
1772 : {
1773 : GEN res = cgetg(3, t_MAT);
1774 : gel(res, 1) = FlxM_Flx_mul2(M,gcoeff(N,1,1),gcoeff(N,2,1),p);
1775 : gel(res, 2) = FlxM_Flx_mul2(M,gcoeff(N,1,2),gcoeff(N,2,2),p);
1776 : return res;
1777 : }
1778 : #endif
1779 : /* A,B are 2x2 matrices, Flx entries. Return A x B using Strassen 7M formula */
1780 : static GEN
1781 1674 : FlxM_mul2(GEN A, GEN B, ulong p)
1782 : {
1783 1674 : GEN A11=gcoeff(A,1,1),A12=gcoeff(A,1,2), B11=gcoeff(B,1,1),B12=gcoeff(B,1,2);
1784 1674 : GEN A21=gcoeff(A,2,1),A22=gcoeff(A,2,2), B21=gcoeff(B,2,1),B22=gcoeff(B,2,2);
1785 1674 : GEN M1 = Flx_mul(Flx_add(A11,A22, p), Flx_add(B11,B22, p), p);
1786 1674 : GEN M2 = Flx_mul(Flx_add(A21,A22, p), B11, p);
1787 1674 : GEN M3 = Flx_mul(A11, Flx_sub(B12,B22, p), p);
1788 1674 : GEN M4 = Flx_mul(A22, Flx_sub(B21,B11, p), p);
1789 1674 : GEN M5 = Flx_mul(Flx_add(A11,A12, p), B22, p);
1790 1674 : GEN M6 = Flx_mul(Flx_sub(A21,A11, p), Flx_add(B11,B12, p), p);
1791 1674 : GEN M7 = Flx_mul(Flx_sub(A12,A22, p), Flx_add(B21,B22, p), p);
1792 1674 : GEN T1 = Flx_add(M1,M4, p), T2 = Flx_sub(M7,M5, p);
1793 1674 : GEN T3 = Flx_sub(M1,M2, p), T4 = Flx_add(M3,M6, p);
1794 1674 : retmkmat2(mkcol2(Flx_add(T1,T2, p), Flx_add(M2,M4, p)),
1795 : mkcol2(Flx_add(M3,M5, p), Flx_add(T3,T4, p)));
1796 : }
1797 :
1798 : /* Return [0,1;1,-q]*M */
1799 : static GEN
1800 1671 : Flx_FlxM_qmul(GEN q, GEN M, ulong p)
1801 : {
1802 1671 : GEN u, v, res = cgetg(3, t_MAT);
1803 1671 : u = Flx_sub(gcoeff(M,1,1), Flx_mul(gcoeff(M,2,1), q, p), p);
1804 1671 : gel(res,1) = mkcol2(gcoeff(M,2,1), u);
1805 1671 : v = Flx_sub(gcoeff(M,1,2), Flx_mul(gcoeff(M,2,2), q, p), p);
1806 1671 : gel(res,2) = mkcol2(gcoeff(M,2,2), v);
1807 1671 : return res;
1808 : }
1809 :
1810 : static GEN
1811 3 : matid2_FlxM(long v)
1812 : {
1813 3 : return mkmat2(mkcol2(pol1_Flx(v),pol0_Flx(v)),
1814 : mkcol2(pol0_Flx(v),pol1_Flx(v)));
1815 : }
1816 :
1817 : static GEN
1818 2853 : Flx_halfgcd_split(GEN x, GEN y, ulong p)
1819 : {
1820 2853 : pari_sp av=avma;
1821 : GEN R, S, V;
1822 : GEN y1, r, q;
1823 2853 : long l = lgpol(x), n = l>>1, k;
1824 2853 : if (lgpol(y)<=n) return matid2_FlxM(x[1]);
1825 2853 : R = Flx_halfgcd(Flx_shift(x,-n),Flx_shift(y,-n),p);
1826 2853 : V = FlxM_Flx_mul2(R,x,y,p); y1 = gel(V,2);
1827 2853 : if (lgpol(y1)<=n) return gerepilecopy(av, R);
1828 1671 : q = Flx_divrem(gel(V,1), y1, p, &r);
1829 1671 : k = 2*n-degpol(y1);
1830 1671 : S = Flx_halfgcd(Flx_shift(y1,-k), Flx_shift(r,-k),p);
1831 1671 : return gerepileupto(av, FlxM_mul2(S,Flx_FlxM_qmul(q,R,p),p));
1832 : }
1833 :
1834 : /* Return M in GL_2(Fl[X]) such that:
1835 : if [a',b']~=M*[a,b]~ then degpol(a')>= (lgpol(a)>>1) >degpol(b')
1836 : */
1837 :
1838 : static GEN
1839 184846 : Flx_halfgcd_i(GEN x, GEN y, ulong p)
1840 : {
1841 184846 : if (!Flx_multhreshold(x,p,
1842 : Flx_HALFGCD_QUARTMULII_LIMIT,
1843 : Flx_HALFGCD_HALFMULII_LIMIT,
1844 : Flx_HALFGCD_MULII_LIMIT,
1845 : Flx_HALFGCD_MULII2_LIMIT,
1846 : Flx_HALFGCD_KARATSUBA_LIMIT))
1847 181993 : return Flx_halfgcd_basecase(x,y,p);
1848 2853 : return Flx_halfgcd_split(x,y,p);
1849 : }
1850 :
1851 : GEN
1852 184846 : Flx_halfgcd(GEN x, GEN y, ulong p)
1853 : {
1854 : pari_sp av;
1855 : GEN M,q,r;
1856 184846 : long lx=lgpol(x), ly=lgpol(y);
1857 184846 : if (!lx)
1858 : {
1859 0 : long v = x[1];
1860 0 : retmkmat2(mkcol2(pol0_Flx(v),pol1_Flx(v)),
1861 : mkcol2(pol1_Flx(v),pol0_Flx(v)));
1862 : }
1863 184846 : if (ly < lx) return Flx_halfgcd_i(x,y,p);
1864 2531 : av = avma;
1865 2531 : q = Flx_divrem(y,x,p,&r);
1866 2531 : M = Flx_halfgcd_i(x,r,p);
1867 2531 : gcoeff(M,1,1) = Flx_sub(gcoeff(M,1,1), Flx_mul(q, gcoeff(M,1,2), p), p);
1868 2531 : gcoeff(M,2,1) = Flx_sub(gcoeff(M,2,1), Flx_mul(q, gcoeff(M,2,2), p), p);
1869 2531 : return gerepilecopy(av, M);
1870 : }
1871 :
1872 : /*Do not garbage collect*/
1873 : static GEN
1874 29115879 : Flx_gcd_basecase(GEN a, GEN b, ulong p)
1875 : {
1876 29115879 : pari_sp av = avma;
1877 29115879 : ulong iter = 0;
1878 29115879 : if (lg(b) > lg(a)) swap(a, b);
1879 147987061 : while (lgpol(b))
1880 : {
1881 89871020 : GEN c = Flx_rem(a,b,p);
1882 89755303 : iter++; a = b; b = c;
1883 89755303 : if (gc_needed(av,2))
1884 : {
1885 0 : if (DEBUGMEM>1) pari_warn(warnmem,"Flx_gcd (d = %ld)",degpol(c));
1886 0 : gerepileall(av,2, &a,&b);
1887 : }
1888 : }
1889 29086943 : return iter < 2 ? Flx_copy(a) : a;
1890 : }
1891 :
1892 : GEN
1893 29828813 : Flx_gcd(GEN x, GEN y, ulong p)
1894 : {
1895 29828813 : pari_sp av = avma;
1896 29828813 : if (!lgpol(x)) return Flx_copy(y);
1897 58225481 : while (lg(y)>Flx_GCD_LIMIT)
1898 : {
1899 : GEN c;
1900 23 : if (lgpol(y)<=(lgpol(x)>>1))
1901 : {
1902 0 : GEN r = Flx_rem(x, y, p);
1903 0 : x = y; y = r;
1904 : }
1905 23 : c = FlxM_Flx_mul2(Flx_halfgcd(x,y, p), x, y, p);
1906 23 : x = gel(c,1); y = gel(c,2);
1907 23 : if (gc_needed(av,2))
1908 : {
1909 0 : if (DEBUGMEM>1) pari_warn(warnmem,"Flx_gcd (y = %ld)",degpol(y));
1910 0 : gerepileall(av,2,&x,&y);
1911 : }
1912 : }
1913 29112528 : return gerepileuptoleaf(av, Flx_gcd_basecase(x,y,p));
1914 : }
1915 :
1916 : int
1917 3501248 : Flx_is_squarefree(GEN z, ulong p)
1918 : {
1919 3501248 : pari_sp av = avma;
1920 3501248 : GEN d = Flx_gcd(z, Flx_deriv(z,p) , p);
1921 3501248 : long res= (degpol(d) == 0);
1922 3501248 : avma = av; return res;
1923 : }
1924 :
1925 : static long
1926 139333 : Flx_is_smooth_squarefree(GEN f, long r, ulong p)
1927 : {
1928 139333 : pari_sp av = avma;
1929 : long i;
1930 139333 : GEN sx = polx_Flx(f[1]), a = sx;
1931 594494 : for(i=1;;i++)
1932 : {
1933 1049847 : if (degpol(f)<=r) {avma = av; return 1;}
1934 568716 : a = Flxq_powu(Flx_rem(a,f,p), p, f, p);
1935 572645 : if (Flx_equal(a, sx)) {avma = av; return 1;}
1936 568089 : if (i==r) {avma = av; return 0;}
1937 456782 : f = Flx_div(f, Flx_gcd(Flx_sub(a,sx,p),f,p),p);
1938 : }
1939 : }
1940 :
1941 : static long
1942 9198 : Flx_is_l_pow(GEN x, ulong p)
1943 : {
1944 9198 : ulong i, lx = lgpol(x);
1945 18530 : for (i=1; i<lx; i++)
1946 16541 : if (x[i+2] && i%p) return 0;
1947 1989 : return 1;
1948 : }
1949 :
1950 : int
1951 130110 : Flx_is_smooth(GEN g, long r, ulong p)
1952 : {
1953 130110 : GEN f = gen_0;
1954 : while (1)
1955 : {
1956 148512 : f = Flx_gcd(g, Flx_deriv(g, p), p);
1957 139308 : if (!Flx_is_smooth_squarefree(Flx_div(g, f, p), r, p))
1958 111302 : return 0;
1959 28162 : if (degpol(f)==0) return 1;
1960 9197 : g = Flx_is_l_pow(f,p) ? Flx_deflate(f, p): f;
1961 : }
1962 : }
1963 :
1964 : static GEN
1965 3865676 : Flx_extgcd_basecase(GEN a, GEN b, ulong p, GEN *ptu, GEN *ptv)
1966 : {
1967 3865676 : pari_sp av=avma;
1968 : GEN u,v,d,d1,v1;
1969 3865676 : long vx = a[1];
1970 3865676 : d = a; d1 = b;
1971 3865676 : v = pol0_Flx(vx); v1 = pol1_Flx(vx);
1972 25542541 : while (lgpol(d1))
1973 : {
1974 17811189 : GEN r, q = Flx_divrem(d,d1,p, &r);
1975 17811189 : v = Flx_sub(v,Flx_mul(q,v1,p),p);
1976 17811189 : u=v; v=v1; v1=u;
1977 17811189 : u=r; d=d1; d1=u;
1978 17811189 : if (gc_needed(av,2))
1979 : {
1980 0 : if (DEBUGMEM>1) pari_warn(warnmem,"Flx_extgcd (d = %ld)",degpol(d));
1981 0 : gerepileall(av,5, &d,&d1,&u,&v,&v1);
1982 : }
1983 : }
1984 3865676 : if (ptu) *ptu = Flx_div(Flx_sub(d, Flx_mul(b,v,p), p), a, p);
1985 3865676 : *ptv = v; return d;
1986 : }
1987 :
1988 : static GEN
1989 3 : Flx_extgcd_halfgcd(GEN x, GEN y, ulong p, GEN *ptu, GEN *ptv)
1990 : {
1991 3 : pari_sp av=avma;
1992 3 : GEN u,v,R = matid2_FlxM(x[1]);
1993 9 : while (lg(y)>Flx_EXTGCD_LIMIT)
1994 : {
1995 : GEN M, c;
1996 3 : if (lgpol(y)<=(lgpol(x)>>1))
1997 : {
1998 0 : GEN r, q = Flx_divrem(x, y, p, &r);
1999 0 : x = y; y = r;
2000 0 : R = Flx_FlxM_qmul(q, R, p);
2001 : }
2002 3 : M = Flx_halfgcd(x,y, p);
2003 3 : c = FlxM_Flx_mul2(M, x,y, p);
2004 3 : R = FlxM_mul2(M, R, p);
2005 3 : x = gel(c,1); y = gel(c,2);
2006 3 : gerepileall(av,3,&x,&y,&R);
2007 : }
2008 3 : y = Flx_extgcd_basecase(x,y,p,&u,&v);
2009 3 : if (ptu) *ptu = Flx_addmulmul(u,v,gcoeff(R,1,1),gcoeff(R,2,1),p);
2010 3 : *ptv = Flx_addmulmul(u,v,gcoeff(R,1,2),gcoeff(R,2,2),p);
2011 3 : return y;
2012 : }
2013 :
2014 : /* x and y in Z[X], return lift(gcd(x mod p, y mod p)). Set u and v st
2015 : * ux + vy = gcd (mod p) */
2016 : GEN
2017 3865676 : Flx_extgcd(GEN x, GEN y, ulong p, GEN *ptu, GEN *ptv)
2018 : {
2019 : GEN d;
2020 3865676 : pari_sp ltop=avma;
2021 3865676 : if (lg(y)>Flx_EXTGCD_LIMIT)
2022 3 : d = Flx_extgcd_halfgcd(x, y, p, ptu, ptv);
2023 : else
2024 3865673 : d = Flx_extgcd_basecase(x, y, p, ptu, ptv);
2025 3865676 : gerepileall(ltop,ptu?3:2,&d,ptv,ptu);
2026 3865676 : return d;
2027 : }
2028 :
2029 : ulong
2030 1968401 : Flx_resultant(GEN a, GEN b, ulong p)
2031 : {
2032 : long da,db,dc,cnt;
2033 1968401 : ulong lb, res = 1UL;
2034 : pari_sp av;
2035 : GEN c;
2036 :
2037 1968401 : if (lgpol(a)==0 || lgpol(b)==0) return 0;
2038 1968380 : da = degpol(a);
2039 1968404 : db = degpol(b);
2040 1979694 : if (db > da)
2041 : {
2042 84689 : swapspec(a,b, da,db);
2043 84689 : if (both_odd(da,db)) res = p-res;
2044 : }
2045 1895005 : else if (!da) return 1; /* = res * a[2] ^ db, since 0 <= db <= da = 0 */
2046 1979689 : cnt = 0; av = avma;
2047 32181557 : while (db)
2048 : {
2049 28234145 : lb = b[db+2];
2050 28234145 : c = Flx_rem(a,b, p);
2051 28039607 : a = b; b = c; dc = degpol(c);
2052 28116026 : if (dc < 0) { avma = av; return 0; }
2053 :
2054 28115863 : if (both_odd(da,db)) res = p - res;
2055 28109226 : if (lb != 1) res = Fl_mul(res, Fl_powu(lb, da - dc, p), p);
2056 28222178 : if (++cnt == 100) { cnt = 0; gerepileall(av, 2, &a, &b); }
2057 28222179 : da = db; /* = degpol(a) */
2058 28222179 : db = dc; /* = degpol(b) */
2059 : }
2060 1967723 : avma = av; return Fl_mul(res, Fl_powu(b[2], da, p), p);
2061 : }
2062 :
2063 : /* If resultant is 0, *ptU and *ptU are not set */
2064 : ulong
2065 121024 : Flx_extresultant(GEN a, GEN b, ulong p, GEN *ptU, GEN *ptV)
2066 : {
2067 121024 : GEN z,q,u,v, x = a, y = b;
2068 121024 : ulong lb, res = 1UL;
2069 121024 : pari_sp av = avma;
2070 : long dx, dy, dz;
2071 121024 : long vs=a[1];
2072 :
2073 121024 : dx = degpol(x);
2074 121024 : dy = degpol(y);
2075 121024 : if (dy > dx)
2076 : {
2077 421 : swap(x,y); lswap(dx,dy); pswap(ptU, ptV);
2078 421 : a = x; b = y;
2079 421 : if (both_odd(dx,dy)) res = p-res;
2080 : }
2081 : /* dx <= dy */
2082 121024 : if (dx < 0) return 0;
2083 :
2084 121024 : u = pol0_Flx(vs);
2085 121024 : v = pol1_Flx(vs); /* v = 1 */
2086 805673 : while (dy)
2087 : { /* b u = x (a), b v = y (a) */
2088 563639 : lb = y[dy+2];
2089 563639 : q = Flx_divrem(x,y, p, &z);
2090 563625 : x = y; y = z; /* (x,y) = (y, x - q y) */
2091 563625 : dz = degpol(z); if (dz < 0) { avma = av; return 0; }
2092 563625 : z = Flx_sub(u, Flx_mul(q,v, p), p);
2093 563625 : u = v; v = z; /* (u,v) = (v, u - q v) */
2094 :
2095 563625 : if (both_odd(dx,dy)) res = p - res;
2096 563625 : if (lb != 1) res = Fl_mul(res, Fl_powu(lb, dx-dz, p), p);
2097 563625 : dx = dy; /* = degpol(x) */
2098 563625 : dy = dz; /* = degpol(y) */
2099 : }
2100 121010 : res = Fl_mul(res, Fl_powu(y[2], dx, p), p);
2101 121010 : lb = Fl_mul(res, Fl_inv(y[2],p), p);
2102 121010 : v = gerepileuptoleaf(av, Flx_Fl_mul(v, lb, p));
2103 121010 : av = avma;
2104 121010 : u = Flx_sub(Fl_to_Flx(res,vs), Flx_mul(b,v,p), p);
2105 121010 : u = gerepileuptoleaf(av, Flx_div(u,a,p)); /* = (res - b v) / a */
2106 121010 : *ptU = u;
2107 121010 : *ptV = v; return res;
2108 : }
2109 :
2110 : ulong
2111 30290219 : Flx_eval_powers_pre(GEN x, GEN y, ulong p, ulong pi)
2112 : {
2113 30290219 : ulong l0, l1, h0, h1, v1, i = 1, lx = lg(x)-1;
2114 : LOCAL_OVERFLOW;
2115 : LOCAL_HIREMAINDER;
2116 30290219 : x++;
2117 :
2118 30290219 : if (lx == 1)
2119 3132365 : return 0;
2120 27157854 : l1 = mulll(uel(x,i), uel(y,i)); h1 = hiremainder; v1 = 0;
2121 89094652 : while (++i < lx) {
2122 34778944 : l0 = mulll(uel(x,i), uel(y,i)); h0 = hiremainder;
2123 34778944 : l1 = addll(l0, l1); h1 = addllx(h0, h1); v1 += overflow;
2124 : }
2125 27157854 : if (v1 == 0) return remll_pre(h1, l1, p, pi);
2126 5514 : else return remlll_pre(v1, h1, l1, p, pi);
2127 : }
2128 :
2129 : INLINE ulong
2130 3325196 : Flx_eval_pre_i(GEN x, ulong y, ulong p, ulong pi)
2131 : {
2132 : ulong p1;
2133 3325196 : long i=lg(x)-1;
2134 3325196 : if (i<=2)
2135 1437411 : return (i==2)? x[2]: 0;
2136 1887785 : p1 = x[i];
2137 8943727 : for (i--; i>=2; i--)
2138 7057104 : p1 = Fl_addmul_pre(uel(x, i), p1, y, p, pi);
2139 1886623 : return p1;
2140 : }
2141 :
2142 : ulong
2143 3401097 : Flx_eval_pre(GEN x, ulong y, ulong p, ulong pi)
2144 : {
2145 3401097 : if (degpol(x) > 15)
2146 : {
2147 79134 : pari_sp av = avma;
2148 79134 : GEN v = Fl_powers_pre(y, degpol(x), p, pi);
2149 79199 : ulong r = Flx_eval_powers_pre(x, v, p, pi);
2150 79180 : avma = av;
2151 79180 : return r;
2152 : }
2153 : else
2154 3322017 : return Flx_eval_pre_i(x, y, p, pi);
2155 : }
2156 :
2157 : ulong
2158 3395161 : Flx_eval(GEN x, ulong y, ulong p)
2159 : {
2160 3395161 : return Flx_eval_pre(x, y, p, get_Fl_red(p));
2161 : }
2162 :
2163 : ulong
2164 3073 : Flv_prod_pre(GEN x, ulong p, ulong pi)
2165 : {
2166 3073 : pari_sp ltop = avma;
2167 : GEN v;
2168 3073 : long i,k,lx = lg(x);
2169 : ulong r;
2170 3073 : if (lx == 1) return 1UL;
2171 3073 : if (lx == 2) return uel(x,1);
2172 2884 : v = cgetg(1+(lx << 1), t_VECSMALL);
2173 2884 : k = 1;
2174 27244 : for (i=1; i<lx-1; i+=2)
2175 24360 : uel(v,k++) = Fl_mul_pre(uel(x,i), uel(x,i+1), p, pi);
2176 2884 : if (i < lx) uel(v,k++) = uel(x,i);
2177 15848 : while (k > 2)
2178 : {
2179 10080 : lx = k; k = 1;
2180 34440 : for (i=1; i<lx-1; i+=2)
2181 24360 : uel(v,k++) = Fl_mul_pre(uel(v,i), uel(v,i+1), p, pi);
2182 10080 : if (i < lx) uel(v,k++) = uel(v,i);
2183 : }
2184 2884 : r = uel(v,1);
2185 2884 : avma = ltop; return r;
2186 : }
2187 :
2188 : ulong
2189 0 : Flv_prod(GEN v, ulong p)
2190 : {
2191 0 : return Flv_prod_pre(v, p, get_Fl_red(p));
2192 : }
2193 :
2194 : GEN
2195 0 : FlxV_prod(GEN V, ulong p)
2196 : {
2197 : struct _Flxq D;
2198 0 : D.T = NULL; D.aut = NULL; D.p = p;
2199 0 : return gen_product(V, (void *)&D, &_Flx_mul);
2200 : }
2201 :
2202 : /* compute prod (x - a[i]) */
2203 : GEN
2204 616014 : Flv_roots_to_pol(GEN a, ulong p, long vs)
2205 : {
2206 : struct _Flxq D;
2207 616014 : long i,k,lx = lg(a);
2208 : GEN p1;
2209 616014 : if (lx == 1) return pol1_Flx(vs);
2210 616014 : p1 = cgetg(lx, t_VEC);
2211 10240356 : for (k=1,i=1; i<lx-1; i+=2)
2212 19248132 : gel(p1,k++) = mkvecsmall4(vs, Fl_mul(a[i], a[i+1], p),
2213 9624491 : Fl_neg(Fl_add(a[i],a[i+1],p),p), 1);
2214 615865 : if (i < lx)
2215 52211 : gel(p1,k++) = mkvecsmall3(vs, Fl_neg(a[i],p), 1);
2216 615865 : D.T = NULL; D.aut = NULL; D.p = p;
2217 615865 : setlg(p1, k); return gen_product(p1, (void *)&D, _Flx_mul);
2218 : }
2219 :
2220 : INLINE void
2221 10297526 : Flv_inv_pre_indir(GEN w, GEN v, ulong p, ulong pi)
2222 : {
2223 10297526 : pari_sp av = avma;
2224 : GEN c;
2225 : register ulong u;
2226 10297526 : register long n = lg(w), i;
2227 :
2228 10297526 : if (n == 1)
2229 0 : return;
2230 :
2231 10297526 : c = cgetg(n, t_VECSMALL);
2232 10297527 : c[1] = w[1];
2233 56478910 : for (i = 2; i < n; ++i)
2234 46181383 : c[i] = Fl_mul_pre(w[i], c[i - 1], p, pi);
2235 :
2236 10297527 : i = n - 1;
2237 10297527 : u = Fl_inv(c[i], p);
2238 56478746 : for ( ; i > 1; --i) {
2239 46181219 : ulong t = Fl_mul_pre(u, c[i - 1], p, pi);
2240 46181214 : u = Fl_mul_pre(u, w[i], p, pi);
2241 46181199 : v[i] = t;
2242 : }
2243 10297527 : v[1] = u;
2244 10297527 : avma = av;
2245 : }
2246 :
2247 : void
2248 10265543 : Flv_inv_pre_inplace(GEN v, ulong p, ulong pi)
2249 : {
2250 10265543 : Flv_inv_pre_indir(v, v, p, pi);
2251 10265543 : }
2252 :
2253 : GEN
2254 10737 : Flv_inv_pre(GEN w, ulong p, ulong pi)
2255 : {
2256 10737 : GEN v = cgetg(lg(w), t_VECSMALL);
2257 10737 : Flv_inv_pre_indir(w, v, p, pi);
2258 10737 : return v;
2259 : }
2260 :
2261 : INLINE void
2262 29191 : Flv_inv_indir(GEN w, GEN v, ulong p)
2263 : {
2264 29191 : pari_sp av = avma;
2265 : GEN c;
2266 : register ulong u;
2267 29191 : register long n = lg(w), i;
2268 :
2269 29191 : if (n == 1)
2270 0 : return;
2271 :
2272 29191 : c = cgetg(n, t_VECSMALL);
2273 29186 : c[1] = w[1];
2274 368369 : for (i = 2; i < n; ++i)
2275 339179 : c[i] = Fl_mul(w[i], c[i - 1], p);
2276 :
2277 29190 : i = n - 1;
2278 29190 : u = Fl_inv(c[i], p);
2279 368386 : for ( ; i > 1; --i) {
2280 339195 : ulong t = Fl_mul(u, c[i - 1], p);
2281 339193 : u = Fl_mul(u, w[i], p);
2282 339191 : v[i] = t;
2283 : }
2284 29191 : v[1] = u;
2285 29191 : avma = av;
2286 : }
2287 :
2288 : void
2289 0 : Flv_inv_inplace(GEN v, ulong p)
2290 : {
2291 0 : if (SMALL_ULONG(p))
2292 0 : Flv_inv_indir(v, v, p);
2293 : else
2294 0 : Flv_inv_pre_indir(v, v, p, get_Fl_red(p));
2295 0 : }
2296 :
2297 : GEN
2298 50437 : Flv_inv(GEN w, ulong p)
2299 : {
2300 50437 : GEN v = cgetg(lg(w), t_VECSMALL);
2301 50437 : if (SMALL_ULONG(p))
2302 29191 : Flv_inv_indir(w, v, p);
2303 : else
2304 21246 : Flv_inv_pre_indir(w, v, p, get_Fl_red(p));
2305 50438 : return v;
2306 : }
2307 :
2308 : GEN
2309 28679783 : Flx_div_by_X_x(GEN a, ulong x, ulong p, ulong *rem)
2310 : {
2311 28679783 : long l = lg(a), i;
2312 : GEN a0, z0;
2313 28679783 : GEN z = cgetg(l-1,t_VECSMALL);
2314 28631082 : z[1] = a[1];
2315 28631082 : a0 = a + l-1;
2316 28631082 : z0 = z + l-2; *z0 = *a0--;
2317 28631082 : if (SMALL_ULONG(p))
2318 : {
2319 70129532 : for (i=l-3; i>1; i--) /* z[i] = (a[i+1] + x*z[i+1]) % p */
2320 : {
2321 52561562 : ulong t = (*a0-- + x * *z0--) % p;
2322 52561562 : *z0 = (long)t;
2323 : }
2324 17567970 : if (rem) *rem = (*a0 + x * *z0) % p;
2325 : }
2326 : else
2327 : {
2328 43399927 : for (i=l-3; i>1; i--)
2329 : {
2330 32312706 : ulong t = Fl_add((ulong)*a0--, Fl_mul(x, *z0--, p), p);
2331 32336815 : *z0 = (long)t;
2332 : }
2333 11087221 : if (rem) *rem = Fl_add((ulong)*a0, Fl_mul(x, *z0, p), p);
2334 : }
2335 28649584 : return z;
2336 : }
2337 :
2338 : /* xa, ya = t_VECSMALL */
2339 : static GEN
2340 50436 : Flv_producttree(GEN xa, GEN s, ulong p, long vs)
2341 : {
2342 50436 : long n = lg(xa)-1;
2343 50436 : long m = n==1 ? 1: expu(n-1)+1;
2344 50435 : long i, j, k, ls = lg(s);
2345 50435 : GEN T = cgetg(m+1, t_VEC);
2346 50433 : GEN t = cgetg(ls, t_VEC);
2347 611982 : for (j=1, k=1; j<ls; k+=s[j++])
2348 1123100 : gel(t, j) = s[j] == 1 ?
2349 764537 : mkvecsmall3(vs, Fl_neg(xa[k], p), 1):
2350 202982 : mkvecsmall4(vs, Fl_mul(xa[k], xa[k+1], p),
2351 202982 : Fl_neg(Fl_add(xa[k],xa[k+1],p),p), 1);
2352 50433 : gel(T,1) = t;
2353 190600 : for (i=2; i<=m; i++)
2354 : {
2355 140167 : GEN u = gel(T, i-1);
2356 140167 : long n = lg(u)-1;
2357 140167 : GEN t = cgetg(((n+1)>>1)+1, t_VEC);
2358 651034 : for (j=1, k=1; k<n; j++, k+=2)
2359 510867 : gel(t, j) = Flx_mul(gel(u, k), gel(u, k+1), p);
2360 140167 : gel(T, i) = t;
2361 : }
2362 50433 : return T;
2363 : }
2364 :
2365 : static GEN
2366 50430 : Flx_Flv_multieval_tree(GEN P, GEN xa, GEN T, ulong p)
2367 : {
2368 : long i,j,k;
2369 50430 : long m = lg(T)-1;
2370 : GEN t;
2371 50430 : GEN R = cgetg(lg(xa), t_VECSMALL);
2372 50424 : GEN Tp = cgetg(m+1, t_VEC);
2373 50424 : gel(Tp, m) = mkvec(P);
2374 190589 : for (i=m-1; i>=1; i--)
2375 : {
2376 140158 : GEN u = gel(T, i);
2377 140158 : GEN v = gel(Tp, i+1);
2378 140158 : long n = lg(u)-1;
2379 140158 : t = cgetg(n+1, t_VEC);
2380 651059 : for (j=1, k=1; k<n; j++, k+=2)
2381 : {
2382 510891 : gel(t, k) = Flx_rem(gel(v, j), gel(u, k), p);
2383 510879 : gel(t, k+1) = Flx_rem(gel(v, j), gel(u, k+1), p);
2384 : }
2385 140168 : gel(Tp, i) = t;
2386 : }
2387 : {
2388 50431 : GEN u = gel(T, i+1);
2389 50431 : GEN v = gel(Tp, i+1);
2390 50431 : long n = lg(u)-1;
2391 611978 : for (j=1, k=1; j<=n; j++)
2392 : {
2393 561539 : long c, d = degpol(gel(u,j));
2394 1325939 : for (c=1; c<=d; c++, k++)
2395 764392 : R[k] = Flx_eval(gel(v, j), xa[k], p);
2396 : }
2397 50439 : avma = (pari_sp) R;
2398 50439 : return R;
2399 : }
2400 : }
2401 :
2402 : static GEN
2403 740841 : FlvV_polint_tree(GEN T, GEN R, GEN s, GEN xa, GEN ya, ulong p, long vs)
2404 : {
2405 740841 : pari_sp av = avma;
2406 740841 : long m = lg(T)-1;
2407 740841 : long i, j, k, ls = lg(s);
2408 740841 : GEN Tp = cgetg(m+1, t_VEC);
2409 740547 : GEN t = cgetg(ls, t_VEC);
2410 12973680 : for (j=1, k=1; j<ls; k+=s[j++])
2411 12233097 : if (s[j]==2)
2412 : {
2413 4188513 : ulong a = Fl_mul(ya[k], R[k], p);
2414 4204958 : ulong b = Fl_mul(ya[k+1], R[k+1], p);
2415 12621562 : gel(t, j) = mkvecsmall3(vs, Fl_neg(Fl_add(Fl_mul(xa[k], b, p ),
2416 8414474 : Fl_mul(xa[k+1], a, p), p), p), Fl_add(a, b, p));
2417 4205291 : gel(t, j) = Flx_renormalize(gel(t, j), 4);
2418 : }
2419 : else
2420 8044584 : gel(t, j) = Fl_to_Flx(Fl_mul(ya[k], R[k], p), vs);
2421 740583 : gel(Tp, 1) = t;
2422 3291277 : for (i=2; i<=m; i++)
2423 : {
2424 2550713 : GEN u = gel(T, i-1);
2425 2550713 : GEN t = cgetg(lg(gel(T,i)), t_VEC);
2426 2548950 : GEN v = gel(Tp, i-1);
2427 2548950 : long n = lg(v)-1;
2428 13997300 : for (j=1, k=1; k<n; j++, k+=2)
2429 34339818 : gel(t, j) = Flx_add(Flx_mul(gel(u, k), gel(v, k+1), p),
2430 22893212 : Flx_mul(gel(u, k+1), gel(v, k), p), p);
2431 2550694 : gel(Tp, i) = t;
2432 : }
2433 740564 : return gerepileuptoleaf(av, gmael(Tp,m,1));
2434 : }
2435 :
2436 : GEN
2437 0 : Flx_Flv_multieval(GEN P, GEN xa, ulong p)
2438 : {
2439 0 : pari_sp av = avma;
2440 0 : GEN s = producttree_scheme(lg(xa)-1);
2441 0 : GEN T = Flv_producttree(xa, s, p, P[1]);
2442 0 : return gerepileuptoleaf(av, Flx_Flv_multieval_tree(P, xa, T, p));
2443 : }
2444 :
2445 : GEN
2446 12019 : Flv_polint(GEN xa, GEN ya, ulong p, long vs)
2447 : {
2448 12019 : pari_sp av = avma;
2449 12019 : GEN s = producttree_scheme(lg(xa)-1);
2450 12019 : GEN T = Flv_producttree(xa, s, p, vs);
2451 12020 : long m = lg(T)-1;
2452 12020 : GEN P = Flx_deriv(gmael(T, m, 1), p);
2453 12019 : GEN R = Flv_inv(Flx_Flv_multieval_tree(P, xa, T, p), p);
2454 12021 : return gerepileuptoleaf(av, FlvV_polint_tree(T, R, s, xa, ya, p, vs));
2455 : }
2456 :
2457 : GEN
2458 35285 : Flv_Flm_polint(GEN xa, GEN ya, ulong p, long vs)
2459 : {
2460 35285 : pari_sp av = avma;
2461 35285 : GEN s = producttree_scheme(lg(xa)-1);
2462 35288 : GEN T = Flv_producttree(xa, s, p, vs);
2463 35283 : long i, m = lg(T)-1, l = lg(ya)-1;
2464 35283 : GEN P = Flx_deriv(gmael(T, m, 1), p);
2465 35283 : GEN R = Flv_inv(Flx_Flv_multieval_tree(P, xa, T, p), p);
2466 35287 : GEN M = cgetg(l+1, t_VEC);
2467 764119 : for (i=1; i<=l; i++)
2468 728838 : gel(M,i) = FlvV_polint_tree(T, R, s, xa, gel(ya,i), p, vs);
2469 35281 : return gerepileupto(av, M);
2470 : }
2471 :
2472 : GEN
2473 3130 : Flv_invVandermonde(GEN L, ulong den, ulong p)
2474 : {
2475 3130 : pari_sp av = avma;
2476 3130 : long i, n = lg(L);
2477 : GEN M, R;
2478 3130 : GEN s = producttree_scheme(n-1);
2479 3130 : GEN tree = Flv_producttree(L, s, p, 0);
2480 3130 : long m = lg(tree)-1;
2481 3130 : GEN T = gmael(tree, m, 1);
2482 3130 : R = Flv_inv(Flx_Flv_multieval_tree(Flx_deriv(T, p), L, tree, p), p);
2483 3130 : if (den!=1) R = Flv_Fl_mul(R, den, p);
2484 3130 : M = cgetg(n, t_MAT);
2485 14128 : for (i = 1; i < n; i++)
2486 : {
2487 10998 : GEN P = Flx_Fl_mul(Flx_div_by_X_x(T, uel(L,i), p, NULL), uel(R,i), p);
2488 10998 : gel(M,i) = Flx_to_Flv(P, n-1);
2489 : }
2490 3130 : return gerepilecopy(av, M);
2491 : }
2492 :
2493 : /***********************************************************************/
2494 : /** **/
2495 : /** Flxq **/
2496 : /** **/
2497 : /***********************************************************************/
2498 : /* Flxq objects are defined as follows:
2499 : They are Flx modulo another Flx called q.
2500 : */
2501 :
2502 : /* Product of y and x in Z/pZ[X]/(T), as t_VECSMALL. */
2503 : GEN
2504 124213183 : Flxq_mul(GEN x,GEN y,GEN T,ulong p)
2505 : {
2506 124213183 : return Flx_rem(Flx_mul(x,y,p),T,p);
2507 : }
2508 :
2509 : /* Square of y in Z/pZ[X]/(T), as t_VECSMALL. */
2510 : GEN
2511 185717272 : Flxq_sqr(GEN x,GEN T,ulong p)
2512 : {
2513 185717272 : return Flx_rem(Flx_sqr(x,p),T,p);
2514 : }
2515 :
2516 : static GEN
2517 10457733 : _Flxq_red(void *E, GEN x)
2518 10457733 : { struct _Flxq *s = (struct _Flxq *)E;
2519 10457733 : return Flx_rem(x, s->T, s->p); }
2520 : static GEN
2521 0 : _Flx_sub(void *E, GEN x, GEN y)
2522 0 : { struct _Flxq *s = (struct _Flxq *)E;
2523 0 : return Flx_sub(x,y,s->p); }
2524 : static GEN
2525 180039296 : _Flxq_sqr(void *data, GEN x)
2526 : {
2527 180039296 : struct _Flxq *D = (struct _Flxq*)data;
2528 180039296 : return Flxq_sqr(x, D->T, D->p);
2529 : }
2530 : static GEN
2531 106393804 : _Flxq_mul(void *data, GEN x, GEN y)
2532 : {
2533 106393804 : struct _Flxq *D = (struct _Flxq*)data;
2534 106393804 : return Flxq_mul(x,y, D->T, D->p);
2535 : }
2536 : static GEN
2537 12205885 : _Flxq_one(void *data)
2538 : {
2539 12205885 : struct _Flxq *D = (struct _Flxq*)data;
2540 12205885 : return pol1_Flx(get_Flx_var(D->T));
2541 : }
2542 : static GEN
2543 196641 : _Flxq_zero(void *data)
2544 : {
2545 196641 : struct _Flxq *D = (struct _Flxq*)data;
2546 196641 : return pol0_Flx(get_Flx_var(D->T));
2547 : }
2548 : static GEN
2549 28693689 : _Flxq_cmul(void *data, GEN P, long a, GEN x)
2550 : {
2551 28693689 : struct _Flxq *D = (struct _Flxq*)data;
2552 28693689 : return Flx_Fl_mul(x, P[a+2], D->p);
2553 : }
2554 :
2555 : /* n-Power of x in Z/pZ[X]/(T), as t_VECSMALL. */
2556 : GEN
2557 11113197 : Flxq_powu(GEN x, ulong n, GEN T, ulong p)
2558 : {
2559 11113197 : pari_sp av = avma;
2560 : struct _Flxq D;
2561 : GEN y;
2562 11113197 : switch(n)
2563 : {
2564 0 : case 0: return pol1_Flx(T[1]);
2565 47637 : case 1: return Flx_copy(x);
2566 141584 : case 2: return Flxq_sqr(x, T, p);
2567 : }
2568 10923976 : D.T = Flx_get_red(T, p); D.p = p;
2569 10921083 : y = gen_powu_i(x, n, (void*)&D, &_Flxq_sqr, &_Flxq_mul);
2570 10917870 : return gerepileuptoleaf(av, y);
2571 : }
2572 :
2573 : /* n-Power of x in Z/pZ[X]/(T), as t_VECSMALL. */
2574 : GEN
2575 22992686 : Flxq_pow(GEN x, GEN n, GEN T, ulong p)
2576 : {
2577 22992686 : pari_sp av = avma;
2578 : struct _Flxq D;
2579 : GEN y;
2580 22992686 : long s = signe(n);
2581 22992686 : if (!s) return pol1_Flx(get_Flx_var(T));
2582 22799634 : if (s < 0)
2583 592106 : x = Flxq_inv(x,T,p);
2584 22799634 : if (is_pm1(n)) return s < 0 ? x : Flx_copy(x);
2585 22016958 : D.T = Flx_get_red(T, p); D.p = p;
2586 22016958 : y = gen_pow_i(x, n, (void*)&D, &_Flxq_sqr, &_Flxq_mul);
2587 22016958 : return gerepileuptoleaf(av, y);
2588 : }
2589 :
2590 : GEN
2591 28 : Flxq_pow_init(GEN x, GEN n, long k, GEN T, ulong p)
2592 : {
2593 : struct _Flxq D;
2594 28 : D.T = Flx_get_red(T, p); D.p = p;
2595 28 : return gen_pow_init(x, n, k, (void*)&D, &_Flxq_sqr, &_Flxq_mul);
2596 : }
2597 :
2598 : GEN
2599 4398 : Flxq_pow_table(GEN R, GEN n, GEN T, ulong p)
2600 : {
2601 : struct _Flxq D;
2602 4398 : D.T = Flx_get_red(T, p); D.p = p;
2603 4398 : return gen_pow_table(R, n, (void*)&D, &_Flxq_one, &_Flxq_mul);
2604 : }
2605 :
2606 : /* Inverse of x in Z/lZ[X]/(T) or NULL if inverse doesn't exist
2607 : * not stack clean.
2608 : */
2609 : GEN
2610 3733745 : Flxq_invsafe(GEN x, GEN T, ulong p)
2611 : {
2612 3733745 : GEN V, z = Flx_extgcd(get_Flx_mod(T), x, p, NULL, &V);
2613 : ulong iz;
2614 3733745 : if (degpol(z)) return NULL;
2615 3733717 : iz = Fl_inv (uel(z,2), p);
2616 3733717 : return Flx_Fl_mul(V, iz, p);
2617 : }
2618 :
2619 : GEN
2620 3679216 : Flxq_inv(GEN x,GEN T,ulong p)
2621 : {
2622 3679216 : pari_sp av=avma;
2623 3679216 : GEN U = Flxq_invsafe(x, T, p);
2624 3679216 : if (!U) pari_err_INV("Flxq_inv",Flx_to_ZX(x));
2625 3679188 : return gerepileuptoleaf(av, U);
2626 : }
2627 :
2628 : GEN
2629 1940467 : Flxq_div(GEN x,GEN y,GEN T,ulong p)
2630 : {
2631 1940467 : pari_sp av = avma;
2632 1940467 : return gerepileuptoleaf(av, Flxq_mul(x,Flxq_inv(y,T,p),T,p));
2633 : }
2634 :
2635 : GEN
2636 3164686 : Flxq_powers(GEN x, long l, GEN T, ulong p)
2637 : {
2638 : struct _Flxq D;
2639 3164686 : int use_sqr = 2*degpol(x) >= get_Flx_degree(T);
2640 3164686 : D.T = Flx_get_red(T, p); D.p = p;
2641 3164684 : return gen_powers(x, l, use_sqr, (void*)&D, &_Flxq_sqr, &_Flxq_mul, &_Flxq_one);
2642 : }
2643 :
2644 : GEN
2645 33068 : Flxq_matrix_pow(GEN y, long n, long m, GEN P, ulong l)
2646 : {
2647 33068 : return FlxV_to_Flm(Flxq_powers(y,m-1,P,l),n);
2648 : }
2649 :
2650 : GEN
2651 3802543 : Flx_Frobenius(GEN T, ulong p)
2652 : {
2653 3802543 : return Flxq_powu(polx_Flx(get_Flx_var(T)), p, T, p);
2654 : }
2655 :
2656 : GEN
2657 16968 : Flx_matFrobenius(GEN T, ulong p)
2658 : {
2659 16968 : long n = get_Flx_degree(T);
2660 16968 : return Flxq_matrix_pow(Flx_Frobenius(T, p), n, n, T, p);
2661 : }
2662 :
2663 : static struct bb_algebra Flxq_algebra = { _Flxq_red, _Flx_add, _Flx_sub,
2664 : _Flxq_mul, _Flxq_sqr, _Flxq_one, _Flxq_zero};
2665 :
2666 : GEN
2667 3577457 : Flx_FlxqV_eval(GEN Q, GEN x, GEN T, ulong p)
2668 : {
2669 : struct _Flxq D;
2670 3577457 : D.T = Flx_get_red(T, p); D.p=p;
2671 3577448 : return gen_bkeval_powers(Q,degpol(Q),x,(void*)&D,&Flxq_algebra,_Flxq_cmul);
2672 : }
2673 :
2674 : GEN
2675 1005885 : Flx_Flxq_eval(GEN Q, GEN x, GEN T, ulong p)
2676 : {
2677 1005885 : int use_sqr = 2*degpol(x) >= get_Flx_degree(T);
2678 : struct _Flxq D;
2679 1005885 : D.T = Flx_get_red(T, p); D.p=p;
2680 1005885 : return gen_bkeval(Q,degpol(Q),x,use_sqr,(void*)&D,&Flxq_algebra,_Flxq_cmul);
2681 : }
2682 :
2683 : static GEN
2684 377937 : Flxq_autpow_sqr(void *E, GEN x)
2685 : {
2686 377937 : struct _Flxq *D = (struct _Flxq*)E;
2687 377937 : return Flx_Flxq_eval(x, x, D->T, D->p);
2688 : }
2689 : static GEN
2690 20676 : Flxq_autpow_mul(void *E, GEN x, GEN y)
2691 : {
2692 20676 : struct _Flxq *D = (struct _Flxq*)E;
2693 20676 : return Flx_Flxq_eval(x, y, D->T, D->p);
2694 : }
2695 :
2696 : GEN
2697 304563 : Flxq_autpow(GEN x, ulong n, GEN T, ulong p)
2698 : {
2699 : struct _Flxq D;
2700 304563 : D.T = Flx_get_red(T, p); D.p = p;
2701 304563 : if (n==0) return polx_Flx(T[1]);
2702 304556 : if (n==1) return Flx_copy(x);
2703 304087 : return gen_powu(x,n,(void*)&D,Flxq_autpow_sqr,Flxq_autpow_mul);
2704 : }
2705 :
2706 : static GEN
2707 613916 : Flxq_autsum_mul(void *E, GEN x, GEN y)
2708 : {
2709 613916 : struct _Flxq *D = (struct _Flxq*)E;
2710 613916 : GEN T = D->T;
2711 613916 : ulong p = D->p;
2712 613916 : GEN phi1 = gel(x,1), a1 = gel(x,2);
2713 613916 : GEN phi2 = gel(y,1), a2 = gel(y,2);
2714 613916 : ulong d = brent_kung_optpow(maxss(degpol(phi1),degpol(a1)),2,1);
2715 613916 : GEN V2 = Flxq_powers(phi2, d, T, p);
2716 613916 : GEN phi3 = Flx_FlxqV_eval(phi1, V2, T, p);
2717 613916 : GEN aphi = Flx_FlxqV_eval(a1, V2, T, p);
2718 613916 : GEN a3 = Flxq_mul(aphi, a2, T, p);
2719 613916 : return mkvec2(phi3, a3);
2720 : }
2721 : static GEN
2722 365750 : Flxq_autsum_sqr(void *E, GEN x)
2723 365750 : { return Flxq_autsum_mul(E, x, x); }
2724 :
2725 : GEN
2726 306720 : Flxq_autsum(GEN x, ulong n, GEN T, ulong p)
2727 : {
2728 : struct _Flxq D;
2729 306720 : D.T = Flx_get_red(T, p); D.p = p;
2730 306720 : return gen_powu(x,n,(void*)&D,Flxq_autsum_sqr,Flxq_autsum_mul);
2731 : }
2732 :
2733 : static GEN
2734 213162 : Flxq_auttrace_mul(void *E, GEN x, GEN y)
2735 : {
2736 213162 : struct _Flxq *D = (struct _Flxq*)E;
2737 213162 : GEN T = D->T;
2738 213162 : ulong p = D->p;
2739 213162 : GEN phi1 = gel(x,1), a1 = gel(x,2);
2740 213162 : GEN phi2 = gel(y,1), a2 = gel(y,2);
2741 213162 : ulong d = brent_kung_optpow(maxss(degpol(phi1),degpol(a1)),2,1);
2742 213163 : GEN V1 = Flxq_powers(phi1, d, T, p);
2743 213162 : GEN phi3 = Flx_FlxqV_eval(phi2, V1, T, p);
2744 213163 : GEN aphi = Flx_FlxqV_eval(a2, V1, T, p);
2745 213162 : GEN a3 = Flx_add(a1, aphi, p);
2746 213156 : return mkvec2(phi3, a3);
2747 : }
2748 :
2749 : static GEN
2750 167712 : Flxq_auttrace_sqr(void *E, GEN x)
2751 167712 : { return Flxq_auttrace_mul(E, x, x); }
2752 :
2753 : GEN
2754 220668 : Flxq_auttrace(GEN x, ulong n, GEN T, ulong p)
2755 : {
2756 : struct _Flxq D;
2757 220668 : D.T = Flx_get_red(T, p); D.p = p;
2758 220668 : return gen_powu(x,n,(void*)&D,Flxq_auttrace_sqr,Flxq_auttrace_mul);
2759 : }
2760 :
2761 : static long
2762 664300 : bounded_order(ulong p, GEN b, long k)
2763 : {
2764 : long i;
2765 664300 : GEN a=modii(utoi(p),b);
2766 1690618 : for(i=1;i<k;i++)
2767 : {
2768 1400768 : if (equali1(a))
2769 374450 : return i;
2770 1026318 : a = modii(muliu(a,p),b);
2771 : }
2772 289850 : return 0;
2773 : }
2774 :
2775 : /*
2776 : n = (p^d-a)\b
2777 : b = bb*p^vb
2778 : p^k = 1 [bb]
2779 : d = m*k+r+vb
2780 : u = (p^k-1)/bb;
2781 : v = (p^(r+vb)-a)/b;
2782 : w = (p^(m*k)-1)/(p^k-1)
2783 : n = p^r*w*u+v
2784 : w*u = p^vb*(p^(m*k)-1)/b
2785 : n = p^(r+vb)*(p^(m*k)-1)/b+(p^(r+vb)-a)/b
2786 : */
2787 :
2788 : static GEN
2789 22761571 : Flxq_pow_Frobenius(GEN x, GEN n, GEN aut, GEN T, ulong p)
2790 : {
2791 22761571 : pari_sp av=avma;
2792 22761571 : long d = get_Flx_degree(T);
2793 22761571 : GEN an = absi_shallow(n), z, q;
2794 22761571 : if (abscmpiu(an,p)<0 || cmpis(an,d)<=0) return Flxq_pow(x, n, T, p);
2795 665153 : q = powuu(p, d);
2796 665153 : if (dvdii(q, n))
2797 : {
2798 804 : long vn = logint(an,utoi(p));
2799 804 : GEN autvn = vn==1 ? aut: Flxq_autpow(aut,vn,T,p);
2800 804 : z = Flx_Flxq_eval(x,autvn,T,p);
2801 : } else
2802 : {
2803 664349 : GEN b = diviiround(q, an), a = subii(q, mulii(an,b));
2804 : GEN bb, u, v, autk;
2805 664349 : long vb = Z_lvalrem(b,p,&bb);
2806 664349 : long m, r, k = is_pm1(bb) ? 1 : bounded_order(p,bb,d);
2807 664349 : if (!k || d-vb<k) return Flxq_pow(x,n, T, p);
2808 374492 : m = (d-vb)/k; r = (d-vb)%k;
2809 374492 : u = diviiexact(subiu(powuu(p,k),1),bb);
2810 374492 : v = diviiexact(subii(powuu(p,r+vb),a),b);
2811 374492 : autk = k==1 ? aut: Flxq_autpow(aut,k,T,p);
2812 374492 : if (r)
2813 : {
2814 93723 : GEN autr = r==1 ? aut: Flxq_autpow(aut,r,T,p);
2815 93723 : z = Flx_Flxq_eval(x,autr,T,p);
2816 280769 : } else z = x;
2817 374492 : if (m > 1) z = gel(Flxq_autsum(mkvec2(autk, z), m, T, p), 2);
2818 374492 : if (!is_pm1(u)) z = Flxq_pow(z, u, T, p);
2819 374492 : if (signe(v)) z = Flxq_mul(z, Flxq_pow(x, v, T, p), T, p);
2820 : }
2821 375296 : return gerepileupto(av,signe(n)>0 ? z : Flxq_inv(z,T,p));
2822 : }
2823 :
2824 : static GEN
2825 22743033 : _Flxq_pow(void *data, GEN x, GEN n)
2826 : {
2827 22743033 : struct _Flxq *D = (struct _Flxq*)data;
2828 22743033 : return Flxq_pow_Frobenius(x, n, D->aut, D->T, D->p);
2829 : }
2830 :
2831 : static GEN
2832 317717 : _Flxq_rand(void *data)
2833 : {
2834 317717 : pari_sp av=avma;
2835 317717 : struct _Flxq *D = (struct _Flxq*)data;
2836 : GEN z;
2837 : do
2838 : {
2839 320722 : avma = av;
2840 320722 : z = random_Flx(get_Flx_degree(D->T),get_Flx_var(D->T),D->p);
2841 320722 : } while (lgpol(z)==0);
2842 317717 : return z;
2843 : }
2844 :
2845 : /* discrete log in FpXQ for a in Fp^*, g in FpXQ^* of order ord */
2846 : static GEN
2847 10919 : Fl_Flxq_log(ulong a, GEN g, GEN o, GEN T, ulong p)
2848 : {
2849 10919 : pari_sp av = avma;
2850 : GEN q,n_q,ord,ordp, op;
2851 :
2852 10919 : if (a == 1UL) return gen_0;
2853 : /* p > 2 */
2854 :
2855 10919 : ordp = utoi(p - 1);
2856 10919 : ord = get_arith_Z(o);
2857 10919 : if (!ord) ord = T? subiu(powuu(p, get_FpX_degree(T)), 1): ordp;
2858 10919 : if (a == p - 1) /* -1 */
2859 761 : return gerepileuptoint(av, shifti(ord,-1));
2860 10158 : ordp = gcdii(ordp, ord);
2861 10158 : op = typ(o)==t_MAT ? famat_Z_gcd(o, ordp) : ordp;
2862 :
2863 10158 : q = NULL;
2864 10158 : if (T)
2865 : { /* we want < g > = Fp^* */
2866 10158 : if (!equalii(ord,ordp)) {
2867 591 : q = diviiexact(ord,ordp);
2868 591 : g = Flxq_pow(g,q,T,p);
2869 : }
2870 : }
2871 10158 : n_q = Fp_log(utoi(a), utoi(uel(g,2)), op, utoi(p));
2872 10158 : if (lg(n_q)==1) return gerepileuptoleaf(av, n_q);
2873 10158 : if (q) n_q = mulii(q, n_q);
2874 10158 : return gerepileuptoint(av, n_q);
2875 : }
2876 :
2877 : static GEN
2878 323290 : Flxq_easylog(void* E, GEN a, GEN g, GEN ord)
2879 : {
2880 323290 : struct _Flxq *f = (struct _Flxq *)E;
2881 323290 : GEN T = f->T;
2882 323290 : ulong p = f->p;
2883 323290 : long d = get_Flx_degree(T);
2884 323290 : if (Flx_equal1(a)) return gen_0;
2885 270845 : if (Flx_equal(a,g)) return gen_1;
2886 59924 : if (!degpol(a))
2887 10919 : return Fl_Flxq_log(uel(a,2), g, ord, T, p);
2888 49005 : if (typ(ord)!=t_INT || d <= 4 || d == 6 || abscmpiu(ord,1UL<<27)<0)
2889 48977 : return NULL;
2890 28 : return Flxq_log_index(a, g, ord, T, p);
2891 : }
2892 :
2893 : int
2894 24432271 : Flx_equal(GEN V, GEN W)
2895 : {
2896 24432271 : long l = lg(V);
2897 24432271 : if (lg(W) != l) return 0;
2898 48288645 : while (--l > 1) /* do not compare variables, V[1] */
2899 24079805 : if (V[l] != W[l]) return 0;
2900 610118 : return 1;
2901 : }
2902 :
2903 : static const struct bb_group Flxq_star={_Flxq_mul,_Flxq_pow,_Flxq_rand,hash_GEN,Flx_equal,Flx_equal1,Flxq_easylog};
2904 :
2905 : const struct bb_group *
2906 214168 : get_Flxq_star(void **E, GEN T, ulong p)
2907 : {
2908 214168 : struct _Flxq *e = (struct _Flxq *) stack_malloc(sizeof(struct _Flxq));
2909 214168 : e->T = T; e->p = p; e->aut = Flx_Frobenius(T, p);
2910 214168 : *E = (void*)e; return &Flxq_star;
2911 : }
2912 :
2913 : GEN
2914 12580 : Flxq_order(GEN a, GEN ord, GEN T, ulong p)
2915 : {
2916 : void *E;
2917 12580 : const struct bb_group *S = get_Flxq_star(&E,T,p);
2918 12580 : return gen_order(a,ord,E,S);
2919 : }
2920 :
2921 : GEN
2922 35741 : Flxq_log(GEN a, GEN g, GEN ord, GEN T, ulong p)
2923 : {
2924 : void *E;
2925 35741 : pari_sp av = avma;
2926 35741 : const struct bb_group *S = get_Flxq_star(&E,T,p);
2927 35741 : GEN v = get_arith_ZZM(ord), F = gmael(v,2,1);
2928 35741 : if (Flxq_log_use_index(gel(F,lg(F)-1), T, p))
2929 9170 : v = mkvec2(gel(v, 1), ZM_famat_limit(gel(v, 2), int2n(27)));
2930 35741 : return gerepileuptoleaf(av, gen_PH_log(a, g, v, E, S));
2931 : }
2932 :
2933 : GEN
2934 168962 : Flxq_sqrtn(GEN a, GEN n, GEN T, ulong p, GEN *zeta)
2935 : {
2936 168962 : if (!lgpol(a))
2937 : {
2938 3115 : if (signe(n) < 0) pari_err_INV("Flxq_sqrtn",a);
2939 3108 : if (zeta)
2940 0 : *zeta=pol1_Flx(get_Flx_var(T));
2941 3108 : return pol0_Flx(get_Flx_var(T));
2942 : }
2943 : else
2944 : {
2945 : void *E;
2946 165847 : pari_sp av = avma;
2947 165847 : const struct bb_group *S = get_Flxq_star(&E,T,p);
2948 165847 : GEN o = subiu(powuu(p,get_Flx_degree(T)), 1);
2949 165847 : GEN s = gen_Shanks_sqrtn(a,n,o,zeta,E,S);
2950 165847 : if (s) gerepileall(av, zeta?2:1, &s, zeta);
2951 165847 : return s;
2952 : }
2953 : }
2954 :
2955 : GEN
2956 160944 : Flxq_sqrt(GEN a, GEN T, ulong p)
2957 : {
2958 160944 : return Flxq_sqrtn(a, gen_2, T, p, NULL);
2959 : }
2960 :
2961 : /* assume T irreducible mod p */
2962 : int
2963 358969 : Flxq_issquare(GEN x, GEN T, ulong p)
2964 : {
2965 358969 : if (lgpol(x) == 0 || p == 2) return 1;
2966 355714 : return krouu(Flxq_norm(x,T,p), p) == 1;
2967 : }
2968 :
2969 : /* assume T irreducible mod p */
2970 : int
2971 280 : Flxq_is2npower(GEN x, long n, GEN T, ulong p)
2972 : {
2973 : pari_sp av;
2974 : GEN m;
2975 : int z;
2976 280 : if (n==1) return Flxq_issquare(x, T, p);
2977 280 : if (lgpol(x) == 0 || p == 2) return 1;
2978 280 : av = avma;
2979 280 : m = shifti(subiu(powuu(p, get_Flx_degree(T)), 1), -n);
2980 280 : z = Flx_equal1(Flxq_pow(x, m, T, p));
2981 280 : avma = av; return z;
2982 : }
2983 :
2984 : GEN
2985 113505 : Flxq_lroot_fast(GEN a, GEN sqx, GEN T, long p)
2986 : {
2987 113505 : pari_sp av=avma;
2988 113505 : GEN A = Flx_splitting(a,p);
2989 113505 : return gerepileuptoleaf(av, FlxqV_dotproduct(A,sqx,T,p));
2990 : }
2991 :
2992 : GEN
2993 25032 : Flxq_lroot(GEN a, GEN T, long p)
2994 : {
2995 25032 : pari_sp av=avma;
2996 25032 : long n = get_Flx_degree(T), d = degpol(a);
2997 : GEN sqx, V;
2998 25032 : if (n==1) return leafcopy(a);
2999 25032 : if (n==2) return Flxq_powu(a, p, T, p);
3000 25032 : sqx = Flxq_autpow(Flx_Frobenius(T, p), n-1, T, p);
3001 25032 : if (d==1 && a[2]==0 && a[3]==1) return gerepileuptoleaf(av, sqx);
3002 0 : if (d>=p)
3003 : {
3004 0 : V = Flxq_powers(sqx,p-1,T,p);
3005 0 : return gerepileuptoleaf(av, Flxq_lroot_fast(a,V,T,p));
3006 : } else
3007 0 : return gerepileuptoleaf(av, Flx_Flxq_eval(a,sqx,T,p));
3008 : }
3009 :
3010 : ulong
3011 385674 : Flxq_norm(GEN x, GEN TB, ulong p)
3012 : {
3013 385674 : GEN T = get_Flx_mod(TB);
3014 385674 : ulong y = Flx_resultant(T, x, p);
3015 385674 : ulong L = Flx_lead(T);
3016 385674 : if ( L==1 || lgpol(x)==0) return y;
3017 0 : return Fl_div(y, Fl_powu(L, (ulong)degpol(x), p), p);
3018 : }
3019 :
3020 : ulong
3021 3310 : Flxq_trace(GEN x, GEN TB, ulong p)
3022 : {
3023 3310 : pari_sp av = avma;
3024 : ulong t;
3025 3310 : GEN T = get_Flx_mod(TB);
3026 3310 : long n = degpol(T)-1;
3027 3310 : GEN z = Flxq_mul(x, Flx_deriv(T, p), TB, p);
3028 3310 : t = degpol(z)<n ? 0 : Fl_div(z[2+n],T[3+n],p);
3029 3310 : avma=av;
3030 3310 : return t;
3031 : }
3032 :
3033 : /*x must be reduced*/
3034 : GEN
3035 27 : Flxq_charpoly(GEN x, GEN TB, ulong p)
3036 : {
3037 27 : pari_sp ltop=avma;
3038 27 : GEN T = get_Flx_mod(TB);
3039 27 : long vs = evalvarn(fetch_var());
3040 27 : GEN xm1 = deg1pol_shallow(pol1_Flx(x[1]),Flx_neg(x,p),vs);
3041 27 : GEN r = Flx_FlxY_resultant(T, xm1, p);
3042 27 : r[1] = x[1];
3043 27 : (void)delete_var(); return gerepileupto(ltop, r);
3044 : }
3045 :
3046 : /* Computing minimal polynomial : */
3047 : /* cf Shoup 'Efficient Computation of Minimal Polynomials */
3048 : /* in Algebraic Extensions of Finite Fields' */
3049 :
3050 : GEN
3051 690633 : Flxn_mul(GEN a, GEN b, long n, ulong p)
3052 : {
3053 690633 : GEN c = Flx_mul(a, b, p);
3054 690633 : return vecsmall_shorten(c, minss(lg(c)-1,n+1));
3055 : }
3056 :
3057 : /* Let v a linear form, return the linear form z->v(tau*z)
3058 : that is, v*(M_tau) */
3059 :
3060 : static GEN
3061 355542 : Flxq_transmul_init(GEN tau, GEN T, ulong p)
3062 : {
3063 : GEN bht;
3064 355542 : GEN h, Tp = get_Flx_red(T, &h);
3065 355542 : long n = degpol(Tp), vT = Tp[1];
3066 355542 : GEN ft = Flx_recipspec(Tp+2, n+1, n+1);
3067 355542 : GEN bt = Flx_recipspec(tau+2, lgpol(tau), n);
3068 355542 : ft[1] = vT; bt[1] = vT;
3069 355542 : if (h)
3070 2210 : bht = Flxn_mul(bt, h, n-1, p);
3071 : else
3072 : {
3073 353332 : GEN bh = Flx_div(Flx_shift(tau, n-1), T, p);
3074 353332 : bht = Flx_recipspec(bh+2, lgpol(bh), n-1);
3075 353332 : bht[1] = vT;
3076 : }
3077 355542 : return mkvec3(bt, bht, ft);
3078 : }
3079 :
3080 : static GEN
3081 901212 : Flxq_transmul(GEN tau, GEN a, long n, ulong p)
3082 : {
3083 901212 : pari_sp ltop = avma;
3084 : GEN t1, t2, t3, vec;
3085 901212 : GEN bt = gel(tau, 1), bht = gel(tau, 2), ft = gel(tau, 3);
3086 901212 : if (lgpol(a)==0) return pol0_Flx(a[1]);
3087 892216 : t2 = Flx_shift(Flx_mul(bt, a, p),1-n);
3088 892216 : if (lgpol(bht)==0) return gerepileuptoleaf(ltop, t2);
3089 677265 : t1 = Flx_shift(Flx_mul(ft, a, p),-n);
3090 677265 : t3 = Flxn_mul(t1, bht, n-1, p);
3091 677265 : vec = Flx_sub(t2, Flx_shift(t3, 1), p);
3092 677265 : return gerepileuptoleaf(ltop, vec);
3093 : }
3094 :
3095 : GEN
3096 163509 : Flxq_minpoly(GEN x, GEN T, ulong p)
3097 : {
3098 163509 : pari_sp ltop = avma;
3099 163509 : long vT = get_Flx_var(T), n = get_Flx_degree(T);
3100 : GEN v_x;
3101 163509 : GEN g = pol1_Flx(vT), tau = pol1_Flx(vT);
3102 163509 : T = Flx_get_red(T, p);
3103 163509 : v_x = Flxq_powers(x, usqrt(2*n), T, p);
3104 504789 : while (lgpol(tau) != 0)
3105 : {
3106 : long i, j, m, k1;
3107 : GEN M, v, tr;
3108 : GEN g_prime, c;
3109 177771 : if (degpol(g) == n) { tau = pol1_Flx(vT); g = pol1_Flx(vT); }
3110 177771 : v = random_Flx(n, vT, p);
3111 177771 : tr = Flxq_transmul_init(tau, T, p);
3112 177771 : v = Flxq_transmul(tr, v, n, p);
3113 177771 : m = 2*(n-degpol(g));
3114 177771 : k1 = usqrt(m);
3115 177771 : tr = Flxq_transmul_init(gel(v_x,k1+1), T, p);
3116 177771 : c = cgetg(m+2,t_VECSMALL);
3117 177771 : c[1] = T[1];
3118 901212 : for (i=0; i<m; i+=k1)
3119 : {
3120 723441 : long mj = minss(m-i, k1);
3121 2985181 : for (j=0; j<mj; j++)
3122 2261740 : uel(c,m+1-(i+j)) = Flx_dotproduct(v, gel(v_x,j+1), p);
3123 723441 : v = Flxq_transmul(tr, v, n, p);
3124 : }
3125 177771 : c = Flx_renormalize(c, m+2);
3126 : /* now c contains <v,x^i> , i = 0..m-1 */
3127 177771 : M = Flx_halfgcd(monomial_Flx(1, m, vT), c, p);
3128 177771 : g_prime = gmael(M, 2, 2);
3129 177771 : if (degpol(g_prime) < 1) continue;
3130 174453 : g = Flx_mul(g, g_prime, p);
3131 174453 : tau = Flxq_mul(tau, Flx_FlxqV_eval(g_prime, v_x, T, p), T, p);
3132 : }
3133 163509 : g = Flx_normalize(g,p);
3134 163509 : return gerepileuptoleaf(ltop,g);
3135 : }
3136 :
3137 : /* return (x % X^n). Shallow */
3138 : static GEN
3139 686 : Flxn_red_shallow(GEN a, long n)
3140 : {
3141 686 : long i, L, l = lg(a);
3142 : GEN b;
3143 686 : if (l == 2 || !n) return zero_Flx(a[1]);
3144 686 : L = n+2; if (L > l) L = l;
3145 686 : b = cgetg(L, t_POL); b[1] = a[1];
3146 686 : for (i=2; i<L; i++) b[i] = a[i];
3147 686 : return Flx_renormalize(b,L);
3148 : }
3149 : GEN
3150 112 : Flxn_inv(GEN f, long e, ulong p)
3151 : {
3152 112 : pari_sp av = avma, av2;
3153 : ulong mask;
3154 : GEN W;
3155 112 : long n=1;
3156 112 : if (lg(f)==2) pari_err_INV("Flxn_inv",f);
3157 112 : W = Fl_to_Flx(Fl_inv(f[2],p), f[1]);
3158 112 : mask = quadratic_prec_mask(e);
3159 112 : av2 = avma;
3160 910 : for (;mask>1;)
3161 : {
3162 : GEN u, fr;
3163 686 : long n2 = n;
3164 686 : n<<=1; if (mask & 1) n--;
3165 686 : mask >>= 1;
3166 686 : fr = Flxn_red_shallow(f, n);
3167 686 : u = Flx_shift(Flxn_mul(W, fr, n, p), -n2);
3168 686 : W = Flx_sub(W, Flx_shift(Flxn_mul(u, W, n-n2, p), n2), p);
3169 686 : if (gc_needed(av2,2))
3170 : {
3171 0 : if(DEBUGMEM>1) pari_warn(warnmem,"RgXn_inv, e = %ld", n);
3172 0 : W = gerepileupto(av2, W);
3173 : }
3174 : }
3175 112 : return gerepileupto(av, W);
3176 : }
3177 :
3178 : GEN
3179 20 : Flxq_conjvec(GEN x, GEN T, ulong p)
3180 : {
3181 20 : long i, l = 1+get_Flx_degree(T);
3182 20 : GEN z = cgetg(l,t_COL);
3183 20 : T = Flx_get_red(T,p);
3184 20 : gel(z,1) = Flx_copy(x);
3185 20 : for (i=2; i<l; i++) gel(z,i) = Flxq_powu(gel(z,i-1), p, T, p);
3186 20 : return z;
3187 : }
3188 :
3189 : GEN
3190 9196 : gener_Flxq(GEN T, ulong p, GEN *po)
3191 : {
3192 : long i, j;
3193 9196 : long vT = get_Flx_var(T), f =get_Flx_degree(T);
3194 : ulong p_1;
3195 : GEN g, L, L2, o, q, F;
3196 : pari_sp av0, av;
3197 :
3198 9196 : if (f == 1) {
3199 : GEN fa;
3200 28 : o = utoipos(p-1);
3201 28 : fa = Z_factor(o);
3202 28 : L = gel(fa,1);
3203 28 : L = vecslice(L, 2, lg(L)-1); /* remove 2 for efficiency */
3204 28 : g = Fl_to_Flx(pgener_Fl_local(p, vec_to_vecsmall(L)), vT);
3205 28 : if (po) *po = mkvec2(o, fa);
3206 28 : return g;
3207 : }
3208 :
3209 9168 : av0 = avma; p_1 = p - 1;
3210 9168 : q = diviuexact(subiu(powuu(p,f), 1), p_1);
3211 :
3212 9168 : L = cgetg(1, t_VECSMALL);
3213 9168 : if (p > 3)
3214 : {
3215 : ulong t;
3216 1118 : (void)u_lvalrem(p_1, 2, &t);
3217 1118 : L = gel(factoru(t),1);
3218 1118 : for (i=lg(L)-1; i; i--) L[i] = p_1 / L[i];
3219 : }
3220 9168 : o = factor_pn_1(utoipos(p),f);
3221 9168 : L2 = leafcopy( gel(o, 1) );
3222 25302 : for (i = j = 1; i < lg(L2); i++)
3223 : {
3224 16134 : if (umodui(p_1, gel(L2,i)) == 0) continue;
3225 13327 : gel(L2,j++) = diviiexact(q, gel(L2,i));
3226 : }
3227 9168 : setlg(L2, j);
3228 9168 : F = Flx_Frobenius(T, p);
3229 20293 : for (av = avma;; avma = av)
3230 11125 : {
3231 : GEN tt;
3232 20293 : g = random_Flx(f, vT, p);
3233 20293 : if (degpol(g) < 1) continue;
3234 15394 : if (p == 2) tt = g;
3235 : else
3236 : {
3237 4908 : ulong t = Flxq_norm(g, T, p);
3238 4908 : if (t == 1 || !is_gener_Fl(t, p, p_1, L)) continue;
3239 2615 : tt = Flxq_powu(g, p_1>>1, T, p);
3240 : }
3241 27706 : for (i = 1; i < j; i++)
3242 : {
3243 18538 : GEN a = Flxq_pow_Frobenius(tt, gel(L2,i), F, T, p);
3244 18538 : if (!degpol(a) && uel(a,2) == p_1) break;
3245 : }
3246 13101 : if (i == j) break;
3247 : }
3248 9168 : if (!po)
3249 : {
3250 180 : avma = (pari_sp)g;
3251 180 : g = gerepileuptoleaf(av0, g);
3252 : }
3253 : else {
3254 8988 : *po = mkvec2(subiu(powuu(p,f), 1), o);
3255 8988 : gerepileall(av0, 2, &g, po);
3256 : }
3257 9168 : return g;
3258 : }
3259 :
3260 : static GEN
3261 6517 : _Flxq_neg(void *E, GEN x)
3262 6517 : { struct _Flxq *s = (struct _Flxq *)E;
3263 6517 : return Flx_neg(x,s->p); }
3264 :
3265 : static GEN
3266 111125 : _Flxq_rmul(void *E, GEN x, GEN y)
3267 111125 : { struct _Flxq *s = (struct _Flxq *)E;
3268 111125 : return Flx_mul(x,y,s->p); }
3269 :
3270 : static GEN
3271 6118 : _Flxq_inv(void *E, GEN x)
3272 6118 : { struct _Flxq *s = (struct _Flxq *)E;
3273 6118 : return Flxq_inv(x,s->T,s->p); }
3274 :
3275 : static int
3276 42777 : _Flxq_equal0(GEN x) { return lgpol(x)==0; }
3277 :
3278 : static GEN
3279 12761 : _Flxq_s(void *E, long x)
3280 12761 : { struct _Flxq *s = (struct _Flxq *)E;
3281 12761 : ulong u = x<0 ? s->p+x: (ulong)x;
3282 12761 : return Fl_to_Flx(u, get_Flx_var(s->T));
3283 : }
3284 :
3285 : static const struct bb_field Flxq_field={_Flxq_red,_Flx_add,_Flxq_rmul,_Flxq_neg,
3286 : _Flxq_inv,_Flxq_equal0,_Flxq_s};
3287 :
3288 6958 : const struct bb_field *get_Flxq_field(void **E, GEN T, ulong p)
3289 : {
3290 6958 : GEN z = new_chunk(sizeof(struct _Flxq));
3291 6958 : struct _Flxq *e = (struct _Flxq *) z;
3292 6958 : e->T = Flx_get_red(T, p); e->p = p; *E = (void*)e;
3293 6958 : return &Flxq_field;
3294 : }
3295 :
3296 : /***********************************************************************/
3297 : /** **/
3298 : /** Fl2 **/
3299 : /** **/
3300 : /***********************************************************************/
3301 : /* Fl2 objects are Flv of length 2 [a,b] representing a+bsqrt(D) for
3302 : a non-square D.
3303 : */
3304 :
3305 : INLINE GEN
3306 6257558 : mkF2(ulong a, ulong b) { return mkvecsmall2(a,b); }
3307 :
3308 : GEN
3309 1680887 : Fl2_mul_pre(GEN x, GEN y, ulong D, ulong p, ulong pi)
3310 : {
3311 : ulong xaya, xbyb, Db2, mid;
3312 : ulong z1, z2;
3313 1680887 : ulong x1 = x[1], x2 = x[2], y1 = y[1], y2 = y[2];
3314 1680887 : xaya = Fl_mul_pre(x1,y1,p,pi);
3315 1681053 : if (x2==0 && y2==0) return mkF2(xaya,0);
3316 1627329 : if (x2==0) return mkF2(xaya,Fl_mul_pre(x1,y2,p,pi));
3317 1606599 : if (y2==0) return mkF2(xaya,Fl_mul_pre(x2,y1,p,pi));
3318 1606329 : xbyb = Fl_mul_pre(x2,y2,p,pi);
3319 1606326 : mid = Fl_mul_pre(Fl_add(x1,x2,p), Fl_add(y1,y2,p),p,pi);
3320 1606344 : Db2 = Fl_mul_pre(D, xbyb, p,pi);
3321 1606342 : z1 = Fl_add(xaya,Db2,p);
3322 1606305 : z2 = Fl_sub(mid,Fl_add(xaya,xbyb,p),p);
3323 1606236 : return mkF2(z1,z2);
3324 : }
3325 :
3326 : GEN
3327 4239261 : Fl2_sqr_pre(GEN x, ulong D, ulong p, ulong pi)
3328 : {
3329 4239261 : ulong a = x[1], b = x[2];
3330 : ulong a2, Db2, ab;
3331 4239261 : a2 = Fl_sqr_pre(a,p,pi);
3332 4240157 : if (b==0) return mkF2(a2,0);
3333 4065222 : Db2= Fl_mul_pre(D, Fl_sqr_pre(b,p,pi), p,pi);
3334 4065247 : ab = Fl_mul_pre(a,b,p,pi);
3335 4065293 : return mkF2(Fl_add(a2,Db2,p), Fl_double(ab,p));
3336 : }
3337 :
3338 : ulong
3339 66198 : Fl2_norm_pre(GEN x, ulong D, ulong p, ulong pi)
3340 : {
3341 66198 : ulong a2 = Fl_sqr_pre(x[1],p,pi);
3342 66198 : return x[2]? Fl_sub(a2, Fl_mul_pre(D, Fl_sqr_pre(x[2], p,pi), p,pi), p): a2;
3343 : }
3344 :
3345 : GEN
3346 167293 : Fl2_inv_pre(GEN x, ulong D, ulong p, ulong pi)
3347 : {
3348 : ulong n, ni;
3349 167293 : if (x[2] == 0) return mkF2(Fl_inv(x[1],p),0);
3350 143359 : n = Fl_sub(Fl_sqr_pre(x[1], p,pi),
3351 143359 : Fl_mul_pre(D, Fl_sqr_pre(x[2], p,pi), p,pi), p);
3352 143357 : ni = Fl_inv(n,p);
3353 143357 : return mkF2(Fl_mul_pre(x[1], ni, p,pi),
3354 143357 : Fl_neg(Fl_mul_pre(x[2], ni, p,pi), p));
3355 : }
3356 :
3357 : int
3358 379428 : Fl2_equal1(GEN x) { return x[1]==1 && x[2]==0; }
3359 :
3360 : struct _Fl2 {
3361 : ulong p, pi, D;
3362 : };
3363 :
3364 :
3365 : static GEN
3366 4239094 : _Fl2_sqr(void *data, GEN x)
3367 : {
3368 4239094 : struct _Fl2 *D = (struct _Fl2*)data;
3369 4239094 : return Fl2_sqr_pre(x, D->D, D->p, D->pi);
3370 : }
3371 : static GEN
3372 1653127 : _Fl2_mul(void *data, GEN x, GEN y)
3373 : {
3374 1653127 : struct _Fl2 *D = (struct _Fl2*)data;
3375 1653127 : return Fl2_mul_pre(x,y, D->D, D->p, D->pi);
3376 : }
3377 :
3378 : /* n-Power of x in Z/pZ[X]/(T), as t_VECSMALL. */
3379 : GEN
3380 567757 : Fl2_pow_pre(GEN x, GEN n, ulong D, ulong p, ulong pi)
3381 : {
3382 567757 : pari_sp av = avma;
3383 : struct _Fl2 d;
3384 : GEN y;
3385 567757 : long s = signe(n);
3386 567757 : if (!s) return mkF2(1,0);
3387 503167 : if (s < 0)
3388 167293 : x = Fl2_inv_pre(x,D,p,pi);
3389 503166 : if (is_pm1(n)) return s < 0 ? x : zv_copy(x);
3390 369997 : d.p = p; d.pi = pi; d.D=D;
3391 369997 : y = gen_pow_i(x, n, (void*)&d, &_Fl2_sqr, &_Fl2_mul);
3392 369989 : return gerepileuptoleaf(av, y);
3393 : }
3394 :
3395 : static GEN
3396 567750 : _Fl2_pow(void *data, GEN x, GEN n)
3397 : {
3398 567750 : struct _Fl2 *D = (struct _Fl2*)data;
3399 567750 : return Fl2_pow_pre(x, n, D->D, D->p, D->pi);
3400 : }
3401 :
3402 : static GEN
3403 96145 : _Fl2_rand(void *data)
3404 : {
3405 96145 : struct _Fl2 *D = (struct _Fl2*)data;
3406 96145 : ulong a = random_Fl(D->p), b=random_Fl(D->p-1)+1;
3407 96147 : return mkF2(a,b);
3408 : }
3409 :
3410 : static const struct bb_group Fl2_star={_Fl2_mul, _Fl2_pow, _Fl2_rand,
3411 : hash_GEN, zv_equal, Fl2_equal1, NULL};
3412 :
3413 : GEN
3414 64591 : Fl2_sqrtn_pre(GEN a, GEN n, ulong D, ulong p, ulong pi, GEN *zeta)
3415 : {
3416 : struct _Fl2 E;
3417 : GEN o;
3418 64591 : if (a[1]==0 && a[2]==0)
3419 : {
3420 0 : if (signe(n) < 0) pari_err_INV("Flxq_sqrtn",a);
3421 0 : if (zeta) *zeta=mkF2(1,0);
3422 0 : return zv_copy(a);
3423 : }
3424 64591 : E.p=p; E.pi = pi; E.D = D;
3425 64591 : o = subiu(powuu(p,2), 1);
3426 64592 : return gen_Shanks_sqrtn(a,n,o,zeta,(void*)&E,&Fl2_star);
3427 : }
3428 :
3429 : GEN
3430 10108 : Flx_Fl2_eval_pre(GEN x, GEN y, ulong D, ulong p, ulong pi)
3431 : {
3432 : GEN p1;
3433 10108 : long i = lg(x)-1;
3434 10108 : if (i <= 2)
3435 1883 : return mkF2(i == 2? x[2]: 0, 0);
3436 8225 : p1 = mkF2(x[i], 0);
3437 35952 : for (i--; i>=2; i--)
3438 : {
3439 27727 : p1 = Fl2_mul_pre(p1, y, D, p, pi);
3440 27727 : uel(p1,1) = Fl_add(uel(p1,1), uel(x,i), p);
3441 : }
3442 8225 : return p1;
3443 : }
3444 :
3445 :
3446 : /***********************************************************************/
3447 : /** **/
3448 : /** FlxV **/
3449 : /** **/
3450 : /***********************************************************************/
3451 : /* FlxV are t_VEC with Flx coefficients. */
3452 :
3453 : GEN
3454 0 : FlxV_Flc_mul(GEN V, GEN W, ulong p)
3455 : {
3456 0 : pari_sp ltop=avma;
3457 : long i;
3458 0 : GEN z = Flx_Fl_mul(gel(V,1),W[1],p);
3459 0 : for(i=2;i<lg(V);i++)
3460 0 : z=Flx_add(z,Flx_Fl_mul(gel(V,i),W[i],p),p);
3461 0 : return gerepileuptoleaf(ltop,z);
3462 : }
3463 :
3464 : GEN
3465 0 : ZXV_to_FlxV(GEN x, ulong p)
3466 0 : { pari_APPLY_type(t_VEC, ZX_to_Flx(gel(x,i), p)) }
3467 :
3468 : GEN
3469 1388982 : ZXT_to_FlxT(GEN x, ulong p)
3470 : {
3471 1388982 : if (typ(x) == t_POL)
3472 1341844 : return ZX_to_Flx(x, p);
3473 : else
3474 47138 : pari_APPLY_type(t_VEC, ZXT_to_FlxT(gel(x,i), p))
3475 : }
3476 :
3477 : GEN
3478 33068 : FlxV_to_Flm(GEN x, long n)
3479 33068 : { pari_APPLY_type(t_MAT, Flx_to_Flv(gel(x,i), n)) }
3480 :
3481 : GEN
3482 0 : FlxV_red(GEN x, ulong p)
3483 0 : { pari_APPLY_type(t_VEC, Flx_red(gel(x,i), p)) }
3484 :
3485 : GEN
3486 207066 : FlxT_red(GEN x, ulong p)
3487 : {
3488 207066 : if (typ(x) == t_VECSMALL)
3489 139789 : return Flx_red(x, p);
3490 : else
3491 67277 : pari_APPLY_type(t_VEC, FlxT_red(gel(x,i), p))
3492 : }
3493 :
3494 : GEN
3495 113505 : FlxqV_dotproduct(GEN x, GEN y, GEN T, ulong p)
3496 : {
3497 113505 : long i, lx = lg(x);
3498 : pari_sp av;
3499 : GEN c;
3500 113505 : if (lx == 1) return gen_0;
3501 113505 : av = avma; c = Flx_mul(gel(x,1),gel(y,1), p);
3502 113505 : for (i=2; i<lx; i++) c = Flx_add(c, Flx_mul(gel(x,i),gel(y,i), p), p);
3503 113505 : return gerepileuptoleaf(av, Flx_rem(c,T,p));
3504 : }
3505 :
3506 : GEN
3507 968 : FlxqX_dotproduct(GEN x, GEN y, GEN T, ulong p)
3508 : {
3509 968 : long i, l = minss(lg(x), lg(y));
3510 : pari_sp av;
3511 : GEN c;
3512 968 : if (l == 2) return pol0_Flx(get_Flx_var(T));
3513 940 : av = avma; c = Flx_mul(gel(x,2),gel(y,2), p);
3514 940 : for (i=3; i<l; i++) c = Flx_add(c, Flx_mul(gel(x,i),gel(y,i), p), p);
3515 940 : return gerepileuptoleaf(av, Flx_rem(c,T,p));
3516 : }
3517 :
3518 : GEN
3519 170229 : FlxC_eval_powers_pre(GEN z, GEN x, ulong p, ulong pi)
3520 : {
3521 170229 : long i, l = lg(z);
3522 170229 : GEN y = cgetg(l, t_VECSMALL);
3523 5990421 : for (i=1; i<l; i++)
3524 5820191 : uel(y,i) = Flx_eval_powers_pre(gel(z,i), x, p, pi);
3525 170230 : return y;
3526 : }
3527 :
3528 : /***********************************************************************/
3529 : /** **/
3530 : /** FlxM **/
3531 : /** **/
3532 : /***********************************************************************/
3533 :
3534 : GEN
3535 13699 : FlxM_eval_powers_pre(GEN z, GEN x, ulong p, ulong pi)
3536 : {
3537 13699 : long i, l = lg(z);
3538 13699 : GEN y = cgetg(l, t_MAT);
3539 183929 : for (i=1; i<l; i++)
3540 170229 : gel(y,i) = FlxC_eval_powers_pre(gel(z,i), x, p, pi);
3541 13700 : return y;
3542 : }
3543 :
3544 : GEN
3545 3031 : zero_FlxC(long n, long sv)
3546 : {
3547 : long i;
3548 3031 : GEN x = cgetg(n + 1, t_COL);
3549 3031 : GEN z = zero_Flx(sv);
3550 14490 : for (i = 1; i <= n; i++)
3551 11459 : gel(x, i) = z;
3552 3031 : return x;
3553 : }
3554 :
3555 : GEN
3556 6433 : FlxC_neg(GEN x, ulong p)
3557 6433 : { pari_APPLY_type(t_COL, Flx_neg(gel(x, i), p)) }
3558 :
3559 : GEN
3560 158802 : FlxC_sub(GEN x, GEN y, ulong p)
3561 158802 : { pari_APPLY_type(t_COL, Flx_sub(gel(x, i), gel(y, i), p)) }
3562 :
3563 : GEN
3564 3017 : zero_FlxM(long r, long c, long sv)
3565 : {
3566 : long j;
3567 3017 : GEN x = cgetg(c + 1, t_MAT);
3568 3017 : GEN z = zero_FlxC(r, sv);
3569 11354 : for (j = 1; j <= c; j++)
3570 8337 : gel(x, j) = z;
3571 3017 : return x;
3572 : }
3573 :
3574 : GEN
3575 1813 : FlxM_neg(GEN x, ulong p)
3576 1813 : { pari_APPLY_same(FlxC_neg(gel(x, i), p)) }
3577 :
3578 : GEN
3579 22470 : FlxM_sub(GEN x, GEN y, ulong p)
3580 22470 : { pari_APPLY_same(FlxC_sub(gel(x, i), gel(y,i), p)) }
3581 :
3582 : /***********************************************************************/
3583 : /** **/
3584 : /** FlxX **/
3585 : /** **/
3586 : /***********************************************************************/
3587 :
3588 : /* FlxX are t_POL with Flx coefficients.
3589 : * Normally the variable ordering should be respected.*/
3590 :
3591 : /*Similar to normalizepol, in place*/
3592 : /*FlxX_renormalize=zxX_renormalize */
3593 : GEN
3594 8646011 : FlxX_renormalize(GEN /*in place*/ x, long lx)
3595 : {
3596 : long i;
3597 11603103 : for (i = lx-1; i>1; i--)
3598 10723269 : if (lgpol(gel(x,i))) break;
3599 8646010 : stackdummy((pari_sp)(x + lg(x)), (pari_sp)(x + i+1));
3600 8646008 : setlg(x, i+1); setsigne(x, i!=1); return x;
3601 : }
3602 :
3603 : GEN
3604 876672 : pol1_FlxX(long v, long sv)
3605 : {
3606 876672 : GEN z = cgetg(3, t_POL);
3607 876672 : z[1] = evalsigne(1) | evalvarn(v);
3608 876672 : gel(z,2) = pol1_Flx(sv); return z;
3609 : }
3610 :
3611 : GEN
3612 7094 : polx_FlxX(long v, long sv)
3613 : {
3614 7094 : GEN z = cgetg(4, t_POL);
3615 7094 : z[1] = evalsigne(1) | evalvarn(v);
3616 7094 : gel(z,2) = pol0_Flx(sv);
3617 7094 : gel(z,3) = pol1_Flx(sv); return z;
3618 : }
3619 :
3620 : long
3621 1827402 : FlxY_degreex(GEN b)
3622 : {
3623 1827402 : long deg = -1, i;
3624 1827402 : if (!signe(b)) return -1;
3625 6648749 : for (i = 2; i < lg(b); ++i)
3626 4821347 : deg = maxss(deg, degpol(gel(b, i)));
3627 1827402 : return deg;
3628 : }
3629 :
3630 : /*Lift coefficient of B to constant Flx, to give a FlxY*/
3631 : GEN
3632 2012 : Fly_to_FlxY(GEN B, long sv)
3633 : {
3634 2012 : long lb=lg(B);
3635 : long i;
3636 2012 : GEN b=cgetg(lb,t_POL);
3637 2020 : b[1]=evalsigne(1)|(((ulong)B[1])&VARNBITS);
3638 46413 : for (i=2; i<lb; i++)
3639 44399 : gel(b,i) = Fl_to_Flx(B[i], sv);
3640 2014 : return FlxX_renormalize(b, lb);
3641 : }
3642 :
3643 : GEN
3644 1647720 : zxX_to_FlxX(GEN B, ulong p)
3645 : {
3646 1647720 : long i, lb = lg(B);
3647 1647720 : GEN b = cgetg(lb,t_POL);
3648 5371165 : for (i=2; i<lb; i++)
3649 3723445 : gel(b,i) = zx_to_Flx(gel(B,i), p);
3650 1647720 : b[1] = B[1]; return FlxX_renormalize(b, lb);
3651 : }
3652 :
3653 : GEN
3654 420287 : FlxX_to_ZXX(GEN B)
3655 : {
3656 420287 : long i, lb = lg(B);
3657 420287 : GEN b = cgetg(lb,t_POL);
3658 2363473 : for (i=2; i<lb; i++)
3659 : {
3660 1943186 : GEN c = gel(B,i);
3661 1943186 : switch(lgpol(c))
3662 : {
3663 41723 : case 0: c = gen_0; break;
3664 58001 : case 1: c = utoi(c[2]); break;
3665 1843462 : default: c = Flx_to_ZX(c); break;
3666 : }
3667 1943186 : gel(b,i) = c;
3668 : }
3669 420287 : b[1] = B[1]; return b;
3670 : }
3671 :
3672 : GEN
3673 1456 : FlxXC_to_ZXXC(GEN x)
3674 1456 : { pari_APPLY_type(t_COL, FlxX_to_ZXX(gel(x,i))) }
3675 :
3676 : GEN
3677 0 : FlxXM_to_ZXXM(GEN x)
3678 0 : { pari_APPLY_same(FlxXC_to_ZXXC(gel(x,i))) }
3679 :
3680 : /* Note: v is used _only_ for the t_INT. It must match
3681 : * the variable of any t_POL coefficients. */
3682 : GEN
3683 479220 : ZXX_to_FlxX(GEN B, ulong p, long v)
3684 : {
3685 479220 : long lb=lg(B);
3686 : long i;
3687 479220 : GEN b=cgetg(lb,t_POL);
3688 479215 : b[1]=evalsigne(1)|(((ulong)B[1])&VARNBITS);
3689 4167240 : for (i=2; i<lb; i++)
3690 3688022 : switch (typ(gel(B,i)))
3691 : {
3692 : case t_INT:
3693 464320 : gel(b,i) = Z_to_Flx(gel(B,i), p, evalvarn(v));
3694 464317 : break;
3695 : case t_POL:
3696 3223716 : gel(b,i) = ZX_to_Flx(gel(B,i), p);
3697 3223722 : break;
3698 : }
3699 479218 : return FlxX_renormalize(b, lb);
3700 : }
3701 :
3702 : GEN
3703 12 : ZXXV_to_FlxXV(GEN x, ulong p, long v)
3704 12 : { pari_APPLY_type(t_VEC, ZXX_to_FlxX(gel(x,i), p, v)) }
3705 :
3706 : GEN
3707 320 : ZXXT_to_FlxXT(GEN x, ulong p, long v)
3708 : {
3709 320 : if (typ(x) == t_POL)
3710 306 : return ZXX_to_FlxX(x, p, v);
3711 : else
3712 14 : pari_APPLY_type(t_VEC, ZXXT_to_FlxXT(gel(x,i), p, v))
3713 : }
3714 :
3715 : GEN
3716 0 : FlxX_to_FlxC(GEN x, long N, long sv)
3717 : {
3718 : long i, l;
3719 : GEN z;
3720 0 : l = lg(x)-1; x++;
3721 0 : if (l > N+1) l = N+1; /* truncate higher degree terms */
3722 0 : z = cgetg(N+1,t_COL);
3723 0 : for (i=1; i<l ; i++) gel(z,i) = gel(x,i);
3724 0 : for ( ; i<=N; i++) gel(z,i) = pol0_Flx(sv);
3725 0 : return z;
3726 : }
3727 :
3728 : GEN
3729 0 : FlxXV_to_FlxM(GEN v, long n, long sv)
3730 : {
3731 0 : long j, N = lg(v);
3732 0 : GEN y = cgetg(N, t_MAT);
3733 0 : for (j=1; j<N; j++) gel(y,j) = FlxX_to_FlxC(gel(v,j), n, sv);
3734 0 : return y;
3735 : }
3736 :
3737 : /* matrix whose entries are given by the coeffs of the polynomial v in
3738 : * two variables (considered as degree n polynomials) */
3739 : GEN
3740 11092 : FlxX_to_Flm(GEN v, long n)
3741 : {
3742 11092 : long j, N = lg(v)-1;
3743 11092 : GEN y = cgetg(N, t_MAT);
3744 11096 : v++;
3745 11096 : for (j=1; j<N; j++) gel(y,j) = Flx_to_Flv(gel(v,j), n);
3746 11095 : return y;
3747 : }
3748 :
3749 : GEN
3750 41390 : FlxX_to_Flx(GEN f)
3751 : {
3752 41390 : long i, l = lg(f);
3753 41390 : GEN V = cgetg(l, t_VECSMALL);
3754 41390 : V[1] = ((ulong)f[1])&VARNBITS;
3755 589288 : for(i=2; i<l; i++)
3756 547898 : V[i] = lgpol(gel(f,i)) ? mael(f,i,2): 0L;
3757 41390 : return V;
3758 : }
3759 :
3760 : GEN
3761 30060 : Flm_to_FlxX(GEN x, long v,long w)
3762 : {
3763 30060 : long j, lx = lg(x);
3764 30060 : GEN y = cgetg(lx+1, t_POL);
3765 30061 : y[1]=evalsigne(1) | v;
3766 30061 : y++;
3767 30061 : for (j=1; j<lx; j++) gel(y,j) = Flv_to_Flx(gel(x,j), w);
3768 30061 : return FlxX_renormalize(--y, lx+1);
3769 : }
3770 :
3771 : /* P(X,Y) --> P(Y,X), n-1 is the degree in Y */
3772 : GEN
3773 19236 : FlxX_swap(GEN x, long n, long ws)
3774 : {
3775 19236 : long j, lx = lg(x), ly = n+3;
3776 19236 : GEN y = cgetg(ly, t_POL);
3777 19236 : y[1] = x[1];
3778 212562 : for (j=2; j<ly; j++)
3779 : {
3780 : long k;
3781 193326 : GEN p1 = cgetg(lx, t_VECSMALL);
3782 193326 : p1[1] = ws;
3783 6248495 : for (k=2; k<lx; k++)
3784 6055169 : if (j<lg(gel(x,k)))
3785 4895138 : p1[k] = mael(x,k,j);
3786 : else
3787 1160031 : p1[k] = 0;
3788 193326 : gel(y,j) = Flx_renormalize(p1,lx);
3789 : }
3790 19236 : return FlxX_renormalize(y,ly);
3791 : }
3792 :
3793 : static GEN
3794 1394416 : zxX_to_Kronecker_spec(GEN P, long lp, long n)
3795 : { /* P(X) = sum Pi(Y) * X^i, return P( Y^(2n-1) ) */
3796 1394416 : long i, j, k, l, N = (n<<1) + 1;
3797 1394416 : GEN y = cgetg((N-2)*lp + 2, t_VECSMALL) + 2;
3798 14929783 : for (k=i=0; i<lp; i++)
3799 : {
3800 14926833 : GEN c = gel(P,i);
3801 14926833 : l = lg(c);
3802 14926833 : if (l-3 >= n)
3803 0 : pari_err_BUG("zxX_to_Kronecker, P is not reduced mod Q");
3804 14926833 : for (j=2; j < l; j++) y[k++] = c[j];
3805 14926833 : if (i == lp-1) break;
3806 13535367 : for ( ; j < N; j++) y[k++] = 0;
3807 : }
3808 1394416 : y -= 2;
3809 1394416 : y[1] = P[1]; setlg(y, k+2); return y;
3810 : }
3811 :
3812 : GEN
3813 1066116 : zxX_to_Kronecker(GEN P, GEN Q)
3814 : {
3815 1066116 : GEN z = zxX_to_Kronecker_spec(P+2, lg(P)-2, degpol(Q));
3816 1066116 : z[1] = P[1]; return z;
3817 : }
3818 :
3819 : GEN
3820 540953 : FlxX_add(GEN x, GEN y, ulong p)
3821 : {
3822 : long i,lz;
3823 : GEN z;
3824 540953 : long lx=lg(x);
3825 540953 : long ly=lg(y);
3826 540953 : if (ly>lx) swapspec(x,y, lx,ly);
3827 540953 : lz = lx; z = cgetg(lz, t_POL); z[1]=x[1];
3828 540953 : for (i=2; i<ly; i++) gel(z,i) = Flx_add(gel(x,i), gel(y,i), p);
3829 540953 : for ( ; i<lx; i++) gel(z,i) = Flx_copy(gel(x,i));
3830 540953 : return FlxX_renormalize(z, lz);
3831 : }
3832 :
3833 : GEN
3834 392 : FlxX_Flx_add(GEN y, GEN x, ulong p)
3835 : {
3836 392 : long i, lz = lg(y);
3837 : GEN z;
3838 392 : if (signe(y) == 0) return scalarpol(x, varn(y));
3839 392 : z = cgetg(lz,t_POL); z[1] = y[1];
3840 392 : gel(z,2) = Flx_add(gel(y,2), x, p);
3841 392 : if (lz == 3) z = FlxX_renormalize(z,lz);
3842 : else
3843 322 : for(i=3;i<lz;i++) gel(z,i) = Flx_copy(gel(y,i));
3844 392 : return z;
3845 : }
3846 :
3847 : GEN
3848 10525 : FlxX_Flx_sub(GEN y, GEN x, ulong p)
3849 : {
3850 10525 : long i, lz = lg(y);
3851 : GEN z;
3852 10525 : if (signe(y) == 0) return scalarpol(x, varn(y));
3853 10525 : z = cgetg(lz,t_POL); z[1] = y[1];
3854 10525 : gel(z,2) = Flx_sub(gel(y,2), x, p);
3855 10525 : if (lz == 3) z = FlxX_renormalize(z,lz);
3856 : else
3857 8699 : for(i=3;i<lz;i++) gel(z,i) = Flx_copy(gel(y,i));
3858 10525 : return z;
3859 : }
3860 :
3861 : GEN
3862 1013 : FlxX_neg(GEN x, ulong p)
3863 : {
3864 1013 : long i, lx=lg(x);
3865 1013 : GEN z = cgetg(lx, t_POL);
3866 1013 : z[1]=x[1];
3867 1013 : for (i=2; i<lx; i++) gel(z,i) = Flx_neg(gel(x,i), p);
3868 1013 : return z;
3869 : }
3870 :
3871 : GEN
3872 219 : FlxX_Fl_mul(GEN x, ulong y, ulong p)
3873 : {
3874 219 : long i, lx=lg(x);
3875 219 : GEN z = cgetg(lx, t_POL);
3876 219 : z[1]=x[1];
3877 219 : for (i=2; i<lx; i++) gel(z,i) = Flx_Fl_mul(gel(x,i), y, p);
3878 219 : return FlxX_renormalize(z, lx);
3879 : }
3880 :
3881 : GEN
3882 0 : FlxX_triple(GEN x, ulong p)
3883 : {
3884 0 : long i, lx=lg(x);
3885 0 : GEN z = cgetg(lx, t_POL);
3886 0 : z[1]=x[1];
3887 0 : for (i=2; i<lx; i++) gel(z,i) = Flx_triple(gel(x,i), p);
3888 0 : return FlxX_renormalize(z, lx);
3889 : }
3890 :
3891 : GEN
3892 219 : FlxX_double(GEN x, ulong p)
3893 : {
3894 219 : long i, lx=lg(x);
3895 219 : GEN z = cgetg(lx, t_POL);
3896 219 : z[1]=x[1];
3897 219 : for (i=2; i<lx; i++) gel(z,i) = Flx_double(gel(x,i), p);
3898 219 : return FlxX_renormalize(z, lx);
3899 : }
3900 :
3901 : GEN
3902 62633 : FlxX_deriv(GEN z, ulong p)
3903 : {
3904 62633 : long i,l = lg(z)-1;
3905 : GEN x;
3906 62633 : if (l < 2) l = 2;
3907 62633 : x = cgetg(l, t_POL); x[1] = z[1];
3908 62633 : for (i=2; i<l; i++) gel(x,i) = Flx_mulu(gel(z,i+1), (ulong) i-1, p);
3909 62633 : return FlxX_renormalize(x,l);
3910 : }
3911 :
3912 : static GEN
3913 63922 : FlxX_subspec(GEN x, GEN y, ulong p, long lx, long ly)
3914 : {
3915 : long i,lz;
3916 : GEN z;
3917 :
3918 63922 : if (ly <= lx)
3919 : {
3920 63922 : lz = lx+2; z = cgetg(lz, t_POL)+2;
3921 63922 : for (i=0; i<ly; i++) gel(z,i) = Flx_sub(gel(x,i),gel(y,i),p);
3922 63922 : for ( ; i<lx; i++) gel(z,i) = Flx_copy(gel(x,i));
3923 : }
3924 : else
3925 : {
3926 0 : lz = ly+2; z = cgetg(lz, t_POL)+2;
3927 0 : for (i=0; i<lx; i++) gel(z,i) = Flx_sub(gel(x,i),gel(y,i),p);
3928 0 : for ( ; i<ly; i++) gel(z,i) = Flx_neg(gel(y,i),p);
3929 : }
3930 63922 : return FlxX_renormalize(z-2, lz);
3931 : }
3932 :
3933 : GEN
3934 107333 : FlxX_sub(GEN x, GEN y, ulong p)
3935 : {
3936 : long lx,ly,i,lz;
3937 : GEN z;
3938 107333 : lx = lg(x); ly = lg(y);
3939 107333 : lz=maxss(lx,ly);
3940 107333 : z = cgetg(lz,t_POL);
3941 107333 : if (lx >= ly)
3942 : {
3943 67807 : z[1] = x[1];
3944 67807 : for (i=2; i<ly; i++) gel(z,i) = Flx_sub(gel(x,i),gel(y,i),p);
3945 67807 : for ( ; i<lx; i++) gel(z,i) = Flx_copy(gel(x,i));
3946 67807 : if (lx==ly) z = FlxX_renormalize(z, lz);
3947 : }
3948 : else
3949 : {
3950 39526 : z[1] = y[1];
3951 39526 : for (i=2; i<lx; i++) gel(z,i) = Flx_sub(gel(x,i),gel(y,i),p);
3952 39526 : for ( ; i<ly; i++) gel(z,i) = Flx_neg(gel(y,i),p);
3953 : }
3954 107333 : if (!lgpol(z)) { avma = (pari_sp)(z + lz); z = pol_0(varn(x)); }
3955 107333 : return z;
3956 : }
3957 :
3958 : GEN
3959 657466 : FlxX_Flx_mul(GEN P, GEN U, ulong p)
3960 : {
3961 657466 : long i, lP = lg(P);
3962 657466 : GEN res = cgetg(lP,t_POL);
3963 657466 : res[1] = P[1];
3964 7056324 : for(i=2; i<lP; i++)
3965 6398858 : gel(res,i) = Flx_mul(U,gel(P,i), p);
3966 657466 : return FlxX_renormalize(res, lP);
3967 : }
3968 :
3969 : GEN
3970 251028 : FlxY_evalx(GEN Q, ulong x, ulong p)
3971 : {
3972 : GEN z;
3973 251028 : long i, lb = lg(Q);
3974 251028 : z = cgetg(lb,t_VECSMALL); z[1] = evalvarn(varn(Q));
3975 250385 : for (i=2; i<lb; i++) z[i] = Flx_eval(gel(Q,i), x, p);
3976 250938 : return Flx_renormalize(z, lb);
3977 : }
3978 :
3979 : GEN
3980 0 : FlxY_Flx_translate(GEN P, GEN c, ulong p)
3981 : {
3982 0 : pari_sp av = avma;
3983 : GEN Q;
3984 : long i, k, n;
3985 :
3986 0 : if (!signe(P) || gequal0(c)) return RgX_copy(P);
3987 0 : Q = leafcopy(P); n = degpol(P);
3988 0 : for (i=1; i<=n; i++)
3989 : {
3990 0 : for (k=n-i; k<n; k++)
3991 0 : gel(Q,2+k) = Flx_add(gel(Q,2+k), Flx_mul(gel(Q,2+k+1), c, p), p);
3992 0 : if (gc_needed(av,2))
3993 : {
3994 0 : if(DEBUGMEM>1)
3995 0 : pari_warn(warnmem,"FlxY_Flx_translate, i = %ld/%ld", i,n);
3996 0 : Q = gerepilecopy(av, Q);
3997 : }
3998 : }
3999 0 : return gerepilecopy(av, Q);
4000 : }
4001 :
4002 : GEN
4003 7965743 : FlxY_evalx_powers_pre(GEN pol, GEN ypowers, ulong p, ulong pi)
4004 : {
4005 7965743 : long i, len = lg(pol);
4006 7965743 : GEN res = cgetg(len, t_VECSMALL);
4007 7965743 : res[1] = pol[1] & VARNBITS;
4008 27015261 : for (i = 2; i < len; ++i)
4009 19049518 : res[i] = Flx_eval_powers_pre(gel(pol, i), ypowers, p, pi);
4010 7965743 : return Flx_renormalize(res, len);
4011 : }
4012 :
4013 : ulong
4014 5340256 : FlxY_eval_powers_pre(GEN pol, GEN ypowers, GEN xpowers, ulong p, ulong pi)
4015 : {
4016 5340256 : pari_sp av = avma;
4017 5340256 : GEN t = FlxY_evalx_powers_pre(pol, ypowers, p, pi);
4018 5340256 : ulong out = Flx_eval_powers_pre(t, xpowers, p, pi);
4019 5340256 : avma = av;
4020 5340256 : return out;
4021 : }
4022 :
4023 : GEN
4024 120658 : FlxY_FlxqV_evalx(GEN P, GEN x, GEN T, ulong p)
4025 : {
4026 120658 : long i, lP = lg(P);
4027 120658 : GEN res = cgetg(lP,t_POL);
4028 120658 : res[1] = P[1];
4029 766408 : for(i=2; i<lP; i++)
4030 645750 : gel(res,i) = Flx_FlxqV_eval(gel(P,i), x, T, p);
4031 120658 : return FlxX_renormalize(res, lP);
4032 : }
4033 :
4034 : GEN
4035 0 : FlxY_Flxq_evalx(GEN P, GEN x, GEN T, ulong p)
4036 : {
4037 0 : pari_sp av = avma;
4038 0 : long n = brent_kung_optpow(get_Flx_degree(T)-1,lgpol(P),1);
4039 0 : GEN xp = Flxq_powers(x, n, T, p);
4040 0 : return gerepileupto(av, FlxY_FlxqV_evalx(P, xp, T, p));
4041 : }
4042 :
4043 : GEN
4044 6194 : FlxY_Flx_div(GEN x, GEN y, ulong p)
4045 : {
4046 : long i, l;
4047 : GEN z;
4048 6194 : if (degpol(y) == 0)
4049 : {
4050 4344 : ulong t = uel(y,2);
4051 4344 : if (t == 1) return x;
4052 42 : t = Fl_inv(t, p);
4053 42 : z = cgetg_copy(x, &l); z[1] = x[1];
4054 42 : for (i=2; i<l; i++) gel(z,i) = Flx_Fl_mul(gel(x,i),t,p);
4055 : }
4056 : else
4057 : {
4058 1851 : z = cgetg_copy(x, &l); z[1] = x[1];
4059 1851 : for (i=2; i<l; i++) gel(z,i) = Flx_div(gel(x,i),y,p);
4060 : }
4061 1891 : return z;
4062 : }
4063 :
4064 : GEN
4065 0 : FlxX_shift(GEN a, long n, long vs)
4066 : {
4067 0 : long i, l = lg(a);
4068 : GEN b;
4069 0 : if (l == 2 || !n) return a;
4070 0 : l += n;
4071 0 : if (n < 0)
4072 : {
4073 0 : if (l <= 2) return pol_0(varn(a));
4074 0 : b = cgetg(l, t_POL); b[1] = a[1];
4075 0 : a -= n;
4076 0 : for (i=2; i<l; i++) gel(b,i) = gel(a,i);
4077 : } else {
4078 0 : b = cgetg(l, t_POL); b[1] = a[1];
4079 0 : a -= n; n += 2;
4080 0 : for (i=2; i<n; i++) gel(b,i) = pol0_Flx(vs);
4081 0 : for ( ; i<l; i++) gel(b,i) = gel(a,i);
4082 : }
4083 0 : return b;
4084 : }
4085 :
4086 : static GEN
4087 131953 : FlxX_recipspec(GEN x, long l, long n, long vs)
4088 : {
4089 : long i;
4090 131953 : GEN z = cgetg(n+2,t_POL);
4091 131953 : z[1] = 0; z += 2;
4092 3091298 : for(i=0; i<l; i++)
4093 2959345 : gel(z,n-i-1) = Flx_copy(gel(x,i));
4094 137417 : for( ; i<n; i++)
4095 5464 : gel(z,n-i-1) = pol0_Flx(vs);
4096 131953 : return FlxX_renormalize(z-2,n+2);
4097 : }
4098 :
4099 : /***********************************************************************/
4100 : /** **/
4101 : /** FlxqX **/
4102 : /** **/
4103 : /***********************************************************************/
4104 :
4105 : static GEN
4106 1486552 : get_FlxqX_red(GEN T, GEN *B)
4107 : {
4108 1486552 : if (typ(T)!=t_VEC) { *B=NULL; return T; }
4109 74779 : *B = gel(T,1); return gel(T,2);
4110 : }
4111 :
4112 : GEN
4113 31100 : RgX_to_FlxqX(GEN x, GEN T, ulong p)
4114 : {
4115 31100 : long i, l = lg(x);
4116 31100 : GEN z = cgetg(l, t_POL); z[1] = x[1];
4117 575869 : for (i = 2; i < l; i++)
4118 544769 : gel(z,i) = Rg_to_Flxq(gel(x,i), T, p);
4119 31100 : return FlxX_renormalize(z, l);
4120 : }
4121 :
4122 : /* FlxqX are t_POL with Flxq coefficients.
4123 : * Normally the variable ordering should be respected.*/
4124 :
4125 : GEN
4126 474 : random_FlxqX(long d1, long v, GEN T, ulong p)
4127 : {
4128 474 : long dT = get_Flx_degree(T), vT = get_Flx_var(T);
4129 474 : long i, d = d1+2;
4130 474 : GEN y = cgetg(d,t_POL); y[1] = evalsigne(1) | evalvarn(v);
4131 474 : for (i=2; i<d; i++) gel(y,i) = random_Flx(dT, vT, p);
4132 474 : return FlxX_renormalize(y,d);
4133 : }
4134 :
4135 : /*Not stack clean*/
4136 : GEN
4137 802891 : Kronecker_to_FlxqX(GEN z, GEN T, ulong p)
4138 : {
4139 802891 : long i,j,lx,l, N = (get_Flx_degree(T)<<1) + 1;
4140 802891 : GEN x, t = cgetg(N,t_VECSMALL);
4141 802891 : t[1] = get_Flx_var(T);
4142 802891 : l = lg(z); lx = (l-2) / (N-2);
4143 802891 : x = cgetg(lx+3,t_POL);
4144 802891 : x[1] = z[1];
4145 15412528 : for (i=2; i<lx+2; i++)
4146 : {
4147 14609637 : for (j=2; j<N; j++) t[j] = z[j];
4148 14609637 : z += (N-2);
4149 14609637 : gel(x,i) = Flx_rem(Flx_renormalize(t,N), T,p);
4150 : }
4151 802891 : N = (l-2) % (N-2) + 2;
4152 802891 : for (j=2; j<N; j++) t[j] = z[j];
4153 802891 : gel(x,i) = Flx_rem(Flx_renormalize(t,N), T,p);
4154 802891 : return FlxX_renormalize(x, i+1);
4155 : }
4156 :
4157 : GEN
4158 986045 : FlxqX_red(GEN z, GEN T, ulong p)
4159 : {
4160 : GEN res;
4161 986045 : long i, l = lg(z);
4162 986045 : res = cgetg(l,t_POL); res[1] = z[1];
4163 986045 : for(i=2;i<l;i++) gel(res,i) = Flx_rem(gel(z,i),T,p);
4164 986045 : return FlxX_renormalize(res,l);
4165 : }
4166 :
4167 : static GEN
4168 164150 : FlxqX_mulspec(GEN x, GEN y, GEN T, ulong p, long lx, long ly)
4169 : {
4170 164150 : pari_sp ltop=avma;
4171 : GEN z,kx,ky;
4172 164150 : long dT = get_Flx_degree(T);
4173 164150 : kx= zxX_to_Kronecker_spec(x,lx,dT);
4174 164150 : ky= zxX_to_Kronecker_spec(y,ly,dT);
4175 164150 : z = Flx_mul(ky, kx, p);
4176 164150 : z = Kronecker_to_FlxqX(z,T,p);
4177 164150 : return gerepileupto(ltop,z);
4178 : }
4179 :
4180 : GEN
4181 427375 : FlxqX_mul(GEN x, GEN y, GEN T, ulong p)
4182 : {
4183 427375 : pari_sp ltop=avma;
4184 : GEN z,kx,ky;
4185 427375 : kx= zxX_to_Kronecker(x,get_Flx_mod(T));
4186 427375 : ky= zxX_to_Kronecker(y,get_Flx_mod(T));
4187 427375 : z = Flx_mul(ky, kx, p);
4188 427375 : z = Kronecker_to_FlxqX(z,T,p);
4189 427375 : return gerepileupto(ltop,z);
4190 : }
4191 :
4192 : GEN
4193 211366 : FlxqX_sqr(GEN x, GEN T, ulong p)
4194 : {
4195 211366 : pari_sp ltop=avma;
4196 : GEN z,kx;
4197 211366 : kx= zxX_to_Kronecker(x,get_Flx_mod(T));
4198 211366 : z = Flx_sqr(kx, p);
4199 211366 : z = Kronecker_to_FlxqX(z,T,p);
4200 211366 : return gerepileupto(ltop,z);
4201 : }
4202 :
4203 : GEN
4204 8176 : FlxqX_Flxq_mul(GEN P, GEN U, GEN T, ulong p)
4205 : {
4206 8176 : long i, lP = lg(P);
4207 8176 : GEN res = cgetg(lP,t_POL);
4208 8176 : res[1] = P[1];
4209 37625 : for(i=2; i<lP; i++)
4210 29449 : gel(res,i) = Flxq_mul(U,gel(P,i), T,p);
4211 8176 : return FlxX_renormalize(res, lP);
4212 : }
4213 : GEN
4214 225144 : FlxqX_Flxq_mul_to_monic(GEN P, GEN U, GEN T, ulong p)
4215 : {
4216 225144 : long i, lP = lg(P);
4217 225144 : GEN res = cgetg(lP,t_POL);
4218 225144 : res[1] = P[1];
4219 225144 : for(i=2; i<lP-1; i++) gel(res,i) = Flxq_mul(U,gel(P,i), T,p);
4220 225144 : gel(res,lP-1) = pol1_Flx(get_Flx_var(T));
4221 225144 : return FlxX_renormalize(res, lP);
4222 : }
4223 :
4224 : GEN
4225 172315 : FlxqX_normalize(GEN z, GEN T, ulong p)
4226 : {
4227 172315 : GEN p1 = leading_coeff(z);
4228 172315 : if (!lgpol(z) || (!degpol(p1) && p1[1] == 1)) return z;
4229 172294 : return FlxqX_Flxq_mul_to_monic(z, Flxq_inv(p1,T,p), T,p);
4230 : }
4231 :
4232 : /* x and y in Z[Y][X]. Assume T irreducible mod p */
4233 : static GEN
4234 1206809 : FlxqX_divrem_basecase(GEN x, GEN y, GEN T, ulong p, GEN *pr)
4235 : {
4236 : long vx, dx, dy, dz, i, j, sx, lr;
4237 : pari_sp av0, av, tetpil;
4238 : GEN z,p1,rem,lead;
4239 :
4240 1206809 : if (!signe(y)) pari_err_INV("FlxqX_divrem",y);
4241 1206809 : vx=varn(x); dy=degpol(y); dx=degpol(x);
4242 1206809 : if (dx < dy)
4243 : {
4244 12837 : if (pr)
4245 : {
4246 12698 : av0 = avma; x = FlxqX_red(x, T, p);
4247 12698 : if (pr == ONLY_DIVIDES) { avma=av0; return signe(x)? NULL: pol_0(vx); }
4248 12698 : if (pr == ONLY_REM) return x;
4249 12698 : *pr = x;
4250 : }
4251 12837 : return pol_0(vx);
4252 : }
4253 1193972 : lead = leading_coeff(y);
4254 1193972 : if (!dy) /* y is constant */
4255 : {
4256 114005 : if (pr && pr != ONLY_DIVIDES)
4257 : {
4258 109413 : if (pr == ONLY_REM) return pol_0(vx);
4259 5873 : *pr = pol_0(vx);
4260 : }
4261 10465 : if (Flx_equal1(lead)) return gcopy(x);
4262 6370 : av0 = avma; x = FlxqX_Flxq_mul(x,Flxq_inv(lead,T,p),T,p);
4263 6370 : return gerepileupto(av0,x);
4264 : }
4265 1079967 : av0 = avma; dz = dx-dy;
4266 1079967 : lead = Flx_equal1(lead)? NULL: gclone(Flxq_inv(lead,T,p));
4267 1079967 : avma = av0;
4268 1079967 : z = cgetg(dz+3,t_POL); z[1] = x[1];
4269 1079967 : x += 2; y += 2; z += 2;
4270 :
4271 1079967 : p1 = gel(x,dx); av = avma;
4272 1079967 : gel(z,dz) = lead? gerepileupto(av, Flxq_mul(p1,lead, T, p)): gcopy(p1);
4273 3011138 : for (i=dx-1; i>=dy; i--)
4274 : {
4275 1931171 : av=avma; p1=gel(x,i);
4276 7136827 : for (j=i-dy+1; j<=i && j<=dz; j++)
4277 5205656 : p1 = Flx_sub(p1, Flx_mul(gel(z,j),gel(y,i-j),p),p);
4278 1931171 : if (lead) p1 = Flx_mul(p1, lead,p);
4279 1931171 : tetpil=avma; gel(z,i-dy) = gerepile(av,tetpil,Flx_rem(p1,T,p));
4280 : }
4281 1079967 : if (!pr) { if (lead) gunclone(lead); return z-2; }
4282 :
4283 1048691 : rem = (GEN)avma; av = (pari_sp)new_chunk(dx+3);
4284 1293157 : for (sx=0; ; i--)
4285 : {
4286 1537623 : p1 = gel(x,i);
4287 4390472 : for (j=0; j<=i && j<=dz; j++)
4288 3097315 : p1 = Flx_sub(p1, Flx_mul(gel(z,j),gel(y,i-j),p),p);
4289 1293157 : tetpil=avma; p1 = Flx_rem(p1, T, p); if (lgpol(p1)) { sx = 1; break; }
4290 299983 : if (!i) break;
4291 244466 : avma=av;
4292 : }
4293 1048691 : if (pr == ONLY_DIVIDES)
4294 : {
4295 0 : if (lead) gunclone(lead);
4296 0 : if (sx) { avma=av0; return NULL; }
4297 0 : avma = (pari_sp)rem; return z-2;
4298 : }
4299 1048691 : lr=i+3; rem -= lr;
4300 1048691 : rem[0] = evaltyp(t_POL) | evallg(lr);
4301 1048691 : rem[1] = z[-1];
4302 1048691 : p1 = gerepile((pari_sp)rem,tetpil,p1);
4303 1048691 : rem += 2; gel(rem,i) = p1;
4304 10010884 : for (i--; i>=0; i--)
4305 : {
4306 8962193 : av=avma; p1 = gel(x,i);
4307 31833196 : for (j=0; j<=i && j<=dz; j++)
4308 22871003 : p1 = Flx_sub(p1, Flx_mul(gel(z,j),gel(y,i-j),p), p);
4309 8962193 : tetpil=avma; gel(rem,i) = gerepile(av,tetpil, Flx_rem(p1, T, p));
4310 : }
4311 1048691 : rem -= 2;
4312 1048691 : if (lead) gunclone(lead);
4313 1048691 : if (!sx) (void)FlxX_renormalize(rem, lr);
4314 1048691 : if (pr == ONLY_REM) return gerepileupto(av0,rem);
4315 193613 : *pr = rem; return z-2;
4316 : }
4317 :
4318 : static GEN
4319 1522 : FlxqX_invBarrett_basecase(GEN T, GEN Q, ulong p)
4320 : {
4321 1522 : long i, l=lg(T)-1, lr = l-1, k;
4322 1522 : long sv=Q[1];
4323 1522 : GEN r=cgetg(lr,t_POL); r[1]=T[1];
4324 1522 : gel(r,2) = pol1_Flx(sv);
4325 15491 : for (i=3;i<lr;i++)
4326 : {
4327 13969 : pari_sp ltop=avma;
4328 13969 : GEN u = Flx_neg(gel(T,l-i+2),p);
4329 96533 : for (k=3;k<i;k++)
4330 82564 : u = Flx_sub(u, Flxq_mul(gel(T,l-i+k),gel(r,k),Q,p),p);
4331 13969 : gel(r,i) = gerepileupto(ltop, u);
4332 : }
4333 1522 : r = FlxX_renormalize(r,lr);
4334 1522 : return r;
4335 : }
4336 :
4337 : /* Return new lgpol */
4338 : static long
4339 180858 : FlxX_lgrenormalizespec(GEN x, long lx)
4340 : {
4341 : long i;
4342 206878 : for (i = lx-1; i>=0; i--)
4343 206878 : if (lgpol(gel(x,i))) break;
4344 180858 : return i+1;
4345 : }
4346 :
4347 : static GEN
4348 3149 : FlxqX_invBarrett_Newton(GEN S, GEN T, ulong p)
4349 : {
4350 3149 : pari_sp av = avma;
4351 3149 : long nold, lx, lz, lq, l = degpol(S), i, lQ;
4352 3149 : GEN q, y, z, x = cgetg(l+2, t_POL) + 2;
4353 3149 : long dT = get_Flx_degree(T);
4354 3149 : ulong mask = quadratic_prec_mask(l-2); /* assume l > 2 */
4355 3149 : for (i=0;i<l;i++) gel(x,i) = pol0_Flx(T[1]);
4356 3149 : q = FlxX_recipspec(S+2,l+1,l+1,dT);
4357 3149 : lQ = lgpol(q); q+=2;
4358 : /* We work on _spec_ FlxX's, all the l[xzq] below are lgpol's */
4359 :
4360 : /* initialize */
4361 3149 : gel(x,0) = Flxq_inv(gel(q,0),T, p);
4362 3149 : if (lQ>1 && degpol(gel(q,1)) >= dT)
4363 0 : gel(q,1) = Flx_rem(gel(q,1), T, p);
4364 3149 : if (lQ>1 && lgpol(gel(q,1)))
4365 2145 : {
4366 2145 : GEN u = gel(q, 1);
4367 2145 : if (!Flx_equal1(gel(x,0))) u = Flxq_mul(u, Flxq_sqr(gel(x,0), T,p), T,p);
4368 2145 : gel(x,1) = Flx_neg(u, p); lx = 2;
4369 : }
4370 : else
4371 1004 : lx = 1;
4372 3149 : nold = 1;
4373 24892 : for (; mask > 1; )
4374 : { /* set x -= x(x*q - 1) + O(t^(nnew + 1)), knowing x*q = 1 + O(t^(nold+1)) */
4375 18594 : long i, lnew, nnew = nold << 1;
4376 :
4377 18594 : if (mask & 1) nnew--;
4378 18594 : mask >>= 1;
4379 :
4380 18594 : lnew = nnew + 1;
4381 18594 : lq = FlxX_lgrenormalizespec(q, minss(lQ,lnew));
4382 18594 : z = FlxqX_mulspec(x, q, T, p, lx, lq); /* FIXME: high product */
4383 18594 : lz = lgpol(z); if (lz > lnew) lz = lnew;
4384 18594 : z += 2;
4385 : /* subtract 1 [=>first nold words are 0]: renormalize so that z(0) != 0 */
4386 18594 : for (i = nold; i < lz; i++) if (lgpol(gel(z,i))) break;
4387 18594 : nold = nnew;
4388 18594 : if (i >= lz) continue; /* z-1 = 0(t^(nnew + 1)) */
4389 :
4390 : /* z + i represents (x*q - 1) / t^i */
4391 17712 : lz = FlxX_lgrenormalizespec (z+i, lz-i);
4392 17712 : z = FlxqX_mulspec(x, z+i, T,p, lx, lz); /* FIXME: low product */
4393 17712 : lz = lgpol(z); z += 2;
4394 17712 : if (lz > lnew-i) lz = FlxX_lgrenormalizespec(z, lnew-i);
4395 :
4396 17712 : lx = lz+ i;
4397 17712 : y = x + i; /* x -= z * t^i, in place */
4398 17712 : for (i = 0; i < lz; i++) gel(y,i) = Flx_neg(gel(z,i), p);
4399 : }
4400 3149 : x -= 2; setlg(x, lx + 2); x[1] = S[1];
4401 3149 : return gerepilecopy(av, x);
4402 : }
4403 :
4404 : /* x/polrecip(P)+O(x^n) */
4405 : GEN
4406 4671 : FlxqX_invBarrett(GEN T, GEN Q, ulong p)
4407 : {
4408 4671 : pari_sp ltop=avma;
4409 4671 : long l=lg(T), v = varn(T);
4410 : GEN r;
4411 4671 : GEN c = gel(T,l-1);
4412 4671 : if (l<5) return pol_0(v);
4413 4671 : if (l<=FlxqX_INVBARRETT_LIMIT)
4414 : {
4415 1522 : if (!Flx_equal1(c))
4416 : {
4417 0 : GEN ci = Flxq_inv(c,Q,p);
4418 0 : T = FlxqX_Flxq_mul(T, ci, Q, p);
4419 0 : r = FlxqX_invBarrett_basecase(T,Q,p);
4420 0 : r = FlxqX_Flxq_mul(r,ci,Q,p);
4421 : } else
4422 1522 : r = FlxqX_invBarrett_basecase(T,Q,p);
4423 : } else
4424 3149 : r = FlxqX_invBarrett_Newton(T,Q,p);
4425 4671 : return gerepileupto(ltop, r);
4426 : }
4427 :
4428 : GEN
4429 298570 : FlxqX_get_red(GEN S, GEN T, ulong p)
4430 : {
4431 298570 : if (typ(S)==t_POL && lg(S)>FlxqX_BARRETT_LIMIT)
4432 3104 : retmkvec2(FlxqX_invBarrett(S, T, p), S);
4433 295466 : return S;
4434 : }
4435 :
4436 : /* Compute x mod S where 2 <= degpol(S) <= l+1 <= 2*(degpol(S)-1)
4437 : * * and mg is the Barrett inverse of S. */
4438 : static GEN
4439 63922 : FlxqX_divrem_Barrettspec(GEN x, long l, GEN mg, GEN S, GEN T, ulong p, GEN *pr)
4440 : {
4441 : GEN q, r;
4442 63922 : long lt = degpol(S); /*We discard the leading term*/
4443 : long ld, lm, lT, lmg;
4444 63922 : ld = l-lt;
4445 63922 : lm = minss(ld, lgpol(mg));
4446 63922 : lT = FlxX_lgrenormalizespec(S+2,lt);
4447 63922 : lmg = FlxX_lgrenormalizespec(mg+2,lm);
4448 63922 : q = FlxX_recipspec(x+lt,ld,ld,0); /* q = rec(x) lq<=ld*/
4449 63922 : q = FlxqX_mulspec(q+2,mg+2,T,p,lgpol(q),lmg); /* q = rec(x) * mg lq<=ld+lm*/
4450 63922 : q = FlxX_recipspec(q+2,minss(ld,lgpol(q)),ld,0);/* q = rec (rec(x) * mg) lq<=ld*/
4451 63922 : if (!pr) return q;
4452 63922 : r = FlxqX_mulspec(q+2,S+2,T,p,lgpol(q),lT); /* r = q*pol lr<=ld+lt*/
4453 63922 : r = FlxX_subspec(x,r+2,p,lt,minss(lt,lgpol(r)));/* r = x - r lr<=lt */
4454 63922 : if (pr == ONLY_REM) return r;
4455 63922 : *pr = r; return q;
4456 : }
4457 :
4458 : static GEN
4459 53629 : FlxqX_divrem_Barrett_noGC(GEN x, GEN mg, GEN S, GEN T, ulong p, GEN *pr)
4460 : {
4461 53629 : long l = lgpol(x), lt = degpol(S), lm = 2*lt-1;
4462 53629 : GEN q = NULL, r;
4463 : long i;
4464 53629 : if (l <= lt)
4465 : {
4466 0 : if (pr == ONLY_REM) return RgX_copy(x);
4467 0 : if (pr == ONLY_DIVIDES) return signe(x)? NULL: pol_0(varn(x));
4468 0 : if (pr) *pr = RgX_copy(x);
4469 0 : return pol_0(varn(x));
4470 : }
4471 53629 : if (lt <= 1)
4472 0 : return FlxqX_divrem_basecase(x,S,T,p,pr);
4473 53629 : if (pr != ONLY_REM && l>lm)
4474 : {
4475 750 : long vT = get_Flx_var(T);
4476 750 : q = cgetg(l-lt+2, t_POL);
4477 750 : for (i=0;i<l-lt;i++) gel(q+2,i) = pol0_Flx(vT);
4478 : }
4479 53629 : r = l>lm ? shallowcopy(x): x;
4480 117633 : while (l>lm)
4481 : {
4482 10375 : GEN zr, zq = FlxqX_divrem_Barrettspec(r+2+l-lm,lm,mg,S,T,p,&zr);
4483 10375 : long lz = lgpol(zr);
4484 10375 : if (pr != ONLY_REM)
4485 : {
4486 2568 : long lq = lgpol(zq);
4487 2568 : for(i=0; i<lq; i++) gel(q+2+l-lm,i) = gel(zq,2+i);
4488 : }
4489 10375 : for(i=0; i<lz; i++) gel(r+2+l-lm,i) = gel(zr,2+i);
4490 10375 : l = l-lm+lz;
4491 : }
4492 53629 : if (pr != ONLY_REM)
4493 : {
4494 1065 : if (l > lt)
4495 : {
4496 983 : GEN zq = FlxqX_divrem_Barrettspec(r+2,l,mg,S,T,p,&r);
4497 983 : if (!q) q = zq;
4498 : else
4499 : {
4500 668 : long lq = lgpol(zq);
4501 668 : for(i=0; i<lq; i++) gel(q+2,i) = gel(zq,2+i);
4502 : }
4503 : }
4504 : else
4505 82 : { setlg(r, l+2); r = RgX_copy(r); }
4506 : }
4507 : else
4508 : {
4509 52564 : if (l > lt)
4510 52564 : (void) FlxqX_divrem_Barrettspec(r+2,l,mg,S,T,p,&r);
4511 : else
4512 0 : { setlg(r, l+2); r = RgX_copy(r); }
4513 52564 : r[1] = x[1]; return FlxX_renormalize(r, lg(r));
4514 : }
4515 1065 : if (pr) { r[1] = x[1]; r = FlxX_renormalize(r, lg(r)); }
4516 1065 : q[1] = x[1]; q = FlxX_renormalize(q, lg(q));
4517 1065 : if (pr == ONLY_DIVIDES) return signe(r)? NULL: q;
4518 1065 : if (pr) *pr = r;
4519 1065 : return q;
4520 : }
4521 :
4522 : GEN
4523 249256 : FlxqX_divrem(GEN x, GEN S, GEN T, ulong p, GEN *pr)
4524 : {
4525 249256 : GEN B, y = get_FlxqX_red(S, &B);
4526 249256 : long dy = degpol(y), dx = degpol(x), d = dx-dy;
4527 249256 : if (pr==ONLY_REM) return FlxqX_rem(x, y, T, p);
4528 249256 : if (!B && d+3 < FlxqX_DIVREM_BARRETT_LIMIT)
4529 248191 : return FlxqX_divrem_basecase(x,y,T,p,pr);
4530 : else
4531 : {
4532 1065 : pari_sp av=avma;
4533 1065 : GEN mg = B? B: FlxqX_invBarrett(y, T, p);
4534 1065 : GEN q = FlxqX_divrem_Barrett_noGC(x,mg,y,T,p,pr);
4535 1065 : if (!q) {avma=av; return NULL;}
4536 1065 : if (!pr || pr==ONLY_DIVIDES) return gerepilecopy(av, q);
4537 792 : gerepileall(av,2,&q,pr);
4538 792 : return q;
4539 : }
4540 : }
4541 :
4542 : GEN
4543 1236976 : FlxqX_rem(GEN x, GEN S, GEN T, ulong p)
4544 : {
4545 1236976 : GEN B, y = get_FlxqX_red(S, &B);
4546 1236976 : long dy = degpol(y), dx = degpol(x), d = dx-dy;
4547 1236976 : if (d < 0) return FlxqX_red(x, T, p);
4548 1011182 : if (!B && d+3 < FlxqX_REM_BARRETT_LIMIT)
4549 958618 : return FlxqX_divrem_basecase(x,y, T, p, ONLY_REM);
4550 : else
4551 : {
4552 52564 : pari_sp av=avma;
4553 52564 : GEN mg = B? B: FlxqX_invBarrett(y, T, p);
4554 52564 : GEN r = FlxqX_divrem_Barrett_noGC(x, mg, y, T, p, ONLY_REM);
4555 52564 : return gerepileupto(av, r);
4556 : }
4557 : }
4558 :
4559 : static GEN
4560 541 : FlxqX_halfgcd_basecase(GEN a, GEN b, GEN T, ulong p)
4561 : {
4562 541 : pari_sp av=avma;
4563 : GEN u,u1,v,v1;
4564 541 : long vx = varn(a);
4565 541 : long n = lgpol(a)>>1;
4566 541 : u1 = v = pol_0(vx);
4567 541 : u = v1 = pol1_FlxX(vx, get_Flx_var(T));
4568 9201 : while (lgpol(b)>n)
4569 : {
4570 8119 : GEN r, q = FlxqX_divrem(a,b, T, p, &r);
4571 8119 : a = b; b = r; swap(u,u1); swap(v,v1);
4572 8119 : u1 = FlxX_sub(u1, FlxqX_mul(u, q, T, p), p);
4573 8119 : v1 = FlxX_sub(v1, FlxqX_mul(v, q ,T, p), p);
4574 8119 : if (gc_needed(av,2))
4575 : {
4576 0 : if (DEBUGMEM>1) pari_warn(warnmem,"FlxqX_halfgcd (d = %ld)",degpol(b));
4577 0 : gerepileall(av,6, &a,&b,&u1,&v1,&u,&v);
4578 : }
4579 : }
4580 541 : return gerepilecopy(av, mkmat2(mkcol2(u,u1), mkcol2(v,v1)));
4581 : }
4582 : static GEN
4583 768 : FlxqX_addmulmul(GEN u, GEN v, GEN x, GEN y, GEN T, ulong p)
4584 : {
4585 768 : return FlxX_add(FlxqX_mul(u, x, T, p),FlxqX_mul(v, y, T, p), p);
4586 : }
4587 :
4588 : static GEN
4589 384 : FlxqXM_FlxqX_mul2(GEN M, GEN x, GEN y, GEN T, ulong p)
4590 : {
4591 384 : GEN res = cgetg(3, t_COL);
4592 384 : gel(res, 1) = FlxqX_addmulmul(gcoeff(M,1,1), gcoeff(M,1,2), x, y, T, p);
4593 384 : gel(res, 2) = FlxqX_addmulmul(gcoeff(M,2,1), gcoeff(M,2,2), x, y, T, p);
4594 384 : return res;
4595 : }
4596 :
4597 : static GEN
4598 360 : FlxqXM_mul2(GEN A, GEN B, GEN T, ulong p)
4599 : {
4600 360 : GEN A11=gcoeff(A,1,1),A12=gcoeff(A,1,2), B11=gcoeff(B,1,1),B12=gcoeff(B,1,2);
4601 360 : GEN A21=gcoeff(A,2,1),A22=gcoeff(A,2,2), B21=gcoeff(B,2,1),B22=gcoeff(B,2,2);
4602 360 : GEN M1 = FlxqX_mul(FlxX_add(A11,A22, p), FlxX_add(B11,B22, p), T, p);
4603 360 : GEN M2 = FlxqX_mul(FlxX_add(A21,A22, p), B11, T, p);
4604 360 : GEN M3 = FlxqX_mul(A11, FlxX_sub(B12,B22, p), T, p);
4605 360 : GEN M4 = FlxqX_mul(A22, FlxX_sub(B21,B11, p), T, p);
4606 360 : GEN M5 = FlxqX_mul(FlxX_add(A11,A12, p), B22, T, p);
4607 360 : GEN M6 = FlxqX_mul(FlxX_sub(A21,A11, p), FlxX_add(B11,B12, p), T, p);
4608 360 : GEN M7 = FlxqX_mul(FlxX_sub(A12,A22, p), FlxX_add(B21,B22, p), T, p);
4609 360 : GEN T1 = FlxX_add(M1,M4, p), T2 = FlxX_sub(M7,M5, p);
4610 360 : GEN T3 = FlxX_sub(M1,M2, p), T4 = FlxX_add(M3,M6, p);
4611 360 : retmkmat2(mkcol2(FlxX_add(T1,T2, p), FlxX_add(M2,M4, p)),
4612 : mkcol2(FlxX_add(M3,M5, p), FlxX_add(T3,T4, p)));
4613 : }
4614 :
4615 : /* Return [0,1;1,-q]*M */
4616 : static GEN
4617 360 : FlxqX_FlxqXM_qmul(GEN q, GEN M, GEN T, ulong p)
4618 : {
4619 360 : GEN u, v, res = cgetg(3, t_MAT);
4620 360 : u = FlxX_sub(gcoeff(M,1,1), FlxqX_mul(gcoeff(M,2,1), q, T, p), p);
4621 360 : gel(res,1) = mkcol2(gcoeff(M,2,1), u);
4622 360 : v = FlxX_sub(gcoeff(M,1,2), FlxqX_mul(gcoeff(M,2,2), q, T, p), p);
4623 360 : gel(res,2) = mkcol2(gcoeff(M,2,2), v);
4624 360 : return res;
4625 : }
4626 :
4627 : static GEN
4628 0 : matid2_FlxXM(long v, long sv)
4629 : {
4630 0 : retmkmat2(mkcol2(pol1_FlxX(v, sv),pol_0(v)),
4631 : mkcol2(pol_0(v),pol1_FlxX(v, sv)));
4632 : }
4633 :
4634 : static GEN
4635 363 : FlxqX_halfgcd_split(GEN x, GEN y, GEN T, ulong p)
4636 : {
4637 363 : pari_sp av=avma;
4638 : GEN R, S, V;
4639 : GEN y1, r, q;
4640 363 : long l = lgpol(x), n = l>>1, k;
4641 363 : if (lgpol(y)<=n) return matid2_FlxXM(varn(x),T[1]);
4642 363 : R = FlxqX_halfgcd(RgX_shift_shallow(x,-n),RgX_shift_shallow(y,-n), T, p);
4643 363 : V = FlxqXM_FlxqX_mul2(R,x,y, T, p); y1 = gel(V,2);
4644 363 : if (lgpol(y1)<=n) return gerepilecopy(av, R);
4645 360 : q = FlxqX_divrem(gel(V,1), y1, T, p, &r);
4646 360 : k = 2*n-degpol(y1);
4647 360 : S = FlxqX_halfgcd(RgX_shift_shallow(y1,-k), RgX_shift_shallow(r,-k), T, p);
4648 360 : return gerepileupto(av, FlxqXM_mul2(S,FlxqX_FlxqXM_qmul(q,R, T, p), T, p));
4649 : }
4650 :
4651 : /* Return M in GL_2(Fp[X]) such that:
4652 : if [a',b']~=M*[a,b]~ then degpol(a')>= (lgpol(a)>>1) >degpol(b')
4653 : */
4654 :
4655 : static GEN
4656 904 : FlxqX_halfgcd_i(GEN x, GEN y, GEN T, ulong p)
4657 : {
4658 904 : if (lg(x)<=FlxqX_HALFGCD_LIMIT) return FlxqX_halfgcd_basecase(x, y, T, p);
4659 363 : return FlxqX_halfgcd_split(x, y, T, p);
4660 : }
4661 :
4662 : GEN
4663 904 : FlxqX_halfgcd(GEN x, GEN y, GEN T, ulong p)
4664 : {
4665 904 : pari_sp av = avma;
4666 : GEN M,q,r;
4667 904 : if (!signe(x))
4668 : {
4669 0 : long v = varn(x), vT = get_Flx_var(T);
4670 0 : retmkmat2(mkcol2(pol_0(v),pol1_FlxX(v,vT)),
4671 : mkcol2(pol1_FlxX(v,vT),pol_0(v)));
4672 : }
4673 904 : if (degpol(y)<degpol(x)) return FlxqX_halfgcd_i(x, y, T, p);
4674 12 : q = FlxqX_divrem(y, x, T, p, &r);
4675 12 : M = FlxqX_halfgcd_i(x, r, T, p);
4676 12 : gcoeff(M,1,1) = FlxX_sub(gcoeff(M,1,1), FlxqX_mul(q, gcoeff(M,1,2), T, p), p);
4677 12 : gcoeff(M,2,1) = FlxX_sub(gcoeff(M,2,1), FlxqX_mul(q, gcoeff(M,2,2), T, p), p);
4678 12 : return gerepilecopy(av, M);
4679 : }
4680 :
4681 : static GEN
4682 149567 : FlxqX_gcd_basecase(GEN a, GEN b, GEN T, ulong p)
4683 : {
4684 149567 : pari_sp av = avma, av0=avma;
4685 965800 : while (signe(b))
4686 : {
4687 : GEN c;
4688 666666 : if (gc_needed(av0,2))
4689 : {
4690 28 : if (DEBUGMEM>1) pari_warn(warnmem,"FlxqX_gcd (d = %ld)",degpol(b));
4691 28 : gerepileall(av0,2, &a,&b);
4692 : }
4693 666666 : av = avma; c = FlxqX_rem(a, b, T, p); a=b; b=c;
4694 : }
4695 149567 : avma = av; return a;
4696 : }
4697 :
4698 : GEN
4699 154327 : FlxqX_gcd(GEN x, GEN y, GEN T, ulong p)
4700 : {
4701 154327 : pari_sp av = avma;
4702 154327 : x = FlxqX_red(x, T, p);
4703 154327 : y = FlxqX_red(y, T, p);
4704 154327 : if (!signe(x)) return gerepileupto(av, y);
4705 299155 : while (lg(y)>FlxqX_GCD_LIMIT)
4706 : {
4707 : GEN c;
4708 21 : if (lgpol(y)<=(lgpol(x)>>1))
4709 : {
4710 0 : GEN r = FlxqX_rem(x, y, T, p);
4711 0 : x = y; y = r;
4712 : }
4713 21 : c = FlxqXM_FlxqX_mul2(FlxqX_halfgcd(x,y, T, p), x, y, T, p);
4714 21 : x = gel(c,1); y = gel(c,2);
4715 21 : gerepileall(av,2,&x,&y);
4716 : }
4717 149567 : return gerepileupto(av, FlxqX_gcd_basecase(x, y, T, p));
4718 : }
4719 :
4720 : static GEN
4721 5880 : FlxqX_extgcd_basecase(GEN a, GEN b, GEN T, ulong p, GEN *ptu, GEN *ptv)
4722 : {
4723 5880 : pari_sp av=avma;
4724 : GEN u,v,d,d1,v1;
4725 5880 : long vx = varn(a);
4726 5880 : d = a; d1 = b;
4727 5880 : v = pol_0(vx); v1 = pol1_FlxX(vx, get_Flx_var(T));
4728 29561 : while (signe(d1))
4729 : {
4730 17801 : GEN r, q = FlxqX_divrem(d, d1, T, p, &r);
4731 17801 : v = FlxX_sub(v,FlxqX_mul(q,v1,T, p),p);
4732 17801 : u=v; v=v1; v1=u;
4733 17801 : u=r; d=d1; d1=u;
4734 17801 : if (gc_needed(av,2))
4735 : {
4736 0 : if (DEBUGMEM>1) pari_warn(warnmem,"FlxqX_extgcd (d = %ld)",degpol(d));
4737 0 : gerepileall(av,5, &d,&d1,&u,&v,&v1);
4738 : }
4739 : }
4740 5880 : if (ptu) *ptu = FlxqX_div(FlxX_sub(d,FlxqX_mul(b,v, T, p), p), a, T, p);
4741 5880 : *ptv = v; return d;
4742 : }
4743 :
4744 : static GEN
4745 0 : FlxqX_extgcd_halfgcd(GEN x, GEN y, GEN T, ulong p, GEN *ptu, GEN *ptv)
4746 : {
4747 0 : pari_sp av=avma;
4748 0 : GEN u,v,R = matid2_FlxXM(varn(x), get_Flx_var(T));
4749 0 : while (lg(y)>FlxqX_EXTGCD_LIMIT)
4750 : {
4751 : GEN M, c;
4752 0 : if (lgpol(y)<=(lgpol(x)>>1))
4753 : {
4754 0 : GEN r, q = FlxqX_divrem(x, y, T, p, &r);
4755 0 : x = y; y = r;
4756 0 : R = FlxqX_FlxqXM_qmul(q, R, T, p);
4757 : }
4758 0 : M = FlxqX_halfgcd(x,y, T, p);
4759 0 : c = FlxqXM_FlxqX_mul2(M, x,y, T, p);
4760 0 : R = FlxqXM_mul2(M, R, T, p);
4761 0 : x = gel(c,1); y = gel(c,2);
4762 0 : gerepileall(av,3,&x,&y,&R);
4763 : }
4764 0 : y = FlxqX_extgcd_basecase(x,y, T, p, &u,&v);
4765 0 : if (ptu) *ptu = FlxqX_addmulmul(u,v,gcoeff(R,1,1),gcoeff(R,2,1), T, p);
4766 0 : *ptv = FlxqX_addmulmul(u,v,gcoeff(R,1,2),gcoeff(R,2,2), T, p);
4767 0 : return y;
4768 : }
4769 :
4770 : /* x and y in Z[Y][X], return lift(gcd(x mod T,p, y mod T,p)). Set u and v st
4771 : * ux + vy = gcd (mod T,p) */
4772 : GEN
4773 5880 : FlxqX_extgcd(GEN x, GEN y, GEN T, ulong p, GEN *ptu, GEN *ptv)
4774 : {
4775 : GEN d;
4776 5880 : pari_sp ltop=avma;
4777 5880 : x = FlxqX_red(x, T, p);
4778 5880 : y = FlxqX_red(y, T, p);
4779 5880 : if (lg(y)>FlxqX_EXTGCD_LIMIT)
4780 0 : d = FlxqX_extgcd_halfgcd(x, y, T, p, ptu, ptv);
4781 : else
4782 5880 : d = FlxqX_extgcd_basecase(x, y, T, p, ptu, ptv);
4783 5880 : gerepileall(ltop,ptu?3:2,&d,ptv,ptu);
4784 5880 : return d;
4785 : }
4786 :
4787 : GEN
4788 9764 : FlxqX_safegcd(GEN P, GEN Q, GEN T, ulong p)
4789 : {
4790 9764 : pari_sp av = avma;
4791 : GEN U;
4792 9764 : if (!signe(P)) return gcopy(Q);
4793 9764 : if (!signe(Q)) return gcopy(P);
4794 : for(;;)
4795 : {
4796 76408 : U = Flxq_invsafe(leading_coeff(Q), T, p);
4797 43086 : if (!U) { avma = av; return NULL; }
4798 43086 : Q = FlxqX_Flxq_mul_to_monic(Q,U,T,p);
4799 43086 : P = FlxqX_rem(P,Q,T,p);
4800 43086 : if (!signe(P)) break;
4801 33322 : if (gc_needed(av, 1))
4802 : {
4803 0 : if (DEBUGMEM>1) pari_warn(warnmem,"FlxqX_safegcd");
4804 0 : gerepileall(av, 2, &P,&Q);
4805 : }
4806 33322 : swap(P, Q);
4807 : }
4808 9764 : U = Flxq_invsafe(leading_coeff(Q), T, p);
4809 9764 : if (!U) { avma = av; return NULL; }
4810 9764 : Q = FlxqX_Flxq_mul_to_monic(Q,U,T,p);
4811 9764 : return gerepileupto(av, Q);
4812 : }
4813 :
4814 : struct _FlxqX {ulong p; GEN T;};
4815 2484 : static GEN _FlxqX_mul(void *data,GEN a,GEN b)
4816 : {
4817 2484 : struct _FlxqX *d=(struct _FlxqX*)data;
4818 2484 : return FlxqX_mul(a,b,d->T,d->p);
4819 : }
4820 10255 : static GEN _FlxqX_sqr(void *data,GEN a)
4821 : {
4822 10255 : struct _FlxqX *d=(struct _FlxqX*)data;
4823 10255 : return FlxqX_sqr(a,d->T,d->p);
4824 : }
4825 :
4826 : GEN
4827 10227 : FlxqX_powu(GEN V, ulong n, GEN T, ulong p)
4828 : {
4829 10227 : struct _FlxqX d; d.p=p; d.T=T;
4830 10227 : return gen_powu(V, n, (void*)&d, &_FlxqX_sqr, &_FlxqX_mul);
4831 : }
4832 :
4833 : GEN
4834 1002 : FlxqXV_prod(GEN V, GEN T, ulong p)
4835 : {
4836 1002 : struct _FlxqX d; d.p=p; d.T=T;
4837 1002 : return gen_product(V, (void*)&d, &_FlxqX_mul);
4838 : }
4839 :
4840 : static GEN
4841 990 : FlxqV_roots_to_deg1(GEN x, GEN T, ulong p, long v)
4842 : {
4843 990 : long sv = get_Flx_var(T);
4844 990 : pari_APPLY_same(deg1pol_shallow(pol1_Flx(sv),Flx_neg(gel(x,i),p),v))
4845 : }
4846 :
4847 : GEN
4848 990 : FlxqV_roots_to_pol(GEN V, GEN T, ulong p, long v)
4849 : {
4850 990 : pari_sp ltop = avma;
4851 990 : GEN W = FlxqV_roots_to_deg1(V, T, p, v);
4852 990 : return gerepileupto(ltop, FlxqXV_prod(W, T, p));
4853 : }
4854 :
4855 : /*** FlxqM ***/
4856 :
4857 : GEN
4858 71239 : FlxqC_Flxq_mul(GEN x, GEN y, GEN T, ulong p)
4859 71239 : { pari_APPLY_type(t_COL, Flxq_mul(gel(x, i), y, T, p)) }
4860 :
4861 : GEN
4862 11844 : FlxqM_Flxq_mul(GEN x, GEN y, GEN T, ulong p)
4863 11844 : { pari_APPLY_same(FlxqC_Flxq_mul(gel(x, i), y, T, p)) }
4864 :
4865 : static GEN
4866 356149 : kron_pack_Flx_spec_half(GEN x, long l) {
4867 356149 : if (l == 0)
4868 173276 : return gen_0;
4869 182873 : return Flx_to_int_halfspec(x, l);
4870 : }
4871 :
4872 : static GEN
4873 21790 : kron_pack_Flx_spec(GEN x, long l) {
4874 : long i;
4875 : GEN w, y;
4876 21790 : if (l == 0)
4877 3880 : return gen_0;
4878 17910 : y = cgetipos(l + 2);
4879 71481 : for (i = 0, w = int_LSW(y); i < l; i++, w = int_nextW(w))
4880 53571 : *w = x[i];
4881 17910 : return y;
4882 : }
4883 :
4884 : static GEN
4885 0 : kron_pack_Flx_spec_2(GEN x, long l) {
4886 0 : return Flx_eval2BILspec(x, 2, l);
4887 : }
4888 :
4889 : static GEN
4890 0 : kron_pack_Flx_spec_3(GEN x, long l) {
4891 0 : return Flx_eval2BILspec(x, 3, l);
4892 : }
4893 :
4894 : static GEN
4895 98876 : kron_pack_Flx_spec_bits(GEN x, long b, long l) {
4896 : GEN y;
4897 : long i;
4898 98876 : if (l == 0)
4899 24185 : return gen_0;
4900 74691 : y = cgetg(l + 1, t_VECSMALL);
4901 379524 : for(i = 1; i <= l; i++)
4902 304833 : y[i] = x[l - i];
4903 74691 : return nv_fromdigits_2k(y, b);
4904 : }
4905 :
4906 : static GEN
4907 14740 : kron_unpack_Flx(GEN z, ulong p)
4908 : {
4909 14740 : long i, l = lgefint(z);
4910 14740 : GEN x = cgetg(l, t_VECSMALL), w;
4911 74179 : for (w = int_LSW(z), i = 2; i < l; w = int_nextW(w), i++)
4912 59439 : x[i] = ((ulong) *w) % p;
4913 14740 : return Flx_renormalize(x, l);
4914 : }
4915 :
4916 : static GEN
4917 0 : kron_unpack_Flx_2(GEN x, ulong p) {
4918 0 : long d = (lgefint(x)-1)/2 - 1;
4919 0 : return Z_mod2BIL_Flx_2(x, d, p);
4920 : }
4921 :
4922 : static GEN
4923 0 : kron_unpack_Flx_3(GEN x, ulong p) {
4924 0 : long d = lgefint(x)/3 - 1;
4925 0 : return Z_mod2BIL_Flx_3(x, d, p);
4926 : }
4927 :
4928 : /* assume b < BITS_IN_LONG */
4929 : static GEN
4930 53174 : kron_unpack_Flx_bits_narrow(GEN z, long b, ulong p) {
4931 53174 : GEN v = binary_2k_nv(z, b), x;
4932 53174 : long i, l = lg(v) + 1;
4933 53174 : x = cgetg(l, t_VECSMALL);
4934 332225 : for (i = 2; i < l; i++)
4935 279051 : x[i] = v[l - i] % p;
4936 53174 : return Flx_renormalize(x, l);
4937 : }
4938 :
4939 : static GEN
4940 7000 : kron_unpack_Flx_bits_wide(GEN z, long b, ulong p, ulong pi) {
4941 7000 : GEN v = binary_2k(z, b), x, y;
4942 7000 : long i, l = lg(v) + 1, ly;
4943 7000 : x = cgetg(l, t_VECSMALL);
4944 70000 : for (i = 2; i < l; i++) {
4945 63000 : y = gel(v, l - i);
4946 63000 : ly = lgefint(y);
4947 63000 : switch (ly) {
4948 0 : case 2: x[i] = 0; break;
4949 7849 : case 3: x[i] = *int_W_lg(y, 0, ly) % p; break;
4950 31574 : case 4: x[i] = remll_pre(*int_W_lg(y, 1, ly), *int_W_lg(y, 0, ly), p, pi); break;
4951 47154 : case 5: x[i] = remlll_pre(*int_W_lg(y, 2, ly), *int_W_lg(y, 1, ly),
4952 47154 : *int_W_lg(y, 0, ly), p, pi); break;
4953 0 : default: x[i] = umodiu(gel(v, l - i), p);
4954 : }
4955 : }
4956 7000 : return Flx_renormalize(x, l);
4957 : }
4958 :
4959 : static GEN
4960 21002 : FlxM_pack_ZM(GEN M, GEN (*pack)(GEN, long)) {
4961 : long i, j, l, lc;
4962 21002 : GEN N = cgetg_copy(M, &l), x;
4963 21002 : if (l == 1)
4964 0 : return N;
4965 21002 : lc = lgcols(M);
4966 132983 : for (j = 1; j < l; j++) {
4967 111981 : gel(N, j) = cgetg(lc, t_COL);
4968 489920 : for (i = 1; i < lc; i++) {
4969 377939 : x = gcoeff(M, i, j);
4970 377939 : gcoeff(N, i, j) = pack(x + 2, lgpol(x));
4971 : }
4972 : }
4973 21002 : return N;
4974 : }
4975 :
4976 : static GEN
4977 3825 : FlxM_pack_ZM_bits(GEN M, long b)
4978 : {
4979 : long i, j, l, lc;
4980 3825 : GEN N = cgetg_copy(M, &l), x;
4981 3825 : if (l == 1)
4982 0 : return N;
4983 3825 : lc = lgcols(M);
4984 23144 : for (j = 1; j < l; j++) {
4985 19319 : gel(N, j) = cgetg(lc, t_COL);
4986 118195 : for (i = 1; i < lc; i++) {
4987 98876 : x = gcoeff(M, i, j);
4988 98876 : gcoeff(N, i, j) = kron_pack_Flx_spec_bits(x + 2, b, lgpol(x));
4989 : }
4990 : }
4991 3825 : return N;
4992 : }
4993 :
4994 : static GEN
4995 10501 : ZM_unpack_FlxqM(GEN M, GEN T, ulong p, GEN (*unpack)(GEN, ulong))
4996 : {
4997 10501 : long i, j, l, lc, sv = get_Flx_var(T);
4998 10501 : GEN N = cgetg_copy(M, &l), x;
4999 10501 : if (l == 1)
5000 0 : return N;
5001 10501 : lc = lgcols(M);
5002 92313 : for (j = 1; j < l; j++) {
5003 81812 : gel(N, j) = cgetg(lc, t_COL);
5004 301950 : for (i = 1; i < lc; i++) {
5005 220138 : x = unpack(gcoeff(M, i, j), p);
5006 220138 : x[1] = sv;
5007 220138 : gcoeff(N, i, j) = Flx_rem(x, T, p);
5008 : }
5009 : }
5010 10501 : return N;
5011 : }
5012 :
5013 : static GEN
5014 1926 : ZM_unpack_FlxqM_bits(GEN M, long b, GEN T, ulong p)
5015 : {
5016 1926 : long i, j, l, lc, sv = get_Flx_var(T);
5017 1926 : GEN N = cgetg_copy(M, &l), x;
5018 1926 : if (l == 1)
5019 0 : return N;
5020 1926 : lc = lgcols(M);
5021 1926 : if (b < BITS_IN_LONG) {
5022 13899 : for (j = 1; j < l; j++) {
5023 12043 : gel(N, j) = cgetg(lc, t_COL);
5024 65217 : for (i = 1; i < lc; i++) {
5025 53174 : x = kron_unpack_Flx_bits_narrow(gcoeff(M, i, j), b, p);
5026 53174 : x[1] = sv;
5027 53174 : gcoeff(N, i, j) = Flx_rem(x, T, p);
5028 : }
5029 : }
5030 : } else {
5031 70 : ulong pi = get_Fl_red(p);
5032 770 : for (j = 1; j < l; j++) {
5033 700 : gel(N, j) = cgetg(lc, t_COL);
5034 7700 : for (i = 1; i < lc; i++) {
5035 7000 : x = kron_unpack_Flx_bits_wide(gcoeff(M, i, j), b, p, pi);
5036 7000 : x[1] = sv;
5037 7000 : gcoeff(N, i, j) = Flx_rem(x, T, p);
5038 : }
5039 : }
5040 : }
5041 1926 : return N;
5042 : }
5043 :
5044 : GEN
5045 12427 : FlxqM_mul_Kronecker(GEN A, GEN B, GEN T, ulong p)
5046 : {
5047 12427 : pari_sp av = avma;
5048 12427 : long b, d = degpol(T), n = lg(A) - 1;
5049 : GEN C, D, z;
5050 : GEN (*pack)(GEN, long), (*unpack)(GEN, ulong);
5051 12427 : int is_sqr = A==B;
5052 :
5053 12427 : z = muliu(muliu(sqru(p - 1), d), n);
5054 12427 : b = expi(z) + 1;
5055 : /* only do expensive bit-packing if it saves at least 1 limb */
5056 12427 : if (b <= BITS_IN_HALFULONG) {
5057 11971 : if (nbits2lg(d*b) - 2 == (d + 1)/2)
5058 10150 : b = BITS_IN_HALFULONG;
5059 : } else {
5060 456 : long l = lgefint(z) - 2;
5061 456 : if (nbits2lg(d*b) - 2 == d*l)
5062 351 : b = l*BITS_IN_LONG;
5063 : }
5064 12427 : avma = av;
5065 :
5066 12427 : switch (b) {
5067 : case BITS_IN_HALFULONG:
5068 10150 : pack = kron_pack_Flx_spec_half;
5069 10150 : unpack = int_to_Flx_half;
5070 10150 : break;
5071 : case BITS_IN_LONG:
5072 351 : pack = kron_pack_Flx_spec;
5073 351 : unpack = kron_unpack_Flx;
5074 351 : break;
5075 : case 2*BITS_IN_LONG:
5076 0 : pack = kron_pack_Flx_spec_2;
5077 0 : unpack = kron_unpack_Flx_2;
5078 0 : break;
5079 : case 3*BITS_IN_LONG:
5080 0 : pack = kron_pack_Flx_spec_3;
5081 0 : unpack = kron_unpack_Flx_3;
5082 0 : break;
5083 : default:
5084 1926 : A = FlxM_pack_ZM_bits(A, b);
5085 1926 : B = is_sqr? A: FlxM_pack_ZM_bits(B, b);
5086 1926 : C = ZM_mul(A, B);
5087 1926 : D = ZM_unpack_FlxqM_bits(C, b, T, p);
5088 1926 : return gerepilecopy(av, D);
5089 : }
5090 10501 : A = FlxM_pack_ZM(A, pack);
5091 10501 : B = is_sqr? A: FlxM_pack_ZM(B, pack);
5092 10501 : C = ZM_mul(A, B);
5093 10501 : D = ZM_unpack_FlxqM(C, T, p, unpack);
5094 10501 : return gerepilecopy(av, D);
5095 : }
5096 :
5097 : /*******************************************************************/
5098 : /* */
5099 : /* (Fl[X]/T(X))[Y] / S(Y) */
5100 : /* */
5101 : /*******************************************************************/
5102 :
5103 : GEN
5104 312400 : FlxqXQ_mul(GEN x, GEN y, GEN S, GEN T, ulong p) {
5105 312400 : return FlxqX_rem(FlxqX_mul(x,y,T,p),S,T,p);
5106 : }
5107 :
5108 : GEN
5109 193334 : FlxqXQ_sqr(GEN x, GEN S, GEN T, ulong p) {
5110 193334 : return FlxqX_rem(FlxqX_sqr(x,T,p),S,T,p);
5111 : }
5112 :
5113 : GEN
5114 14 : FlxqXQ_invsafe(GEN x, GEN S, GEN T, ulong p)
5115 : {
5116 14 : GEN V, z = FlxqX_extgcd(get_FlxqX_mod(S), x, T, p, NULL, &V);
5117 14 : if (degpol(z)) return NULL;
5118 14 : z = Flxq_invsafe(gel(z,2),T,p);
5119 14 : if (!z) return NULL;
5120 14 : return FlxqX_Flxq_mul(V, z, T, p);
5121 : }
5122 :
5123 : GEN
5124 14 : FlxqXQ_inv(GEN x, GEN S, GEN T,ulong p)
5125 : {
5126 14 : pari_sp av = avma;
5127 14 : GEN U = FlxqXQ_invsafe(x, S, T, p);
5128 14 : if (!U) pari_err_INV("FlxqXQ_inv",x);
5129 14 : return gerepileupto(av, U);
5130 : }
5131 :
5132 : GEN
5133 0 : FlxqXQ_div(GEN x, GEN y, GEN S, GEN T, ulong p) {
5134 0 : return FlxqXQ_mul(x, FlxqXQ_inv(y,S,T,p),S,T,p);
5135 : }
5136 :
5137 : struct _FlxqXQ {
5138 : GEN T, S;
5139 : ulong p;
5140 : };
5141 : static GEN
5142 535845 : _FlxqXQ_add(void *data, GEN x, GEN y) {
5143 535845 : struct _FlxqXQ *d = (struct _FlxqXQ*) data;
5144 535845 : return FlxX_add(x,y, d->p);
5145 : }
5146 : static GEN
5147 2121 : _FlxqXQ_sub(void *data, GEN x, GEN y) {
5148 2121 : struct _FlxqXQ *d = (struct _FlxqXQ*) data;
5149 2121 : return FlxX_sub(x,y, d->p);
5150 : }
5151 : static GEN
5152 657466 : _FlxqXQ_cmul(void *data, GEN P, long a, GEN x) {
5153 657466 : struct _FlxqXQ *d = (struct _FlxqXQ*) data;
5154 657466 : return FlxX_Flx_mul(x,gel(P,a+2), d->p);
5155 : }
5156 : static GEN
5157 351844 : _FlxqXQ_red(void *data, GEN x) {
5158 351844 : struct _FlxqXQ *d = (struct _FlxqXQ*) data;
5159 351844 : return FlxqX_red(x, d->T, d->p);
5160 : }
5161 : static GEN
5162 282704 : _FlxqXQ_mul(void *data, GEN x, GEN y) {
5163 282704 : struct _FlxqXQ *d = (struct _FlxqXQ*) data;
5164 282704 : return FlxqXQ_mul(x,y, d->S,d->T, d->p);
5165 : }
5166 : static GEN
5167 192935 : _FlxqXQ_sqr(void *data, GEN x) {
5168 192935 : struct _FlxqXQ *d = (struct _FlxqXQ*) data;
5169 192935 : return FlxqXQ_sqr(x, d->S,d->T, d->p);
5170 : }
5171 :
5172 : static GEN
5173 363716 : _FlxqXQ_one(void *data) {
5174 363716 : struct _FlxqXQ *d = (struct _FlxqXQ*) data;
5175 363716 : return pol1_FlxX(get_FlxqX_var(d->S),get_Flx_var(d->T));
5176 : }
5177 :
5178 : static GEN
5179 191 : _FlxqXQ_zero(void *data) {
5180 191 : struct _FlxqXQ *d = (struct _FlxqXQ*) data;
5181 191 : return pol_0(get_FlxqX_var(d->S));
5182 : }
5183 :
5184 : static struct bb_algebra FlxqXQ_algebra = { _FlxqXQ_red, _FlxqXQ_add,
5185 : _FlxqXQ_sub, _FlxqXQ_mul, _FlxqXQ_sqr, _FlxqXQ_one, _FlxqXQ_zero };
5186 :
5187 : const struct bb_algebra *
5188 219 : get_FlxqXQ_algebra(void **E, GEN S, GEN T, ulong p)
5189 : {
5190 219 : GEN z = new_chunk(sizeof(struct _FlxqXQ));
5191 219 : struct _FlxqXQ *e = (struct _FlxqXQ *) z;
5192 219 : e->T = Flx_get_red(T, p);
5193 219 : e->S = FlxqX_get_red(S, e->T, p);
5194 219 : e->p = p; *E = (void*)e;
5195 219 : return &FlxqXQ_algebra;
5196 : }
5197 :
5198 : /* x over Fq, return lift(x^n) mod S */
5199 : GEN
5200 42 : FlxqXQ_pow(GEN x, GEN n, GEN S, GEN T, ulong p)
5201 : {
5202 : struct _FlxqXQ D;
5203 42 : long s = signe(n);
5204 42 : if (!s) return pol1_FlxX(get_FlxqX_var(S),get_Flx_var(T));
5205 42 : if (s < 0) x = FlxqXQ_inv(x,S,T,p);
5206 42 : if (is_pm1(n)) return s < 0 ? x : gcopy(x);
5207 42 : if (degpol(x) >= get_FlxqX_degree(S)) x = FlxqX_rem(x,S,T,p);
5208 42 : T = Flx_get_red(T, p);
5209 42 : S = FlxqX_get_red(S, T, p);
5210 42 : D.S = S;
5211 42 : D.T = T;
5212 42 : D.p = p;
5213 42 : return gen_pow(x, n, (void*)&D, &_FlxqXQ_sqr, &_FlxqXQ_mul);
5214 : }
5215 :
5216 : /* x over Fq, return lift(x^n) mod S */
5217 : GEN
5218 72827 : FlxqXQ_powu(GEN x, ulong n, GEN S, GEN T, ulong p)
5219 : {
5220 : struct _FlxqXQ D;
5221 72827 : switch(n)
5222 : {
5223 0 : case 0: return pol1_FlxX(get_FlxqX_var(S),get_Flx_var(T));
5224 7532 : case 1: return gcopy(x);
5225 399 : case 2: return FlxqXQ_sqr(x, S, T, p);
5226 : }
5227 64896 : T = Flx_get_red(T, p);
5228 64896 : S = FlxqX_get_red(S, T, p);
5229 64896 : D.S = S; D.T = T; D.p = p;
5230 64896 : return gen_powu(x, n, (void*)&D, &_FlxqXQ_sqr, &_FlxqXQ_mul);
5231 : }
5232 :
5233 : GEN
5234 29052 : FlxqXQ_powers(GEN x, long l, GEN S, GEN T, ulong p)
5235 : {
5236 : struct _FlxqXQ D;
5237 29052 : int use_sqr = 2*degpol(x) >= get_FlxqX_degree(S);
5238 29052 : T = Flx_get_red(T, p);
5239 29052 : S = FlxqX_get_red(S, T, p);
5240 29052 : D.S = S; D.T = T; D.p = p;
5241 29052 : return gen_powers(x, l, use_sqr, (void*)&D, &_FlxqXQ_sqr, &_FlxqXQ_mul,&_FlxqXQ_one);
5242 : }
5243 :
5244 : static GEN
5245 486 : FlxqXn_mul(GEN a, GEN b, long n, GEN T, ulong p)
5246 : {
5247 486 : return RgXn_red_shallow(FlxqX_mul(a, b, T, p), n);
5248 : }
5249 :
5250 : /* Let v a linear form, return the linear form z->v(tau*z)
5251 : that is, v*(M_tau) */
5252 :
5253 : static GEN
5254 320 : FlxqXQ_transmul_init(GEN tau, GEN S, GEN T, ulong p)
5255 : {
5256 : GEN bht;
5257 320 : GEN h, Sp = get_FlxqX_red(S, &h);
5258 320 : long n = degpol(Sp), vS = varn(Sp), vT = get_Flx_var(T);
5259 320 : GEN ft = FlxX_recipspec(Sp+2, n+1, n+1, vT);
5260 320 : GEN bt = FlxX_recipspec(tau+2, lgpol(tau), n, vT);
5261 320 : setvarn(ft, vS); setvarn(bt, vS);
5262 320 : if (h)
5263 0 : bht = FlxqXn_mul(bt, h, n-1, T, p);
5264 : else
5265 : {
5266 320 : GEN bh = FlxqX_div(RgX_shift_shallow(tau, n-1), S, T, p);
5267 320 : bht = FlxX_recipspec(bh+2, lgpol(bh), n-1, vT);
5268 320 : setvarn(bht, vS);
5269 : }
5270 320 : return mkvec3(bt, bht, ft);
5271 : }
5272 :
5273 : static GEN
5274 632 : FlxqXQ_transmul(GEN tau, GEN a, long n, GEN T, ulong p)
5275 : {
5276 632 : pari_sp ltop = avma;
5277 : GEN t1, t2, t3, vec;
5278 632 : GEN bt = gel(tau, 1), bht = gel(tau, 2), ft = gel(tau, 3);
5279 632 : if (signe(a)==0) return pol_0(varn(a));
5280 618 : t2 = RgX_shift_shallow(FlxqX_mul(bt, a, T, p),1-n);
5281 618 : if (signe(bht)==0) return gerepilecopy(ltop, t2);
5282 486 : t1 = RgX_shift_shallow(FlxqX_mul(ft, a, T, p),-n);
5283 486 : t3 = FlxqXn_mul(t1, bht, n-1, T, p);
5284 486 : vec = FlxX_sub(t2, RgX_shift_shallow(t3, 1), p);
5285 486 : return gerepileupto(ltop, vec);
5286 : }
5287 :
5288 : static GEN
5289 160 : polxn_FlxX(long n, long v, long vT)
5290 : {
5291 160 : long i, a = n+2;
5292 160 : GEN p = cgetg(a+1, t_POL);
5293 160 : p[1] = evalsigne(1)|evalvarn(v);
5294 160 : for (i = 2; i < a; i++) gel(p,i) = pol0_Flx(vT);
5295 160 : gel(p,a) = pol1_Flx(vT); return p;
5296 : }
5297 :
5298 : GEN
5299 132 : FlxqXQ_minpoly(GEN x, GEN S, GEN T, ulong p)
5300 : {
5301 132 : pari_sp ltop = avma;
5302 : long vS, vT, n;
5303 : GEN v_x, g, tau;
5304 132 : vS = get_FlxqX_var(S);
5305 132 : vT = get_Flx_var(T);
5306 132 : n = get_FlxqX_degree(S);
5307 132 : g = pol1_FlxX(vS,vT);
5308 132 : tau = pol1_FlxX(vS,vT);
5309 132 : S = FlxqX_get_red(S, T, p);
5310 132 : v_x = FlxqXQ_powers(x, usqrt(2*n), S, T, p);
5311 424 : while(signe(tau) != 0)
5312 : {
5313 : long i, j, m, k1;
5314 : GEN M, v, tr;
5315 : GEN g_prime, c;
5316 160 : if (degpol(g) == n) { tau = pol1_FlxX(vS, vT); g = pol1_FlxX(vS, vT); }
5317 160 : v = random_FlxqX(n, vS, T, p);
5318 160 : tr = FlxqXQ_transmul_init(tau, S, T, p);
5319 160 : v = FlxqXQ_transmul(tr, v, n, T, p);
5320 160 : m = 2*(n-degpol(g));
5321 160 : k1 = usqrt(m);
5322 160 : tr = FlxqXQ_transmul_init(gel(v_x,k1+1), S, T, p);
5323 160 : c = cgetg(m+2,t_POL);
5324 160 : c[1] = evalsigne(1)|evalvarn(vS);
5325 632 : for (i=0; i<m; i+=k1)
5326 : {
5327 472 : long mj = minss(m-i, k1);
5328 1440 : for (j=0; j<mj; j++)
5329 968 : gel(c,m+1-(i+j)) = FlxqX_dotproduct(v, gel(v_x,j+1), T, p);
5330 472 : v = FlxqXQ_transmul(tr, v, n, T, p);
5331 : }
5332 160 : c = FlxX_renormalize(c, m+2);
5333 : /* now c contains <v,x^i> , i = 0..m-1 */
5334 160 : M = FlxqX_halfgcd(polxn_FlxX(m, vS, vT), c, T, p);
5335 160 : g_prime = gmael(M, 2, 2);
5336 160 : if (degpol(g_prime) < 1) continue;
5337 153 : g = FlxqX_mul(g, g_prime, T, p);
5338 153 : tau = FlxqXQ_mul(tau, FlxqX_FlxqXQV_eval(g_prime, v_x, S, T, p), S, T, p);
5339 : }
5340 132 : g = FlxqX_normalize(g,T, p);
5341 132 : return gerepilecopy(ltop,g);
5342 : }
5343 :
5344 : GEN
5345 0 : FlxqXQ_matrix_pow(GEN y, long n, long m, GEN S, GEN T, ulong p)
5346 : {
5347 0 : return FlxXV_to_FlxM(FlxqXQ_powers(y,m-1,S,T,p), n, T[1]);
5348 : }
5349 :
5350 : GEN
5351 57336 : FlxqX_FlxqXQV_eval(GEN P, GEN V, GEN S, GEN T, ulong p)
5352 : {
5353 : struct _FlxqXQ D;
5354 57336 : T = Flx_get_red(T, p);
5355 57336 : S = FlxqX_get_red(S, T, p);
5356 57336 : D.S=S; D.T=T; D.p=p;
5357 57336 : return gen_bkeval_powers(P, degpol(P), V, (void*)&D, &FlxqXQ_algebra,
5358 : _FlxqXQ_cmul);
5359 : }
5360 :
5361 : GEN
5362 64285 : FlxqX_FlxqXQ_eval(GEN Q, GEN x, GEN S, GEN T, ulong p)
5363 : {
5364 : struct _FlxqXQ D;
5365 64285 : int use_sqr = 2*degpol(x) >= get_FlxqX_degree(S);
5366 64285 : T = Flx_get_red(T, p);
5367 64285 : S = FlxqX_get_red(S, T, p);
5368 64285 : D.S=S; D.T=T; D.p=p;
5369 64285 : return gen_bkeval(Q, degpol(Q), x, use_sqr, (void*)&D, &FlxqXQ_algebra,
5370 : _FlxqXQ_cmul);
5371 : }
5372 :
5373 : static GEN
5374 62930 : FlxqXQ_autpow_sqr(void * E, GEN x)
5375 : {
5376 62930 : struct _FlxqXQ *D = (struct _FlxqXQ *)E;
5377 62930 : GEN S = D->S, T = D->T;
5378 62930 : ulong p = D->p;
5379 62930 : GEN phi = gel(x,1), S1 = gel(x,2);
5380 62930 : long n = brent_kung_optpow(get_Flx_degree(T)-1,lgpol(S1)+1,1);
5381 62930 : GEN V = Flxq_powers(phi, n, T, p);
5382 62930 : GEN phi2 = Flx_FlxqV_eval(phi, V, T, p);
5383 62930 : GEN Sphi = FlxY_FlxqV_evalx(S1, V, T, p);
5384 62930 : GEN S2 = FlxqX_FlxqXQ_eval(Sphi, S1, S, T, p);
5385 62930 : return mkvec2(phi2, S2);
5386 : }
5387 :
5388 : static GEN
5389 1126 : FlxqXQ_autpow_mul(void * E, GEN x, GEN y)
5390 : {
5391 1126 : struct _FlxqXQ *D = (struct _FlxqXQ *)E;
5392 1126 : GEN S = D->S, T = D->T;
5393 1126 : ulong p = D->p;
5394 1126 : GEN phi1 = gel(x,1), S1 = gel(x,2);
5395 1126 : GEN phi2 = gel(y,1), S2 = gel(y,2);
5396 1126 : long n = brent_kung_optpow(get_Flx_degree(T)-1,lgpol(S1)+1,1);
5397 1126 : GEN V = Flxq_powers(phi2, n, T, p);
5398 1126 : GEN phi3 = Flx_FlxqV_eval(phi1, V, T, p);
5399 1126 : GEN Sphi = FlxY_FlxqV_evalx(S1, V, T, p);
5400 1126 : GEN S3 = FlxqX_FlxqXQ_eval(Sphi, S2, S, T, p);
5401 1126 : return mkvec2(phi3, S3);
5402 : }
5403 :
5404 : GEN
5405 61572 : FlxqXQ_autpow(GEN aut, long n, GEN S, GEN T, ulong p)
5406 : {
5407 : struct _FlxqXQ D;
5408 61572 : T = Flx_get_red(T, p);
5409 61572 : S = FlxqX_get_red(S, T, p);
5410 61572 : D.S=S; D.T=T; D.p=p;
5411 61572 : return gen_powu(aut,n,&D,FlxqXQ_autpow_sqr,FlxqXQ_autpow_mul);
5412 : }
5413 :
5414 : static GEN
5415 28301 : FlxqXQ_autsum_mul(void *E, GEN x, GEN y)
5416 : {
5417 28301 : struct _FlxqXQ *D = (struct _FlxqXQ *)E;
5418 28301 : GEN S = D->S, T = D->T;
5419 28301 : ulong p = D->p;
5420 28301 : GEN phi1 = gel(x,1), S1 = gel(x,2), a1 = gel(x,3);
5421 28301 : GEN phi2 = gel(y,1), S2 = gel(y,2), a2 = gel(y,3);
5422 28301 : long n2 = brent_kung_optpow(get_Flx_degree(T)-1, lgpol(S1)+lgpol(a1)+1,1);
5423 28301 : GEN V2 = Flxq_powers(phi2, n2, T, p);
5424 28301 : GEN phi3 = Flx_FlxqV_eval(phi1, V2, T, p);
5425 28301 : GEN Sphi = FlxY_FlxqV_evalx(S1, V2, T, p);
5426 28301 : GEN aphi = FlxY_FlxqV_evalx(a1, V2, T, p);
5427 28301 : long n = brent_kung_optpow(maxss(degpol(Sphi),degpol(aphi)),2,1);
5428 28301 : GEN V = FlxqXQ_powers(S2, n, S, T, p);
5429 28301 : GEN S3 = FlxqX_FlxqXQV_eval(Sphi, V, S, T, p);
5430 28301 : GEN aS = FlxqX_FlxqXQV_eval(aphi, V, S, T, p);
5431 28301 : GEN a3 = FlxqXQ_mul(aS, a2, S, T, p);
5432 28301 : return mkvec3(phi3, S3, a3);
5433 : }
5434 :
5435 : static GEN
5436 16947 : FlxqXQ_autsum_sqr(void * T, GEN x)
5437 16947 : { return FlxqXQ_autsum_mul(T, x, x); }
5438 :
5439 : GEN
5440 10817 : FlxqXQ_autsum(GEN aut, long n, GEN S, GEN T, ulong p)
5441 : {
5442 : struct _FlxqXQ D;
5443 10817 : T = Flx_get_red(T, p);
5444 10817 : S = FlxqX_get_red(S, T, p);
5445 10817 : D.S=S; D.T=T; D.p=p;
5446 10817 : return gen_powu(aut,n,&D,FlxqXQ_autsum_sqr,FlxqXQ_autsum_mul);
5447 : }
5448 :
5449 : static GEN
5450 20 : FlxqXQ_auttrace_mul(void *E, GEN x, GEN y)
5451 : {
5452 20 : struct _FlxqXQ *D = (struct _FlxqXQ *)E;
5453 20 : GEN S = D->S, T = D->T;
5454 20 : ulong p = D->p;
5455 20 : GEN S1 = gel(x,1), a1 = gel(x,2);
5456 20 : GEN S2 = gel(y,1), a2 = gel(y,2);
5457 20 : long n = brent_kung_optpow(maxss(degpol(S1),degpol(a1)),2,1);
5458 20 : GEN V = FlxqXQ_powers(S2, n, S, T, p);
5459 20 : GEN S3 = FlxqX_FlxqXQV_eval(S1, V, S, T, p);
5460 20 : GEN aS = FlxqX_FlxqXQV_eval(a1, V, S, T, p);
5461 20 : GEN a3 = FlxX_add(aS, a2, p);
5462 20 : return mkvec2(S3, a3);
5463 : }
5464 :
5465 : static GEN
5466 20 : FlxqXQ_auttrace_sqr(void *E, GEN x)
5467 20 : { return FlxqXQ_auttrace_mul(E, x, x); }
5468 :
5469 : GEN
5470 314 : FlxqXQ_auttrace(GEN x, ulong n, GEN S, GEN T, ulong p)
5471 : {
5472 : struct _FlxqXQ D;
5473 314 : T = Flx_get_red(T, p);
5474 314 : S = FlxqX_get_red(S, T, p);
5475 314 : D.S=S; D.T=T; D.p=p;
5476 314 : return gen_powu(x,n,(void*)&D,FlxqXQ_auttrace_sqr,FlxqXQ_auttrace_mul);
5477 : }
5478 :
5479 : /*******************************************************************/
5480 : /* */
5481 : /* FlxYqQ */
5482 : /* */
5483 : /*******************************************************************/
5484 :
5485 : /*Preliminary implementation to speed up FpX_ffisom*/
5486 : typedef struct {
5487 : GEN S, T;
5488 : ulong p;
5489 : } FlxYqq_muldata;
5490 :
5491 : /* reduce x in Fl[X, Y] in the algebra Fl[X, Y]/ (P(X),Q(Y)) */
5492 : static GEN
5493 9618 : FlxYqq_redswap(GEN x, GEN S, GEN T, ulong p)
5494 : {
5495 9618 : pari_sp ltop=avma;
5496 9618 : long n = get_Flx_degree(S);
5497 9618 : long m = get_Flx_degree(T);
5498 9618 : long w = get_Flx_var(T);
5499 9618 : GEN V = FlxX_swap(x,m,w);
5500 9618 : V = FlxqX_red(V,S,p);
5501 9618 : V = FlxX_swap(V,n,w);
5502 9618 : return gerepilecopy(ltop,V);
5503 : }
5504 : static GEN
5505 6664 : FlxYqq_sqr(void *data, GEN x)
5506 : {
5507 6664 : FlxYqq_muldata *D = (FlxYqq_muldata*)data;
5508 6664 : return FlxYqq_redswap(FlxqX_sqr(x, D->T, D->p),D->S,D->T,D->p);
5509 : }
5510 :
5511 : static GEN
5512 2954 : FlxYqq_mul(void *data, GEN x, GEN y)
5513 : {
5514 2954 : FlxYqq_muldata *D = (FlxYqq_muldata*)data;
5515 2954 : return FlxYqq_redswap(FlxqX_mul(x,y, D->T, D->p),D->S,D->T,D->p);
5516 : }
5517 :
5518 : /* x in Z[X,Y], S in Z[X] over Fq = Z[Y]/(p,T); compute lift(x^n mod (S,T,p)) */
5519 : GEN
5520 3584 : FlxYqq_pow(GEN x, GEN n, GEN S, GEN T, ulong p)
5521 : {
5522 3584 : pari_sp av = avma;
5523 : FlxYqq_muldata D;
5524 : GEN y;
5525 3584 : D.S = S;
5526 3584 : D.T = T;
5527 3584 : D.p = p;
5528 3584 : y = gen_pow(x, n, (void*)&D, &FlxYqq_sqr, &FlxYqq_mul);
5529 3584 : return gerepileupto(av, y);
5530 : }
|
