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 583193164 : get_Flx_red(GEN T, GEN *B)
21 : {
22 583193164 : if (typ(T)!=t_VEC) { *B=NULL; return T; }
23 3097355 : *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 41466159 : Flx_to_ZX(GEN z)
48 : {
49 41466159 : long i, l = lg(z);
50 41466159 : GEN x = cgetg(l,t_POL);
51 41466341 : for (i=2; i<l; i++) gel(x,i) = utoi(z[i]);
52 41466158 : x[1] = evalsigne(l-2!=0)| z[1]; return x;
53 : }
54 :
55 : GEN
56 25095 : Flx_to_FlxX(GEN z, long sv)
57 : {
58 25095 : long i, l = lg(z);
59 25095 : GEN x = cgetg(l,t_POL);
60 25095 : for (i=2; i<l; i++) gel(x,i) = Fl_to_Flx(z[i], sv);
61 25095 : x[1] = evalsigne(l-2!=0)| z[1]; return x;
62 : }
63 :
64 : GEN
65 127589 : Flv_to_ZV(GEN z)
66 : {
67 127589 : long i, l = lg(z);
68 127589 : GEN x = cgetg(l, t_VEC);
69 127589 : for (i=1; i<l; i++) gel(x,i) = utoi(z[i]);
70 127589 : return x;
71 : }
72 :
73 : GEN
74 19411680 : Flc_to_ZC(GEN z)
75 : {
76 19411680 : long i, l = lg(z);
77 19411680 : GEN x = cgetg(l,t_COL);
78 19411680 : for (i=1; i<l; i++) gel(x,i) = utoi(z[i]);
79 19411680 : return x;
80 : }
81 :
82 : GEN
83 8087128 : Flm_to_ZM(GEN z)
84 : {
85 8087128 : long i, l = lg(z);
86 8087128 : GEN x = cgetg(l,t_MAT);
87 8087128 : for (i=1; i<l; i++) gel(x,i) = Flc_to_ZC(gel(z,i));
88 8087128 : return x;
89 : }
90 :
91 : /* same as Flx_to_ZX, in place */
92 : GEN
93 43605539 : Flx_to_ZX_inplace(GEN z)
94 : {
95 43605539 : long i, l = lg(z);
96 43605539 : for (i=2; i<l; i++) gel(z,i) = utoi(z[i]);
97 43605498 : settyp(z, t_POL); z[1]=evalsigne(l-2!=0)|z[1]; return z;
98 : }
99 :
100 : /*Flx_to_Flv=zx_to_zv*/
101 : GEN
102 4872932 : Flx_to_Flv(GEN x, long N)
103 : {
104 : long i, l;
105 4872932 : GEN z = cgetg(N+1,t_VECSMALL);
106 4872921 : if (typ(x) != t_VECSMALL) pari_err_TYPE("Flx_to_Flv",x);
107 4872941 : l = lg(x)-1; x++;
108 4872941 : for (i=1; i<l ; i++) z[i]=x[i];
109 4872941 : for ( ; i<=N; i++) z[i]=0;
110 4872941 : return z;
111 : }
112 :
113 : /*Flv_to_Flx=zv_to_zx*/
114 : GEN
115 796827 : Flv_to_Flx(GEN x, long sv)
116 : {
117 796827 : long i, l=lg(x)+1;
118 796827 : GEN z = cgetg(l,t_VECSMALL); z[1]=sv;
119 796825 : x--;
120 796825 : for (i=2; i<l ; i++) z[i]=x[i];
121 796825 : return Flx_renormalize(z,l);
122 : }
123 :
124 : /*Flm_to_FlxV=zm_to_zxV*/
125 : GEN
126 282216 : Flm_to_FlxV(GEN x, long sv)
127 : {
128 282216 : long j, lx = lg(x);
129 282216 : GEN y = cgetg(lx, t_VEC);
130 282216 : for (j=1; j<lx; j++) gel(y,j) = Flv_to_Flx(gel(x,j), sv);
131 282216 : return y;
132 : }
133 :
134 : /*FlxC_to_ZXC=zxC_to_ZXC*/
135 : GEN
136 21072 : FlxC_to_ZXC(GEN x)
137 : {
138 21072 : long i, l=lg(x);
139 21072 : GEN z = cgetg(l,t_COL);
140 21072 : for (i=1; i<l ; i++) gel(z,i) = Flx_to_ZX(gel(x,i));
141 21072 : return z;
142 : }
143 :
144 : /*FlxC_to_ZXC=zxV_to_ZXV*/
145 : GEN
146 160481 : FlxV_to_ZXV(GEN x)
147 : {
148 160481 : long i, l=lg(x);
149 160481 : GEN z = cgetg(l,t_VEC);
150 160481 : for (i=1; i<l ; i++) gel(z,i) = Flx_to_ZX(gel(x,i));
151 160481 : return z;
152 : }
153 :
154 : /*FlxM_to_ZXM=zxM_to_ZXM*/
155 : GEN
156 2576 : FlxM_to_ZXM(GEN z)
157 : {
158 : long i, l;
159 2576 : GEN x = cgetg_copy(z, &l);
160 2576 : for (i=1; i<l; i++) gel(x,i) = FlxC_to_ZXC(gel(z,i));
161 2576 : return x;
162 : }
163 :
164 : GEN
165 0 : FlxM_Flx_add_shallow(GEN x, GEN y, ulong p)
166 : {
167 0 : long l = lg(x), i, j;
168 0 : GEN z = cgetg(l,t_MAT);
169 :
170 0 : if (l==1) return z;
171 0 : if (l != lgcols(x)) pari_err_OP( "+", x, y);
172 0 : for (i=1; i<l; i++)
173 : {
174 0 : GEN zi = cgetg(l,t_COL), xi = gel(x,i);
175 0 : gel(z,i) = zi;
176 0 : for (j=1; j<l; j++) gel(zi,j) = gel(xi,j);
177 0 : gel(zi,i) = Flx_add(gel(zi,i), y, p);
178 : }
179 0 : return z;
180 : }
181 :
182 : /***********************************************************************/
183 : /** **/
184 : /** Conversion to Flx **/
185 : /** **/
186 : /***********************************************************************/
187 : /* Take an integer and return a scalar polynomial mod p, with evalvarn=vs */
188 : GEN
189 9210591 : Fl_to_Flx(ulong x, long sv)
190 : {
191 9210591 : return x? mkvecsmall2(sv, x): pol0_Flx(sv);
192 : }
193 :
194 : /* a X^d */
195 : GEN
196 32688 : monomial_Flx(ulong a, long d, long vs)
197 : {
198 : GEN P;
199 32688 : if (a==0) return pol0_Flx(vs);
200 32688 : P = const_vecsmall(d+2, 0);
201 32688 : P[1] = vs; P[d+2] = a;
202 32688 : return P;
203 : }
204 :
205 : GEN
206 1235591 : Z_to_Flx(GEN x, ulong p, long sv)
207 : {
208 1235591 : long u = umodiu(x,p);
209 1235594 : return u? mkvecsmall2(sv, u): pol0_Flx(sv);
210 : }
211 :
212 : /* return x[0 .. dx] mod p as t_VECSMALL. Assume x a t_POL*/
213 : GEN
214 175665512 : ZX_to_Flx(GEN x, ulong p)
215 : {
216 175665512 : long i, lx = lg(x);
217 175665512 : GEN a = cgetg(lx, t_VECSMALL);
218 175671461 : a[1]=((ulong)x[1])&VARNBITS;
219 175671461 : for (i=2; i<lx; i++) a[i] = umodiu(gel(x,i), p);
220 175665617 : return Flx_renormalize(a,lx);
221 : }
222 :
223 : /* return x[0 .. dx] mod p as t_VECSMALL. Assume x a t_POL*/
224 : GEN
225 2853809 : zx_to_Flx(GEN x, ulong p)
226 : {
227 2853809 : long i, lx = lg(x);
228 2853809 : GEN a = cgetg(lx, t_VECSMALL);
229 2853809 : a[1] = x[1];
230 2853809 : for (i=2; i<lx; i++) uel(a,i) = umodsu(x[i], p);
231 2853809 : return Flx_renormalize(a,lx);
232 : }
233 :
234 : ulong
235 42101137 : Rg_to_Fl(GEN x, ulong p)
236 : {
237 42101137 : switch(typ(x))
238 : {
239 29634329 : case t_INT: return umodiu(x, p);
240 : case t_FRAC: {
241 32987 : ulong z = umodiu(gel(x,1), p);
242 32987 : if (!z) return 0;
243 29718 : return Fl_div(z, umodiu(gel(x,2), p), p);
244 : }
245 49 : case t_PADIC: return padic_to_Fl(x, p);
246 : case t_INTMOD: {
247 12433772 : GEN q = gel(x,1), a = gel(x,2);
248 12433772 : if (absequaliu(q, p)) return itou(a);
249 0 : if (!dvdiu(q,p)) pari_err_MODULUS("Rg_to_Fl", q, utoi(p));
250 0 : return umodiu(a, p);
251 : }
252 0 : default: pari_err_TYPE("Rg_to_Fl",x);
253 : return 0; /* LCOV_EXCL_LINE */
254 : }
255 : }
256 :
257 : ulong
258 1656534 : Rg_to_F2(GEN x)
259 : {
260 1656534 : switch(typ(x))
261 : {
262 253608 : case t_INT: return mpodd(x);
263 : case t_FRAC:
264 140 : if (!mpodd(gel(x,2))) (void)Fl_inv(0,2); /* error */
265 140 : return mpodd(gel(x,1));
266 : case t_PADIC:
267 0 : if (!absequaliu(gel(x,2),2)) pari_err_OP("",x, mkintmodu(1,2));
268 0 : if (valp(x) < 0) (void)Fl_inv(0,2);
269 0 : return valp(x) & 1;
270 : case t_INTMOD: {
271 1402786 : GEN q = gel(x,1), a = gel(x,2);
272 1402786 : if (mpodd(q)) pari_err_MODULUS("Rg_to_F2", q, gen_2);
273 1402786 : return mpodd(a);
274 : }
275 0 : default: pari_err_TYPE("Rg_to_F2",x);
276 : return 0; /* LCOV_EXCL_LINE */
277 : }
278 : }
279 :
280 : GEN
281 1260688 : RgX_to_Flx(GEN x, ulong p)
282 : {
283 1260688 : long i, lx = lg(x);
284 1260688 : GEN a = cgetg(lx, t_VECSMALL);
285 1260688 : a[1]=((ulong)x[1])&VARNBITS;
286 1260688 : for (i=2; i<lx; i++) a[i] = Rg_to_Fl(gel(x,i), p);
287 1260688 : return Flx_renormalize(a,lx);
288 : }
289 :
290 : /* If x is a POLMOD, assume modulus is a multiple of T. */
291 : GEN
292 1461916 : Rg_to_Flxq(GEN x, GEN T, ulong p)
293 : {
294 1461916 : long ta, tx = typ(x), v = T[1];
295 : GEN a, b;
296 1461916 : if (is_const_t(tx))
297 : {
298 1401212 : if (tx == t_FFELT) return FF_to_Flxq(x);
299 614454 : return Fl_to_Flx(Rg_to_Fl(x, p), v);
300 : }
301 60704 : switch(tx)
302 : {
303 : case t_POLMOD:
304 616 : b = gel(x,1);
305 616 : a = gel(x,2); ta = typ(a);
306 616 : if (is_const_t(ta)) return Fl_to_Flx(Rg_to_Fl(a, p), v);
307 525 : b = RgX_to_Flx(b, p); if (b[1] != v) break;
308 525 : a = RgX_to_Flx(a, p); if (Flx_equal(b,T)) return a;
309 0 : if (lgpol(Flx_rem(b,T,p))==0) return Flx_rem(a, T, p);
310 0 : break;
311 : case t_POL:
312 59983 : x = RgX_to_Flx(x,p);
313 59983 : if (x[1] != v) break;
314 59983 : return Flx_rem(x, T, p);
315 : case t_RFRAC:
316 105 : a = Rg_to_Flxq(gel(x,1), T,p);
317 105 : b = Rg_to_Flxq(gel(x,2), T,p);
318 105 : return Flxq_div(a,b, T,p);
319 : }
320 0 : pari_err_TYPE("Rg_to_Flxq",x);
321 : return NULL; /* LCOV_EXCL_LINE */
322 : }
323 :
324 : /***********************************************************************/
325 : /** **/
326 : /** Basic operation on Flx **/
327 : /** **/
328 : /***********************************************************************/
329 : /* = zx_renormalize. Similar to normalizepol, in place */
330 : GEN
331 1393141097 : Flx_renormalize(GEN /*in place*/ x, long lx)
332 : {
333 : long i;
334 1572038163 : for (i = lx-1; i>1; i--)
335 1533474309 : if (x[i]) break;
336 1393141097 : stackdummy((pari_sp)(x + lg(x)), (pari_sp)(x + i+1));
337 1393113479 : setlg(x, i+1); return x;
338 : }
339 :
340 : GEN
341 378798 : Flx_red(GEN z, ulong p)
342 : {
343 378798 : long i, l = lg(z);
344 378798 : GEN x = cgetg(l, t_VECSMALL);
345 378864 : x[1] = z[1];
346 378864 : for (i=2; i<l; i++) x[i] = uel(z,i)%p;
347 378864 : return Flx_renormalize(x,l);
348 : }
349 :
350 : GEN
351 758226 : random_Flx(long d1, long vs, ulong p)
352 : {
353 758226 : long i, d = d1+2;
354 758226 : GEN y = cgetg(d,t_VECSMALL); y[1] = vs;
355 758225 : for (i=2; i<d; i++) y[i] = random_Fl(p);
356 758226 : return Flx_renormalize(y,d);
357 : }
358 :
359 : static GEN
360 7117 : Flx_addspec(GEN x, GEN y, ulong p, long lx, long ly)
361 : {
362 : long i,lz;
363 : GEN z;
364 :
365 7117 : if (ly>lx) swapspec(x,y, lx,ly);
366 7117 : lz = lx+2; z = cgetg(lz, t_VECSMALL) + 2;
367 7117 : for (i=0; i<ly; i++) z[i] = Fl_add(x[i], y[i], p);
368 7117 : for ( ; i<lx; i++) z[i] = x[i];
369 7117 : z -= 2; return Flx_renormalize(z, lz);
370 : }
371 :
372 : GEN
373 43432465 : Flx_add(GEN x, GEN y, ulong p)
374 : {
375 : long i,lz;
376 : GEN z;
377 43432465 : long lx=lg(x);
378 43432465 : long ly=lg(y);
379 43432465 : if (ly>lx) swapspec(x,y, lx,ly);
380 43432465 : lz = lx; z = cgetg(lz, t_VECSMALL); z[1]=x[1];
381 43392653 : for (i=2; i<ly; i++) z[i] = Fl_add(x[i], y[i], p);
382 43433758 : for ( ; i<lx; i++) z[i] = x[i];
383 43433758 : return Flx_renormalize(z, lz);
384 : }
385 :
386 : GEN
387 8087733 : Flx_Fl_add(GEN y, ulong x, ulong p)
388 : {
389 : GEN z;
390 : long lz, i;
391 8087733 : if (!lgpol(y))
392 263163 : return Fl_to_Flx(x,y[1]);
393 7824212 : lz=lg(y);
394 7824212 : z=cgetg(lz,t_VECSMALL);
395 7822624 : z[1]=y[1];
396 7822624 : z[2] = Fl_add(y[2],x,p);
397 42715221 : for(i=3;i<lz;i++)
398 34891067 : z[i] = y[i];
399 7824154 : if (lz==3) z = Flx_renormalize(z,lz);
400 7824014 : return z;
401 : }
402 :
403 : static GEN
404 1735745 : Flx_subspec(GEN x, GEN y, ulong p, long lx, long ly)
405 : {
406 : long i,lz;
407 : GEN z;
408 :
409 1735745 : if (ly <= lx)
410 : {
411 1735745 : lz = lx+2; z = cgetg(lz, t_VECSMALL)+2;
412 1736885 : for (i=0; i<ly; i++) z[i] = Fl_sub(x[i],y[i],p);
413 1735760 : for ( ; i<lx; i++) z[i] = x[i];
414 : }
415 : else
416 : {
417 0 : lz = ly+2; z = cgetg(lz, t_VECSMALL)+2;
418 0 : for (i=0; i<lx; i++) z[i] = Fl_sub(x[i],y[i],p);
419 0 : for ( ; i<ly; i++) z[i] = Fl_neg(y[i],p);
420 : }
421 1735760 : return Flx_renormalize(z-2, lz);
422 : }
423 :
424 : GEN
425 56024718 : Flx_sub(GEN x, GEN y, ulong p)
426 : {
427 56024718 : long i,lz,lx = lg(x), ly = lg(y);
428 : GEN z;
429 :
430 56024718 : if (ly <= lx)
431 : {
432 27393397 : lz = lx; z = cgetg(lz, t_VECSMALL);
433 27395881 : for (i=2; i<ly; i++) z[i] = Fl_sub(x[i],y[i],p);
434 27393242 : for ( ; i<lx; i++) z[i] = x[i];
435 : }
436 : else
437 : {
438 28631321 : lz = ly; z = cgetg(lz, t_VECSMALL);
439 28631425 : for (i=2; i<lx; i++) z[i] = Fl_sub(x[i],y[i],p);
440 28631323 : for ( ; i<ly; i++) z[i] = y[i]? (long)(p - y[i]): y[i];
441 : }
442 56024565 : z[1]=x[1]; return Flx_renormalize(z, lz);
443 : }
444 :
445 : static GEN
446 1046057 : Flx_negspec(GEN x, ulong p, long l)
447 : {
448 : long i;
449 1046057 : GEN z = cgetg(l+2, t_VECSMALL) + 2;
450 1045867 : for (i=0; i<l; i++) z[i] = Fl_neg(x[i], p);
451 1046098 : return z-2;
452 : }
453 :
454 :
455 : GEN
456 1046060 : Flx_neg(GEN x, ulong p)
457 : {
458 1046060 : GEN z = Flx_negspec(x+2, p, lgpol(x));
459 1046108 : z[1] = x[1];
460 1046108 : return z;
461 : }
462 :
463 : GEN
464 1601 : Flx_neg_inplace(GEN x, ulong p)
465 : {
466 1601 : long i, l = lg(x);
467 373768 : for (i=2; i<l; i++)
468 372167 : if (x[i]) x[i] = p - x[i];
469 1601 : return x;
470 : }
471 :
472 : GEN
473 1800086 : Flx_double(GEN y, ulong p)
474 : {
475 : long i, l;
476 1800086 : GEN z = cgetg_copy(y, &l); z[1] = y[1];
477 1800086 : for(i=2; i<l; i++) z[i] = Fl_double(y[i], p);
478 1800086 : return Flx_renormalize(z, l);
479 : }
480 : GEN
481 635520 : Flx_triple(GEN y, ulong p)
482 : {
483 : long i, l;
484 635520 : GEN z = cgetg_copy(y, &l); z[1] = y[1];
485 635520 : for(i=2; i<l; i++) z[i] = Fl_triple(y[i], p);
486 635520 : return Flx_renormalize(z, l);
487 : }
488 : GEN
489 29116334 : Flx_Fl_mul(GEN y, ulong x, ulong p)
490 : {
491 : GEN z;
492 : long i, l;
493 29116334 : if (!x) return pol0_Flx(y[1]);
494 21521948 : z = cgetg_copy(y, &l); z[1] = y[1];
495 21521894 : if (HIGHWORD(x | p))
496 134119 : for(i=2; i<l; i++) z[i] = Fl_mul(y[i], x, p);
497 : else
498 21387775 : for(i=2; i<l; i++) z[i] = (y[i] * x) % p;
499 21521894 : return Flx_renormalize(z, l);
500 : }
501 : GEN
502 7276316 : Flx_Fl_mul_to_monic(GEN y, ulong x, ulong p)
503 : {
504 : GEN z;
505 : long i, l;
506 7276316 : z = cgetg_copy(y, &l); z[1] = y[1];
507 7275472 : if (HIGHWORD(x | p))
508 2198617 : for(i=2; i<l-1; i++) z[i] = Fl_mul(y[i], x, p);
509 : else
510 5076855 : for(i=2; i<l-1; i++) z[i] = (y[i] * x) % p;
511 7275455 : z[l-1] = 1; return z;
512 : }
513 :
514 : /* Return a*x^n if n>=0 and a\x^(-n) if n<0 */
515 : GEN
516 2957366 : Flx_shift(GEN a, long n)
517 : {
518 2957366 : long i, l = lg(a);
519 : GEN b;
520 2957366 : if (l==2 || !n) return Flx_copy(a);
521 2943778 : if (l+n<=2) return pol0_Flx(a[1]);
522 2942709 : b = cgetg(l+n, t_VECSMALL);
523 2942715 : b[1] = a[1];
524 2942715 : if (n < 0)
525 250113 : for (i=2-n; i<l; i++) b[i+n] = a[i];
526 : else
527 : {
528 2692602 : for (i=0; i<n; i++) b[2+i] = 0;
529 2692602 : for (i=2; i<l; i++) b[i+n] = a[i];
530 : }
531 2942715 : return b;
532 : }
533 :
534 : GEN
535 42564782 : Flx_normalize(GEN z, ulong p)
536 : {
537 42564782 : long l = lg(z)-1;
538 42564782 : ulong p1 = z[l]; /* leading term */
539 42564782 : if (p1 == 1) return z;
540 7275210 : return Flx_Fl_mul_to_monic(z, Fl_inv(p1,p), p);
541 : }
542 :
543 : /* return (x * X^d) + y. Assume d > 0, x > 0 and y >= 0 */
544 : static GEN
545 3682 : Flx_addshift(GEN x, GEN y, ulong p, long d)
546 : {
547 3682 : GEN xd,yd,zd = (GEN)avma;
548 3682 : long a,lz,ny = lgpol(y), nx = lgpol(x);
549 3682 : long vs = x[1];
550 :
551 3682 : x += 2; y += 2; a = ny-d;
552 3682 : if (a <= 0)
553 : {
554 7 : lz = (a>nx)? ny+2: nx+d+2;
555 7 : (void)new_chunk(lz); xd = x+nx; yd = y+ny;
556 7 : while (xd > x) *--zd = *--xd;
557 7 : x = zd + a;
558 7 : while (zd > x) *--zd = 0;
559 : }
560 : else
561 : {
562 3675 : xd = new_chunk(d); yd = y+d;
563 3675 : x = Flx_addspec(x,yd,p, nx,a);
564 3675 : lz = (a>nx)? ny+2: lg(x)+d;
565 3675 : x += 2; while (xd > x) *--zd = *--xd;
566 : }
567 3682 : while (yd > y) *--zd = *--yd;
568 3682 : *--zd = vs;
569 3682 : *--zd = evaltyp(t_VECSMALL) | evallg(lz); return zd;
570 : }
571 :
572 : /* shift polynomial + gerepile */
573 : /* Do not set evalvarn*/
574 : static GEN
575 440860598 : Flx_shiftip(pari_sp av, GEN x, long v)
576 : {
577 440860598 : long i, lx = lg(x), ly;
578 : GEN y;
579 440860598 : if (!v || lx==2) return gerepileuptoleaf(av, x);
580 104461674 : ly = lx + v; /* result length */
581 104461674 : (void)new_chunk(ly); /* check that result fits */
582 104604544 : x += lx; y = (GEN)av;
583 104604544 : for (i = 2; i<lx; i++) *--y = *--x;
584 104604544 : for (i = 0; i< v; i++) *--y = 0;
585 104604544 : y -= 2; y[0] = evaltyp(t_VECSMALL) | evallg(ly);
586 104525913 : avma = (pari_sp)y; return y;
587 : }
588 :
589 : #define BITS_IN_QUARTULONG (BITS_IN_HALFULONG >> 1)
590 : #define QUARTMASK ((1UL<<BITS_IN_QUARTULONG)-1UL)
591 : #define LLQUARTWORD(x) ((x) & QUARTMASK)
592 : #define HLQUARTWORD(x) (((x) >> BITS_IN_QUARTULONG) & QUARTMASK)
593 : #define LHQUARTWORD(x) (((x) >> (2*BITS_IN_QUARTULONG)) & QUARTMASK)
594 : #define HHQUARTWORD(x) (((x) >> (3*BITS_IN_QUARTULONG)) & QUARTMASK)
595 : INLINE long
596 484564784 : maxlengthcoeffpol(ulong p, long n)
597 : {
598 484564784 : pari_sp ltop = avma;
599 484564784 : GEN z = muliu(sqru(p-1), n);
600 484296882 : long l = lgefint(z);
601 484296882 : avma = ltop;
602 484296882 : if (l==3 && HIGHWORD(z[2])==0)
603 : {
604 135221027 : if (HLQUARTWORD(z[2]) == 0) return -1;
605 42276708 : else return 0;
606 : }
607 349075855 : return l-2;
608 : }
609 :
610 : INLINE ulong
611 774498994 : Flx_mullimb_ok(GEN x, GEN y, ulong p, long a, long b)
612 : { /* Assume OK_ULONG*/
613 774498994 : ulong p1 = 0;
614 : long i;
615 2525438872 : for (i=a; i<b; i++)
616 1750939878 : if (y[i])
617 : {
618 1587734764 : p1 += y[i] * x[-i];
619 1587734764 : if (p1 & HIGHBIT) p1 %= p;
620 : }
621 774498994 : return p1 % p;
622 : }
623 :
624 : INLINE ulong
625 739041730 : Flx_mullimb(GEN x, GEN y, ulong p, ulong pi, long a, long b)
626 : {
627 739041730 : ulong p1 = 0;
628 : long i;
629 2307213191 : for (i=a; i<b; i++)
630 1568226352 : if (y[i])
631 1534754188 : p1 = Fl_addmul_pre(p1, y[i], x[-i], p, pi);
632 738986839 : return p1;
633 : }
634 :
635 : /* assume nx >= ny > 0 */
636 : static GEN
637 185021174 : Flx_mulspec_basecase(GEN x, GEN y, ulong p, long nx, long ny)
638 : {
639 : long i,lz,nz;
640 : GEN z;
641 :
642 185021174 : lz = nx+ny+1; nz = lz-2;
643 185021174 : z = cgetg(lz, t_VECSMALL) + 2; /* x:y:z [i] = term of degree i */
644 184816999 : if (SMALL_ULONG(p))
645 : {
646 107514166 : for (i=0; i<ny; i++)z[i] = Flx_mullimb_ok(x+i,y,p,0,i+1);
647 107781550 : for ( ; i<nx; i++) z[i] = Flx_mullimb_ok(x+i,y,p,0,ny);
648 107829763 : for ( ; i<nz; i++) z[i] = Flx_mullimb_ok(x+i,y,p,i-nx+1,ny);
649 : }
650 : else
651 : {
652 77302833 : ulong pi = get_Fl_red(p);
653 77297377 : for (i=0; i<ny; i++)z[i] = Flx_mullimb(x+i,y,p,pi,0,i+1);
654 77328563 : for ( ; i<nx; i++) z[i] = Flx_mullimb(x+i,y,p,pi,0,ny);
655 77328390 : for ( ; i<nz; i++) z[i] = Flx_mullimb(x+i,y,p,pi,i-nx+1,ny);
656 : }
657 185141633 : z -= 2; return Flx_renormalize(z, lz);
658 : }
659 :
660 : static GEN
661 55929828 : int_to_Flx(GEN z, ulong p)
662 : {
663 55929828 : long i, l = lgefint(z);
664 55929828 : GEN x = cgetg(l, t_VECSMALL);
665 56005737 : for (i=2; i<l; i++) x[i] = uel(z,i)%p;
666 56005737 : return Flx_renormalize(x, l);
667 : }
668 :
669 : INLINE GEN
670 6005404 : Flx_mulspec_mulii(GEN a, GEN b, ulong p, long na, long nb)
671 : {
672 6005404 : GEN z=muliispec(a,b,na,nb);
673 6016676 : return int_to_Flx(z,p);
674 : }
675 :
676 : static GEN
677 30647085 : Flx_to_int_halfspec(GEN a, long na)
678 : {
679 : long j;
680 30647085 : long n = (na+1)>>1UL;
681 30647085 : GEN V = cgetipos(2+n);
682 : GEN w;
683 223917335 : for (w = int_LSW(V), j=0; j+1<na; j+=2, w=int_nextW(w))
684 193270409 : *w = a[j]|(a[j+1]<<BITS_IN_HALFULONG);
685 30646926 : if (j<na)
686 22521067 : *w = a[j];
687 30646926 : return V;
688 : }
689 :
690 : static GEN
691 23114666 : int_to_Flx_half(GEN z, ulong p)
692 : {
693 : long i;
694 23114666 : long lx = (lgefint(z)-2)*2+2;
695 23114666 : GEN w, x = cgetg(lx, t_VECSMALL);
696 267610785 : for (w = int_LSW(z), i=2; i<lx; i+=2, w=int_nextW(w))
697 : {
698 244496171 : x[i] = LOWWORD((ulong)*w)%p;
699 244496171 : x[i+1] = HIGHWORD((ulong)*w)%p;
700 : }
701 23114614 : return Flx_renormalize(x, lx);
702 : }
703 :
704 : static GEN
705 7559468 : Flx_mulspec_halfmulii(GEN a, GEN b, ulong p, long na, long nb)
706 : {
707 7559468 : GEN A = Flx_to_int_halfspec(a,na);
708 7559474 : GEN B = Flx_to_int_halfspec(b,nb);
709 7559469 : GEN z = mulii(A,B);
710 7559473 : return int_to_Flx_half(z,p);
711 : }
712 :
713 : static GEN
714 74712166 : Flx_to_int_quartspec(GEN a, long na)
715 : {
716 : long j;
717 74712166 : long n = (na+3)>>2UL;
718 74712166 : GEN V = cgetipos(2+n);
719 : GEN w;
720 242144036 : for (w = int_LSW(V), j=0; j+3<na; j+=4, w=int_nextW(w))
721 167433205 : *w = a[j]|(a[j+1]<<BITS_IN_QUARTULONG)|(a[j+2]<<(2*BITS_IN_QUARTULONG))|(a[j+3]<<(3*BITS_IN_QUARTULONG));
722 74710831 : switch (na-j)
723 : {
724 : case 3:
725 23800629 : *w = a[j]|(a[j+1]<<BITS_IN_QUARTULONG)|(a[j+2]<<(2*BITS_IN_QUARTULONG));
726 23800629 : break;
727 : case 2:
728 21992265 : *w = a[j]|(a[j+1]<<BITS_IN_QUARTULONG);
729 21992265 : break;
730 : case 1:
731 19622894 : *w = a[j];
732 19622894 : break;
733 : case 0:
734 9297765 : break;
735 : }
736 74710831 : return V;
737 : }
738 :
739 : static GEN
740 42658155 : int_to_Flx_quart(GEN z, ulong p)
741 : {
742 : long i;
743 42658155 : long lx = (lgefint(z)-2)*4+2;
744 42658155 : GEN w, x = cgetg(lx, t_VECSMALL);
745 268188259 : for (w = int_LSW(z), i=2; i<lx; i+=4, w=int_nextW(w))
746 : {
747 225529045 : x[i] = LLQUARTWORD((ulong)*w)%p;
748 225529045 : x[i+1] = HLQUARTWORD((ulong)*w)%p;
749 225529045 : x[i+2] = LHQUARTWORD((ulong)*w)%p;
750 225529045 : x[i+3] = HHQUARTWORD((ulong)*w)%p;
751 : }
752 42659214 : return Flx_renormalize(x, lx);
753 : }
754 :
755 : static GEN
756 32054489 : Flx_mulspec_quartmulii(GEN a, GEN b, ulong p, long na, long nb)
757 : {
758 32054489 : GEN A = Flx_to_int_quartspec(a,na);
759 32055381 : GEN B = Flx_to_int_quartspec(b,nb);
760 32054473 : GEN z = mulii(A,B);
761 32055115 : return int_to_Flx_quart(z,p);
762 : }
763 :
764 : /*Eval x in 2^(k*BIL) in linear time, k==2 or 3*/
765 : static GEN
766 39343008 : Flx_eval2BILspec(GEN x, long k, long l)
767 : {
768 39343008 : long i, lz = k*l, ki;
769 39343008 : GEN pz = cgetipos(2+lz);
770 847012087 : for (i=0; i < lz; i++)
771 807629100 : *int_W(pz,i) = 0UL;
772 441734375 : for (i=0, ki=0; i<l; i++, ki+=k)
773 402351388 : *int_W(pz,ki) = x[i];
774 39382987 : return int_normalize(pz,0);
775 : }
776 :
777 : static GEN
778 29176781 : Z_mod2BIL_Flx_2(GEN x, long d, ulong p)
779 : {
780 29176781 : long i, offset, lm = lgefint(x)-2, l = d+3;
781 29176781 : ulong pi = get_Fl_red(p);
782 29141513 : GEN pol = cgetg(l, t_VECSMALL);
783 29599314 : pol[1] = 0;
784 576796521 : for (i=0, offset=0; offset+1 < lm; i++, offset += 2)
785 547629527 : pol[i+2] = remll_pre(*int_W(x,offset+1), *int_W(x,offset), p, pi);
786 29166994 : if (offset < lm)
787 21108797 : pol[i+2] = (*int_W(x,offset)) % p;
788 29166994 : return Flx_renormalize(pol,l);
789 : }
790 :
791 : static GEN
792 14082 : Z_mod2BIL_Flx_3(GEN x, long d, ulong p)
793 : {
794 14082 : long i, offset, lm = lgefint(x)-2, l = d+3;
795 14082 : ulong pi = get_Fl_red(p);
796 14082 : GEN pol = cgetg(l, t_VECSMALL);
797 14092 : pol[1] = 0;
798 5608907 : for (i=0, offset=0; offset+2 < lm; i++, offset += 3)
799 11189650 : pol[i+2] = remlll_pre(*int_W(x,offset+2), *int_W(x,offset+1),
800 5594825 : *int_W(x,offset), p, pi);
801 14082 : if (offset+1 < lm)
802 10725 : pol[i+2] = remll_pre(*int_W(x,offset+1), *int_W(x,offset), p, pi);
803 3357 : else if (offset < lm)
804 3357 : pol[i+2] = (*int_W(x,offset)) % p;
805 14082 : return Flx_renormalize(pol,l);
806 : }
807 :
808 : static GEN
809 29200865 : Z_mod2BIL_Flx(GEN x, long bs, long d, ulong p)
810 : {
811 29200865 : return bs==2 ? Z_mod2BIL_Flx_2(x, d, p): Z_mod2BIL_Flx_3(x, d, p);
812 : }
813 :
814 : static GEN
815 10166163 : Flx_mulspec_mulii_inflate(GEN x, GEN y, long N, ulong p, long nx, long ny)
816 : {
817 10166163 : pari_sp av = avma;
818 10166163 : GEN z = mulii(Flx_eval2BILspec(x,N,nx), Flx_eval2BILspec(y,N,ny));
819 10171143 : return gerepileupto(av, Z_mod2BIL_Flx(z, N, nx+ny-2, p));
820 : }
821 :
822 : /* fast product (Karatsuba) of polynomials a,b. These are not real GENs, a+2,
823 : * b+2 were sent instead. na, nb = number of terms of a, b.
824 : * Only c, c0, c1, c2 are genuine GEN.
825 : */
826 : static GEN
827 249545491 : Flx_mulspec(GEN a, GEN b, ulong p, long na, long nb)
828 : {
829 : GEN a0,c,c0;
830 249545491 : long n0, n0a, i, v = 0;
831 : pari_sp av;
832 :
833 249545491 : while (na && !a[0]) { a++; na--; v++; }
834 249545491 : while (nb && !b[0]) { b++; nb--; v++; }
835 249545491 : if (na < nb) swapspec(a,b, na,nb);
836 249545491 : if (!nb) return pol0_Flx(0);
837 :
838 240845084 : av = avma;
839 240845084 : switch (maxlengthcoeffpol(p,nb))
840 : {
841 : case -1:
842 61340993 : if (na>=Flx_MUL_QUARTMULII_LIMIT)
843 32054073 : return Flx_shiftip(av,Flx_mulspec_quartmulii(a,b,p,na,nb), v);
844 29286920 : break;
845 : case 0:
846 16988786 : if (na>=Flx_MUL_HALFMULII_LIMIT)
847 7559464 : return Flx_shiftip(av,Flx_mulspec_halfmulii(a,b,p,na,nb), v);
848 9429322 : break;
849 : case 1:
850 76616699 : if (na>=Flx_MUL_MULII_LIMIT)
851 6005229 : return Flx_shiftip(av,Flx_mulspec_mulii(a,b,p,na,nb), v);
852 70611470 : break;
853 : case 2:
854 83292757 : if (na>=Flx_MUL_MULII2_LIMIT)
855 10154814 : return Flx_shiftip(av,Flx_mulspec_mulii_inflate(a,b,2,p,na,nb), v);
856 73137943 : break;
857 : case 3:
858 2594008 : if (na>70)
859 11859 : return Flx_shiftip(av,Flx_mulspec_mulii_inflate(a,b,3,p,na,nb), v);
860 2582149 : break;
861 : }
862 185033796 : if (nb < Flx_MUL_KARATSUBA_LIMIT)
863 185032195 : return Flx_shiftip(av,Flx_mulspec_basecase(a,b,p,na,nb), v);
864 1601 : i=(na>>1); n0=na-i; na=i;
865 1601 : a0=a+n0; n0a=n0;
866 1601 : while (n0a && !a[n0a-1]) n0a--;
867 :
868 1601 : if (nb > n0)
869 : {
870 : GEN b0,c1,c2;
871 : long n0b;
872 :
873 1601 : nb -= n0; b0 = b+n0; n0b = n0;
874 1601 : while (n0b && !b[n0b-1]) n0b--;
875 1601 : c = Flx_mulspec(a,b,p,n0a,n0b);
876 1601 : c0 = Flx_mulspec(a0,b0,p,na,nb);
877 :
878 1601 : c2 = Flx_addspec(a0,a,p,na,n0a);
879 1601 : c1 = Flx_addspec(b0,b,p,nb,n0b);
880 :
881 1601 : c1 = Flx_mul(c1,c2,p);
882 1601 : c2 = Flx_add(c0,c,p);
883 :
884 1601 : c2 = Flx_neg_inplace(c2,p);
885 1601 : c2 = Flx_add(c1,c2,p);
886 1601 : c0 = Flx_addshift(c0,c2 ,p, n0);
887 : }
888 : else
889 : {
890 0 : c = Flx_mulspec(a,b,p,n0a,nb);
891 0 : c0 = Flx_mulspec(a0,b,p,na,nb);
892 : }
893 1601 : c0 = Flx_addshift(c0,c,p,n0);
894 1601 : return Flx_shiftip(av,c0, v);
895 : }
896 :
897 :
898 : GEN
899 245943493 : Flx_mul(GEN x, GEN y, ulong p)
900 : {
901 245943493 : GEN z = Flx_mulspec(x+2,y+2,p, lgpol(x),lgpol(y));
902 246003691 : z[1] = x[1]; return z;
903 : }
904 :
905 : static GEN
906 106544959 : Flx_sqrspec_basecase(GEN x, ulong p, long nx)
907 : {
908 : long i, lz, nz;
909 : ulong p1;
910 : GEN z;
911 :
912 106544959 : if (!nx) return pol0_Flx(0);
913 106544959 : lz = (nx << 1) + 1, nz = lz-2;
914 106544959 : z = cgetg(lz, t_VECSMALL) + 2;
915 106382992 : if (SMALL_ULONG(p))
916 : {
917 60310672 : z[0] = x[0]*x[0]%p;
918 141002082 : for (i=1; i<nx; i++)
919 : {
920 80384231 : p1 = Flx_mullimb_ok(x+i,x,p,0, (i+1)>>1);
921 80691410 : p1 <<= 1;
922 80691410 : if ((i&1) == 0) p1 += x[i>>1] * x[i>>1];
923 80691410 : z[i] = p1 % p;
924 : }
925 141643366 : for ( ; i<nz; i++)
926 : {
927 80989528 : p1 = Flx_mullimb_ok(x+i,x,p,i-nx+1, (i+1)>>1);
928 81025515 : p1 <<= 1;
929 81025515 : if ((i&1) == 0) p1 += x[i>>1] * x[i>>1];
930 81025515 : z[i] = p1 % p;
931 : }
932 : }
933 : else
934 : {
935 46072320 : ulong pi = get_Fl_red(p);
936 46068626 : z[0] = Fl_sqr_pre(x[0], p, pi);
937 218210388 : for (i=1; i<nx; i++)
938 : {
939 172118518 : p1 = Flx_mullimb(x+i,x,p,pi,0, (i+1)>>1);
940 172118024 : p1 = Fl_add(p1, p1, p);
941 172068098 : if ((i&1) == 0) p1 = Fl_add(p1, Fl_sqr_pre(x[i>>1], p, pi), p);
942 172144502 : z[i] = p1;
943 : }
944 218236792 : for ( ; i<nz; i++)
945 : {
946 172151415 : p1 = Flx_mullimb(x+i,x,p,pi,i-nx+1, (i+1)>>1);
947 172192607 : p1 = Fl_add(p1, p1, p);
948 172171541 : if ((i&1) == 0) p1 = Fl_add(p1, Fl_sqr_pre(x[i>>1], p, pi), p);
949 172144922 : z[i] = p1;
950 : }
951 : }
952 106739215 : z -= 2; return Flx_renormalize(z, lz);
953 : }
954 :
955 : static GEN
956 49662632 : Flx_sqrspec_sqri(GEN a, ulong p, long na)
957 : {
958 49662632 : GEN z=sqrispec(a,na);
959 50005306 : return int_to_Flx(z,p);
960 : }
961 :
962 : static GEN
963 15365842 : Flx_sqrspec_halfsqri(GEN a, ulong p, long na)
964 : {
965 15365842 : GEN z = sqri(Flx_to_int_halfspec(a,na));
966 15365858 : return int_to_Flx_half(z,p);
967 : }
968 :
969 : static GEN
970 10603121 : Flx_sqrspec_quartsqri(GEN a, ulong p, long na)
971 : {
972 10603121 : GEN z = sqri(Flx_to_int_quartspec(a,na));
973 10603163 : return int_to_Flx_quart(z,p);
974 : }
975 :
976 : static GEN
977 19023455 : Flx_sqrspec_sqri_inflate(GEN x, long N, ulong p, long nx)
978 : {
979 19023455 : pari_sp av = avma;
980 19023455 : GEN z = sqri(Flx_eval2BILspec(x,N,nx));
981 19041538 : return gerepileupto(av, Z_mod2BIL_Flx(z, N, (nx-1)*2, p));
982 : }
983 :
984 : static GEN
985 201275610 : Flx_sqrspec(GEN a, ulong p, long na)
986 : {
987 : GEN a0, c, c0;
988 201275610 : long n0, n0a, i, v = 0;
989 : pari_sp av;
990 :
991 201275610 : while (na && !a[0]) { a++; na--; v += 2; }
992 201275610 : if (!na) return pol0_Flx(0);
993 :
994 201214086 : av = avma;
995 201214086 : switch(maxlengthcoeffpol(p,na))
996 : {
997 : case -1:
998 20243761 : if (na>=Flx_SQR_QUARTSQRI_LIMIT)
999 10603137 : return Flx_shiftip(av, Flx_sqrspec_quartsqri(a,p,na), v);
1000 9640624 : break;
1001 : case 0:
1002 21125580 : if (na>=Flx_SQR_HALFSQRI_LIMIT)
1003 15365845 : return Flx_shiftip(av, Flx_sqrspec_halfsqri(a,p,na), v);
1004 5759735 : break;
1005 : case 1:
1006 93293528 : if (na>=Flx_SQR_SQRI_LIMIT)
1007 49676085 : return Flx_shiftip(av, Flx_sqrspec_sqri(a,p,na), v);
1008 43617443 : break;
1009 : case 2:
1010 65369326 : if (na>=Flx_SQR_SQRI2_LIMIT)
1011 19020876 : return Flx_shiftip(av, Flx_sqrspec_sqri_inflate(a,2,p,na), v);
1012 46348450 : break;
1013 : case 3:
1014 1212418 : if (na>70)
1015 2223 : return Flx_shiftip(av, Flx_sqrspec_sqri_inflate(a,3,p,na), v);
1016 1210195 : break;
1017 : }
1018 106562010 : if (na < Flx_SQR_KARATSUBA_LIMIT)
1019 106561770 : return Flx_shiftip(av, Flx_sqrspec_basecase(a,p,na), v);
1020 240 : i=(na>>1); n0=na-i; na=i;
1021 240 : a0=a+n0; n0a=n0;
1022 240 : while (n0a && !a[n0a-1]) n0a--;
1023 :
1024 240 : c = Flx_sqrspec(a,p,n0a);
1025 240 : c0= Flx_sqrspec(a0,p,na);
1026 240 : if (p == 2) n0 *= 2;
1027 : else
1028 : {
1029 240 : GEN c1, t = Flx_addspec(a0,a,p,na,n0a);
1030 240 : t = Flx_sqr(t,p);
1031 240 : c1= Flx_add(c0,c, p);
1032 240 : c1= Flx_sub(t, c1, p);
1033 240 : c0 = Flx_addshift(c0,c1,p,n0);
1034 : }
1035 240 : c0 = Flx_addshift(c0,c,p,n0);
1036 240 : return Flx_shiftip(av,c0,v);
1037 : }
1038 :
1039 : GEN
1040 201151515 : Flx_sqr(GEN x, ulong p)
1041 : {
1042 201151515 : GEN z = Flx_sqrspec(x+2,p, lgpol(x));
1043 201487324 : z[1] = x[1]; return z;
1044 : }
1045 :
1046 : GEN
1047 9306 : Flx_powu(GEN x, ulong n, ulong p)
1048 : {
1049 9306 : GEN y = pol1_Flx(x[1]), z;
1050 : ulong m;
1051 9297 : if (n == 0) return y;
1052 9297 : m = n; z = x;
1053 : for (;;)
1054 : {
1055 35132 : if (m&1UL) y = Flx_mul(y,z, p);
1056 35140 : m >>= 1; if (!m) return y;
1057 25836 : z = Flx_sqr(z, p);
1058 25835 : }
1059 : }
1060 :
1061 : GEN
1062 12686 : Flx_halve(GEN y, ulong p)
1063 : {
1064 : GEN z;
1065 : long i, l;
1066 12686 : z = cgetg_copy(y, &l); z[1] = y[1];
1067 12686 : for(i=2; i<l; i++) uel(z,i) = Fl_halve(uel(y,i), p);
1068 12686 : return z;
1069 : }
1070 :
1071 : static GEN
1072 3655409 : Flx_recipspec(GEN x, long l, long n)
1073 : {
1074 : long i;
1075 3655409 : GEN z=cgetg(n+2,t_VECSMALL)+2;
1076 153731055 : for(i=0; i<l; i++)
1077 150075585 : z[n-i-1] = x[i];
1078 4444346 : for( ; i<n; i++)
1079 788876 : z[n-i-1] = 0;
1080 3655470 : return Flx_renormalize(z-2,n+2);
1081 : }
1082 :
1083 : GEN
1084 0 : Flx_recip(GEN x)
1085 : {
1086 0 : GEN z=Flx_recipspec(x+2,lgpol(x),lgpol(x));
1087 0 : z[1]=x[1];
1088 0 : return z;
1089 : }
1090 :
1091 : /* Return h^degpol(P) P(x / h) */
1092 : GEN
1093 580 : Flx_rescale(GEN P, ulong h, ulong p)
1094 : {
1095 580 : long i, l = lg(P);
1096 580 : GEN Q = cgetg(l,t_VECSMALL);
1097 580 : ulong hi = h;
1098 580 : Q[l-1] = P[l-1];
1099 4361 : for (i=l-2; i>=2; i--)
1100 : {
1101 4361 : Q[i] = Fl_mul(P[i], hi, p);
1102 4361 : if (i == 2) break;
1103 3781 : hi = Fl_mul(hi,h, p);
1104 : }
1105 580 : Q[1] = P[1]; return Q;
1106 : }
1107 :
1108 : static long
1109 43193731 : Flx_multhreshold(GEN T, ulong p, long quart, long half, long mul, long mul2, long kara)
1110 : {
1111 43193731 : long na = lgpol(T);
1112 43193364 : switch (maxlengthcoeffpol(p,na))
1113 : {
1114 : case -1:
1115 11368095 : if (na>=Flx_MUL_QUARTMULII_LIMIT)
1116 5947350 : return na>=quart;
1117 5420745 : break;
1118 : case 0:
1119 4163075 : if (na>=Flx_MUL_HALFMULII_LIMIT)
1120 2499711 : return na>=half;
1121 1663364 : break;
1122 : case 1:
1123 15761634 : if (na>=Flx_MUL_MULII_LIMIT)
1124 6195547 : return na>=mul;
1125 9566087 : break;
1126 : case 2:
1127 10734305 : if (na>=Flx_MUL_MULII2_LIMIT)
1128 974297 : return na>=mul2;
1129 9760008 : break;
1130 : case 3:
1131 1166062 : if (na>=70)
1132 1348 : return na>=70;
1133 1164714 : break;
1134 : }
1135 27574842 : return na>=kara;
1136 : }
1137 :
1138 : /*
1139 : * x/polrecip(P)+O(x^n)
1140 : */
1141 : static GEN
1142 73120 : Flx_invBarrett_basecase(GEN T, ulong p)
1143 : {
1144 73120 : long i, l=lg(T)-1, lr=l-1, k;
1145 73120 : GEN r=cgetg(lr,t_VECSMALL); r[1] = T[1];
1146 73120 : r[2] = 1;
1147 73120 : if (SMALL_ULONG(p))
1148 3061087 : for (i=3;i<lr;i++)
1149 : {
1150 2990483 : ulong u = uel(T, l-i+2);
1151 83184855 : for (k=3; k<i; k++)
1152 80194372 : { u += uel(T,l-i+k) * uel(r, k); if (u & HIGHBIT) u %= p; }
1153 2990483 : r[i] = Fl_neg(u % p, p);
1154 : }
1155 : else
1156 49915 : for (i=3;i<lr;i++)
1157 : {
1158 47397 : ulong u = Fl_neg(uel(T,l-i+2), p);
1159 508044 : for (k=3; k<i; k++)
1160 460645 : u = Fl_sub(u, Fl_mul(uel(T,l-i+k), uel(r,k), p), p);
1161 47399 : r[i] = u;
1162 : }
1163 73122 : return Flx_renormalize(r,lr);
1164 : }
1165 :
1166 : /* Return new lgpol */
1167 : static long
1168 3536110 : Flx_lgrenormalizespec(GEN x, long lx)
1169 : {
1170 : long i;
1171 10022456 : for (i = lx-1; i>=0; i--)
1172 10022435 : if (x[i]) break;
1173 3536110 : return i+1;
1174 : }
1175 : static GEN
1176 4337 : Flx_invBarrett_Newton(GEN T, ulong p)
1177 : {
1178 4337 : long nold, lx, lz, lq, l = degpol(T), lQ;
1179 4337 : GEN q, y, z, x = zero_zv(l+1) + 2;
1180 4338 : ulong mask = quadratic_prec_mask(l-2); /* assume l > 2 */
1181 : pari_sp av;
1182 :
1183 4338 : y = T+2;
1184 4338 : q = Flx_recipspec(y,l+1,l+1); lQ = lgpol(q); q+=2;
1185 4338 : av = avma;
1186 : /* We work on _spec_ Flx's, all the l[xzq12] below are lgpol's */
1187 :
1188 : /* initialize */
1189 4338 : x[0] = Fl_inv(q[0], p);
1190 4339 : if (lQ>1 && q[1])
1191 2042 : {
1192 2043 : ulong u = q[1];
1193 2043 : if (x[0] != 1) u = Fl_mul(u, Fl_sqr(x[0],p), p);
1194 2042 : x[1] = p - u; lx = 2;
1195 : }
1196 : else
1197 2296 : lx = 1;
1198 4338 : nold = 1;
1199 31995 : for (; mask > 1; avma = av)
1200 : { /* set x -= x(x*q - 1) + O(t^(nnew + 1)), knowing x*q = 1 + O(t^(nold+1)) */
1201 27656 : long i, lnew, nnew = nold << 1;
1202 :
1203 27656 : if (mask & 1) nnew--;
1204 27656 : mask >>= 1;
1205 :
1206 27656 : lnew = nnew + 1;
1207 27656 : lq = Flx_lgrenormalizespec(q, minss(lQ, lnew));
1208 27655 : z = Flx_mulspec(x, q, p, lx, lq); /* FIXME: high product */
1209 27652 : lz = lgpol(z); if (lz > lnew) lz = lnew;
1210 27671 : z += 2;
1211 : /* subtract 1 [=>first nold words are 0]: renormalize so that z(0) != 0 */
1212 27671 : for (i = nold; i < lz; i++) if (z[i]) break;
1213 27671 : nold = nnew;
1214 27671 : if (i >= lz) continue; /* z-1 = 0(t^(nnew + 1)) */
1215 :
1216 : /* z + i represents (x*q - 1) / t^i */
1217 19289 : lz = Flx_lgrenormalizespec (z+i, lz-i);
1218 19291 : z = Flx_mulspec(x, z+i, p, lx, lz); /* FIXME: low product */
1219 19289 : lz = lgpol(z); z += 2;
1220 19289 : if (lz > lnew-i) lz = Flx_lgrenormalizespec(z, lnew-i);
1221 :
1222 19288 : lx = lz+ i;
1223 19288 : y = x + i; /* x -= z * t^i, in place */
1224 19288 : for (i = 0; i < lz; i++) y[i] = Fl_neg(z[i], p);
1225 : }
1226 4339 : x -= 2; setlg(x, lx + 2); x[1] = T[1];
1227 4339 : return x;
1228 : }
1229 :
1230 : /* x/polrecip(T)+O(x^deg(T)) */
1231 : GEN
1232 77459 : Flx_invBarrett(GEN T, ulong p)
1233 : {
1234 77459 : pari_sp ltop=avma;
1235 77459 : long l=lg(T);
1236 : GEN r;
1237 77459 : if (l<5) return pol0_Flx(T[1]);
1238 77457 : if (!Flx_multhreshold(T,p, Flx_INVBARRETT_QUARTMULII_LIMIT,
1239 : Flx_INVBARRETT_HALFMULII_LIMIT,
1240 : Flx_INVBARRETT_MULII_LIMIT,
1241 : Flx_INVBARRETT_MULII2_LIMIT,
1242 : Flx_INVBARRETT_KARATSUBA_LIMIT))
1243 : {
1244 73121 : ulong c = T[l-1];
1245 73121 : if (c!=1)
1246 : {
1247 550 : ulong ci = Fl_inv(c,p);
1248 550 : T=Flx_Fl_mul(T, ci, p);
1249 550 : r=Flx_invBarrett_basecase(T,p);
1250 550 : r=Flx_Fl_mul(r,ci,p);
1251 : }
1252 : else
1253 72571 : r=Flx_invBarrett_basecase(T,p);
1254 : }
1255 : else
1256 4338 : r = Flx_invBarrett_Newton(T,p);
1257 77460 : return gerepileuptoleaf(ltop, r);
1258 : }
1259 :
1260 : GEN
1261 43309003 : Flx_get_red(GEN T, ulong p)
1262 : {
1263 43309003 : if (typ(T)!=t_VECSMALL || !Flx_multhreshold(T,p,
1264 : Flx_BARRETT_QUARTMULII_LIMIT,
1265 : Flx_BARRETT_HALFMULII_LIMIT,
1266 : Flx_BARRETT_MULII_LIMIT,
1267 : Flx_BARRETT_MULII2_LIMIT,
1268 : Flx_BARRETT_KARATSUBA_LIMIT))
1269 43231253 : return T;
1270 76540 : retmkvec2(Flx_invBarrett(T,p),T);
1271 : }
1272 :
1273 : /* separate from Flx_divrem for maximal speed. */
1274 : static GEN
1275 463541397 : Flx_rem_basecase(GEN x, GEN y, ulong p)
1276 : {
1277 : pari_sp av;
1278 : GEN z, c;
1279 : long dx,dy,dy1,dz,i,j;
1280 : ulong p1,inv;
1281 463541397 : long vs=x[1];
1282 :
1283 463541397 : dy = degpol(y); if (!dy) return pol0_Flx(x[1]);
1284 456105283 : dx = degpol(x);
1285 456034809 : dz = dx-dy; if (dz < 0) return Flx_copy(x);
1286 456034809 : x += 2; y += 2;
1287 456034809 : inv = y[dy];
1288 456034809 : if (inv != 1UL) inv = Fl_inv(inv,p);
1289 456522541 : for (dy1=dy-1; dy1>=0 && !y[dy1]; dy1--);
1290 :
1291 456522541 : c = cgetg(dy+3, t_VECSMALL); c[1]=vs; c += 2; av=avma;
1292 455275990 : z = cgetg(dz+3, t_VECSMALL); z[1]=vs; z += 2;
1293 :
1294 458435466 : if (SMALL_ULONG(p))
1295 : {
1296 283144170 : z[dz] = (inv*x[dx]) % p;
1297 1093397329 : for (i=dx-1; i>=dy; --i)
1298 : {
1299 810253159 : p1 = p - x[i]; /* compute -p1 instead of p1 (pb with ulongs otherwise) */
1300 4518185483 : for (j=i-dy1; j<=i && j<=dz; j++)
1301 : {
1302 3707932324 : p1 += z[j]*y[i-j];
1303 3707932324 : if (p1 & HIGHBIT) p1 %= p;
1304 : }
1305 810253159 : p1 %= p;
1306 810253159 : z[i-dy] = p1? ((p - p1)*inv) % p: 0;
1307 : }
1308 1920602085 : for (i=0; i<dy; i++)
1309 : {
1310 1639203745 : p1 = z[0]*y[i];
1311 6457661466 : for (j=maxss(1,i-dy1); j<=i && j<=dz; j++)
1312 : {
1313 4818457721 : p1 += z[j]*y[i-j];
1314 4818457721 : if (p1 & HIGHBIT) p1 %= p;
1315 : }
1316 1635535250 : c[i] = Fl_sub(x[i], p1%p, p);
1317 : }
1318 : }
1319 : else
1320 : {
1321 175291296 : ulong pi = get_Fl_red(p);
1322 175290139 : z[dz] = Fl_mul_pre(inv, x[dx], p, pi);
1323 580075187 : for (i=dx-1; i>=dy; --i)
1324 : {
1325 404709460 : p1 = p - x[i]; /* compute -p1 instead of p1 (pb with ulongs otherwise) */
1326 1713437242 : for (j=i-dy1; j<=i && j<=dz; j++)
1327 1308663408 : p1 = Fl_addmul_pre(p1, z[j], y[i - j], p, pi);
1328 404773834 : z[i-dy] = p1? Fl_mul_pre(p - p1, inv, p, pi): 0;
1329 : }
1330 1231677291 : for (i=0; i<dy; i++)
1331 : {
1332 1057150211 : p1 = Fl_mul_pre(z[0],y[i],p,pi);
1333 3046075895 : for (j=maxss(1,i-dy1); j<=i && j<=dz; j++)
1334 1983039917 : p1 = Fl_addmul_pre(p1, z[j], y[i - j], p, pi);
1335 1047187490 : c[i] = Fl_sub(x[i], p1, p);
1336 : }
1337 : }
1338 455925420 : i = dy-1; while (i>=0 && !c[i]) i--;
1339 455925420 : avma=av;
1340 455925420 : return Flx_renormalize(c-2, i+3);
1341 : }
1342 :
1343 : /* as FpX_divrem but working only on ulong types.
1344 : * if relevant, *pr is the last object on stack */
1345 : static GEN
1346 22873171 : Flx_divrem_basecase(GEN x, GEN y, ulong p, GEN *pr)
1347 : {
1348 : GEN z,q,c;
1349 : long dx,dy,dy1,dz,i,j;
1350 : ulong p1,inv;
1351 22873171 : long sv=x[1];
1352 :
1353 22873171 : dy = degpol(y);
1354 22873135 : if (dy<0) pari_err_INV("Flx_divrem",y);
1355 22873358 : if (pr == ONLY_REM) return Flx_rem_basecase(x, y, p);
1356 22873356 : if (!dy)
1357 : {
1358 4589011 : if (pr && pr != ONLY_DIVIDES) *pr = pol0_Flx(sv);
1359 4589011 : if (y[2] == 1UL) return Flx_copy(x);
1360 2930041 : return Flx_Fl_mul(x, Fl_inv(y[2], p), p);
1361 : }
1362 18284345 : dx = degpol(x);
1363 18284338 : dz = dx-dy;
1364 18284338 : if (dz < 0)
1365 : {
1366 86942 : q = pol0_Flx(sv);
1367 86942 : if (pr && pr != ONLY_DIVIDES) *pr = Flx_copy(x);
1368 86942 : return q;
1369 : }
1370 18197396 : x += 2;
1371 18197396 : y += 2;
1372 18197396 : z = cgetg(dz + 3, t_VECSMALL); z[1] = sv; z += 2;
1373 18197313 : inv = uel(y, dy);
1374 18197313 : if (inv != 1UL) inv = Fl_inv(inv,p);
1375 18197382 : for (dy1=dy-1; dy1>=0 && !y[dy1]; dy1--);
1376 :
1377 18197382 : if (SMALL_ULONG(p))
1378 : {
1379 17309345 : z[dz] = (inv*x[dx]) % p;
1380 48203887 : for (i=dx-1; i>=dy; --i)
1381 : {
1382 30894542 : p1 = p - x[i]; /* compute -p1 instead of p1 (pb with ulongs otherwise) */
1383 163509622 : for (j=i-dy1; j<=i && j<=dz; j++)
1384 : {
1385 132615080 : p1 += z[j]*y[i-j];
1386 132615080 : if (p1 & HIGHBIT) p1 %= p;
1387 : }
1388 30894542 : p1 %= p;
1389 30894542 : z[i-dy] = p1? (long) ((p - p1)*inv) % p: 0;
1390 : }
1391 : }
1392 : else
1393 : {
1394 888037 : z[dz] = Fl_mul(inv, x[dx], p);
1395 7267683 : for (i=dx-1; i>=dy; --i)
1396 : { /* compute -p1 instead of p1 (pb with ulongs otherwise) */
1397 6379646 : p1 = p - uel(x,i);
1398 36143191 : for (j=i-dy1; j<=i && j<=dz; j++)
1399 29763545 : p1 = Fl_add(p1, Fl_mul(z[j],y[i-j],p), p);
1400 6379646 : z[i-dy] = p1? Fl_mul(p - p1, inv, p): 0;
1401 : }
1402 : }
1403 18197382 : q = Flx_renormalize(z-2, dz+3);
1404 18197366 : if (!pr) return q;
1405 :
1406 14763748 : c = cgetg(dy + 3, t_VECSMALL); c[1] = sv; c += 2;
1407 14763748 : if (SMALL_ULONG(p))
1408 : {
1409 146899931 : for (i=0; i<dy; i++)
1410 : {
1411 132970442 : p1 = (ulong)z[0]*y[i];
1412 303497150 : for (j=maxss(1,i-dy1); j<=i && j<=dz; j++)
1413 : {
1414 170526708 : p1 += (ulong)z[j]*y[i-j];
1415 170526708 : if (p1 & HIGHBIT) p1 %= p;
1416 : }
1417 132970442 : c[i] = Fl_sub(x[i], p1%p, p);
1418 : }
1419 : }
1420 : else
1421 : {
1422 9715585 : for (i=0; i<dy; i++)
1423 : {
1424 8881326 : p1 = Fl_mul(z[0],y[i],p);
1425 54628836 : for (j=maxss(1,i-dy1); j<=i && j<=dz; j++)
1426 45747510 : p1 = Fl_add(p1, Fl_mul(z[j],y[i-j],p), p);
1427 8881326 : c[i] = Fl_sub(x[i], p1, p);
1428 : }
1429 : }
1430 14763748 : i=dy-1; while (i>=0 && !c[i]) i--;
1431 14763748 : c = Flx_renormalize(c-2, i+3);
1432 14763748 : if (pr == ONLY_DIVIDES)
1433 259 : { if (lg(c) != 2) return NULL; }
1434 : else
1435 14763489 : *pr = c;
1436 14763692 : return q;
1437 : }
1438 :
1439 :
1440 : /* Compute x mod T where 2 <= degpol(T) <= l+1 <= 2*(degpol(T)-1)
1441 : * and mg is the Barrett inverse of T. */
1442 : static GEN
1443 1735753 : Flx_divrem_Barrettspec(GEN x, long l, GEN mg, GEN T, ulong p, GEN *pr)
1444 : {
1445 : GEN q, r;
1446 1735753 : long lt = degpol(T); /*We discard the leading term*/
1447 : long ld, lm, lT, lmg;
1448 1735754 : ld = l-lt;
1449 1735754 : lm = minss(ld, lgpol(mg));
1450 1735744 : lT = Flx_lgrenormalizespec(T+2,lt);
1451 1735738 : lmg = Flx_lgrenormalizespec(mg+2,lm);
1452 1735737 : q = Flx_recipspec(x+lt,ld,ld); /* q = rec(x) lz<=ld*/
1453 1735733 : q = Flx_mulspec(q+2,mg+2,p,lgpol(q),lmg); /* q = rec(x) * mg lz<=ld+lm*/
1454 1735748 : q = Flx_recipspec(q+2,minss(ld,lgpol(q)),ld);/* q = rec (rec(x) * mg) lz<=ld*/
1455 1735737 : if (!pr) return q;
1456 1735737 : r = Flx_mulspec(q+2,T+2,p,lgpol(q),lT); /* r = q*pol lz<=ld+lt*/
1457 1735754 : r = Flx_subspec(x,r+2,p,lt,minss(lt,lgpol(r)));/* r = x - q*pol lz<=lt */
1458 1735729 : if (pr == ONLY_REM) return r;
1459 5469 : *pr = r; return q;
1460 : }
1461 :
1462 : static GEN
1463 1730325 : Flx_divrem_Barrett_noGC(GEN x, GEN mg, GEN T, ulong p, GEN *pr)
1464 : {
1465 1730325 : long l = lgpol(x), lt = degpol(T), lm = 2*lt-1;
1466 1730327 : GEN q = NULL, r;
1467 : long i;
1468 1730327 : if (l <= lt)
1469 : {
1470 0 : if (pr == ONLY_REM) return Flx_copy(x);
1471 0 : if (pr == ONLY_DIVIDES) return lgpol(x)? NULL: pol0_Flx(x[1]);
1472 0 : if (pr) *pr = Flx_copy(x);
1473 0 : return pol0_Flx(x[1]);
1474 : }
1475 1730327 : if (lt <= 1)
1476 2 : return Flx_divrem_basecase(x,T,p,pr);
1477 1730325 : if (pr != ONLY_REM && l>lm)
1478 0 : q = zero_zv(l-lt+1);
1479 1730325 : r = Flx_copy(x);
1480 3466105 : while (l>lm)
1481 : {
1482 5421 : GEN zr, zq = Flx_divrem_Barrettspec(r+2+l-lm,lm,mg,T,p,&zr);
1483 5421 : long lz = lgpol(zr);
1484 5421 : if (pr != ONLY_REM)
1485 : {
1486 0 : long lq = lgpol(zq);
1487 0 : for(i=0; i<lq; i++) q[2+l-lm+i] = zq[2+i];
1488 : }
1489 5421 : for(i=0; i<lz; i++) r[2+l-lm+i] = zr[2+i];
1490 5421 : l = l-lm+lz;
1491 : }
1492 1730342 : if (pr != ONLY_REM)
1493 : {
1494 48 : if (l > lt)
1495 : {
1496 48 : GEN zq = Flx_divrem_Barrettspec(r+2,l,mg,T,p,&r);
1497 48 : if (!q) q = zq;
1498 : else
1499 : {
1500 0 : long lq = lgpol(zq);
1501 0 : for(i=0; i<lq; i++) q[2+i] = zq[2+i];
1502 : }
1503 : }
1504 : else
1505 0 : r = Flx_renormalize(r, l+2);
1506 : }
1507 : else
1508 : {
1509 1730294 : if (l > lt)
1510 1730287 : r = Flx_divrem_Barrettspec(r+2,l,mg,T,p,ONLY_REM);
1511 : else
1512 7 : r = Flx_renormalize(r, l+2);
1513 1730265 : r[1] = x[1]; return Flx_renormalize(r, lg(r));
1514 : }
1515 48 : if (pr) { r[1] = x[1]; r = Flx_renormalize(r, lg(r)); }
1516 48 : q[1] = x[1]; q = Flx_renormalize(q, lg(q));
1517 48 : if (pr == ONLY_DIVIDES) return lgpol(r)? NULL: q;
1518 48 : if (pr) *pr = r;
1519 48 : return q;
1520 : }
1521 :
1522 : GEN
1523 60076898 : Flx_divrem(GEN x, GEN T, ulong p, GEN *pr)
1524 : {
1525 60076898 : GEN B, y = get_Flx_red(T, &B);
1526 60076915 : long dy = degpol(y), dx = degpol(x), d = dx-dy;
1527 60076777 : if (pr==ONLY_REM) return Flx_rem(x, y, p);
1528 22873151 : if (!B && d+3 < Flx_DIVREM_BARRETT_LIMIT)
1529 22873103 : return Flx_divrem_basecase(x,y,p,pr);
1530 : else
1531 : {
1532 48 : pari_sp av=avma;
1533 48 : GEN mg = B? B: Flx_invBarrett(y, p);
1534 48 : GEN q1 = Flx_divrem_Barrett_noGC(x,mg,y,p,pr);
1535 48 : if (!q1) {avma=av; return NULL;}
1536 48 : if (!pr || pr==ONLY_DIVIDES) return gerepileuptoleaf(av, q1);
1537 21 : gerepileall(av,2,&q1,pr);
1538 21 : return q1;
1539 : }
1540 : }
1541 :
1542 : GEN
1543 522918485 : Flx_rem(GEN x, GEN T, ulong p)
1544 : {
1545 522918485 : GEN B, y = get_Flx_red(T, &B);
1546 522896453 : long dy = degpol(y), dx = degpol(x), d = dx-dy;
1547 522504434 : if (d < 0) return Flx_copy(x);
1548 465267539 : if (!B && d+3 < Flx_REM_BARRETT_LIMIT)
1549 463537261 : return Flx_rem_basecase(x,y,p);
1550 : else
1551 : {
1552 1730278 : pari_sp av=avma;
1553 1730278 : GEN mg = B ? B: Flx_invBarrett(y, p);
1554 1730278 : GEN r = Flx_divrem_Barrett_noGC(x, mg, y, p, ONLY_REM);
1555 1730245 : return gerepileuptoleaf(av, r);
1556 : }
1557 : }
1558 :
1559 : /* reduce T mod (X^n - 1, p). Shallow function */
1560 : GEN
1561 4992949 : Flx_mod_Xnm1(GEN T, ulong n, ulong p)
1562 : {
1563 4992949 : long i, j, L = lg(T), l = n+2;
1564 : GEN S;
1565 4992949 : if (L <= l || n & ~LGBITS) return T;
1566 61 : S = cgetg(l, t_VECSMALL);
1567 61 : S[1] = T[1];
1568 61 : for (i = 2; i < l; i++) S[i] = T[i];
1569 181 : for (j = 2; i < L; i++) {
1570 120 : S[j] = Fl_add(S[j], T[i], p);
1571 120 : if (++j == l) j = 2;
1572 : }
1573 61 : return Flx_renormalize(S, l);
1574 : }
1575 : /* reduce T mod (X^n + 1, p). Shallow function */
1576 : GEN
1577 12 : Flx_mod_Xn1(GEN T, ulong n, ulong p)
1578 : {
1579 12 : long i, j, L = lg(T), l = n+2;
1580 : GEN S;
1581 12 : if (L <= l || n & ~LGBITS) return T;
1582 12 : S = cgetg(l, t_VECSMALL);
1583 12 : S[1] = T[1];
1584 12 : for (i = 2; i < l; i++) S[i] = T[i];
1585 48 : for (j = 2; i < L; i++) {
1586 36 : S[j] = Fl_sub(S[j], T[i], p);
1587 36 : if (++j == l) j = 2;
1588 : }
1589 12 : return Flx_renormalize(S, l);
1590 : }
1591 :
1592 : struct _Flxq {
1593 : GEN aut;
1594 : GEN T;
1595 : ulong p;
1596 : };
1597 :
1598 : static GEN
1599 0 : _Flx_divrem(void * E, GEN x, GEN y, GEN *r)
1600 : {
1601 0 : struct _Flxq *D = (struct _Flxq*) E;
1602 0 : return Flx_divrem(x, y, D->p, r);
1603 : }
1604 : static GEN
1605 17482318 : _Flx_add(void * E, GEN x, GEN y) {
1606 17482318 : struct _Flxq *D = (struct _Flxq*) E;
1607 17482318 : return Flx_add(x, y, D->p);
1608 : }
1609 : static GEN
1610 8957776 : _Flx_mul(void *E, GEN x, GEN y) {
1611 8957776 : struct _Flxq *D = (struct _Flxq*) E;
1612 8957776 : return Flx_mul(x, y, D->p);
1613 : }
1614 : static GEN
1615 0 : _Flx_sqr(void *E, GEN x) {
1616 0 : struct _Flxq *D = (struct _Flxq*) E;
1617 0 : return Flx_sqr(x, D->p);
1618 : }
1619 :
1620 : static struct bb_ring Flx_ring = { _Flx_add,_Flx_mul,_Flx_sqr };
1621 :
1622 : GEN
1623 0 : Flx_digits(GEN x, GEN T, ulong p)
1624 : {
1625 0 : pari_sp av = avma;
1626 : struct _Flxq D;
1627 0 : long d = degpol(T), n = (lgpol(x)+d-1)/d;
1628 : GEN z;
1629 0 : D.p = p;
1630 0 : z = gen_digits(x,T,n,(void *)&D, &Flx_ring, _Flx_divrem);
1631 0 : return gerepileupto(av, z);
1632 : }
1633 :
1634 : GEN
1635 0 : FlxV_Flx_fromdigits(GEN x, GEN T, ulong p)
1636 : {
1637 0 : pari_sp av = avma;
1638 : struct _Flxq D;
1639 : GEN z;
1640 0 : D.p = p;
1641 0 : z = gen_fromdigits(x,T,(void *)&D, &Flx_ring);
1642 0 : return gerepileupto(av, z);
1643 : }
1644 :
1645 : long
1646 1594393 : Flx_val(GEN x)
1647 : {
1648 1594393 : long i, l=lg(x);
1649 1594393 : if (l==2) return LONG_MAX;
1650 1594393 : for (i=2; i<l && x[i]==0; i++) /*empty*/;
1651 1594393 : return i-2;
1652 : }
1653 : long
1654 22324148 : Flx_valrem(GEN x, GEN *Z)
1655 : {
1656 22324148 : long v, i, l=lg(x);
1657 : GEN y;
1658 22324148 : if (l==2) { *Z = Flx_copy(x); return LONG_MAX; }
1659 22324148 : for (i=2; i<l && x[i]==0; i++) /*empty*/;
1660 22324148 : v = i-2;
1661 22324148 : if (v == 0) { *Z = x; return 0; }
1662 49638 : l -= v;
1663 49638 : y = cgetg(l, t_VECSMALL); y[1] = x[1];
1664 49638 : for (i=2; i<l; i++) y[i] = x[i+v];
1665 49638 : *Z = y; return v;
1666 : }
1667 :
1668 : GEN
1669 5700432 : Flx_deriv(GEN z, ulong p)
1670 : {
1671 5700432 : long i,l = lg(z)-1;
1672 : GEN x;
1673 5700432 : if (l < 2) l = 2;
1674 5700432 : x = cgetg(l, t_VECSMALL); x[1] = z[1]; z++;
1675 5700254 : if (HIGHWORD(l | p))
1676 1220943 : for (i=2; i<l; i++) x[i] = Fl_mul((ulong)i-1, z[i], p);
1677 : else
1678 4479311 : for (i=2; i<l; i++) x[i] = ((i-1) * z[i]) % p;
1679 5700905 : return Flx_renormalize(x,l);
1680 : }
1681 :
1682 : GEN
1683 9583 : Flx_translate1(GEN P, ulong p)
1684 : {
1685 9583 : long i, k, n = degpol(P);
1686 9583 : GEN R = Flx_copy(P);
1687 42322 : for (i=1; i<=n; i++)
1688 120169 : for (k=n-i; k<n; k++)
1689 87430 : uel(R,k+2) = Fl_add(uel(R,k+2), uel(R,k+3), p);
1690 9583 : return R;
1691 : }
1692 :
1693 : GEN
1694 9583 : Flx_diff1(GEN P, ulong p)
1695 : {
1696 9583 : return Flx_sub(Flx_translate1(P, p), P, p);
1697 : }
1698 :
1699 : GEN
1700 71136 : Flx_deflate(GEN x0, long d)
1701 : {
1702 : GEN z, y, x;
1703 71136 : long i,id, dy, dx = degpol(x0);
1704 71136 : if (d == 1 || dx <= 0) return Flx_copy(x0);
1705 65074 : dy = dx/d;
1706 65074 : y = cgetg(dy+3, t_VECSMALL); y[1] = x0[1];
1707 65074 : z = y + 2;
1708 65074 : x = x0+ 2;
1709 65074 : for (i=id=0; i<=dy; i++,id+=d) z[i] = x[id];
1710 65074 : return y;
1711 : }
1712 :
1713 : GEN
1714 45024 : Flx_inflate(GEN x0, long d)
1715 : {
1716 45024 : long i, id, dy, dx = degpol(x0);
1717 45024 : GEN x = x0 + 2, z, y;
1718 45024 : if (dx <= 0) return Flx_copy(x0);
1719 44439 : dy = dx*d;
1720 44439 : y = cgetg(dy+3, t_VECSMALL); y[1] = x0[1];
1721 44442 : z = y + 2;
1722 44442 : for (i=0; i<=dy; i++) z[i] = 0;
1723 44442 : for (i=id=0; i<=dx; i++,id+=d) z[id] = x[i];
1724 44442 : return y;
1725 : }
1726 :
1727 : /* write p(X) = a_0(X^k) + X*a_1(X^k) + ... + X^(k-1)*a_{k-1}(X^k) */
1728 : GEN
1729 149198 : Flx_splitting(GEN p, long k)
1730 : {
1731 149198 : long n = degpol(p), v = p[1], m, i, j, l;
1732 : GEN r;
1733 :
1734 149197 : m = n/k;
1735 149197 : r = cgetg(k+1,t_VEC);
1736 684372 : for(i=1; i<=k; i++)
1737 : {
1738 535163 : gel(r,i) = cgetg(m+3, t_VECSMALL);
1739 535167 : mael(r,i,1) = v;
1740 : }
1741 4707759 : for (j=1, i=0, l=2; i<=n; i++)
1742 : {
1743 4558550 : mael(r,j,l) = p[2+i];
1744 4558550 : if (j==k) { j=1; l++; } else j++;
1745 : }
1746 684385 : for(i=1; i<=k; i++)
1747 535183 : gel(r,i) = Flx_renormalize(gel(r,i),i<j?l+1:l);
1748 149202 : return r;
1749 : }
1750 : static GEN
1751 32608 : Flx_halfgcd_basecase(GEN a, GEN b, ulong p)
1752 : {
1753 32608 : pari_sp av=avma;
1754 : GEN u,u1,v,v1;
1755 32608 : long vx = a[1];
1756 32608 : long n = lgpol(a)>>1;
1757 32608 : u1 = v = pol0_Flx(vx);
1758 32608 : u = v1 = pol1_Flx(vx);
1759 151880 : while (lgpol(b)>n)
1760 : {
1761 86664 : GEN r, q = Flx_divrem(a,b,p, &r);
1762 86664 : a = b; b = r; swap(u,u1); swap(v,v1);
1763 86664 : u1 = Flx_sub(u1, Flx_mul(u, q, p), p);
1764 86664 : v1 = Flx_sub(v1, Flx_mul(v, q ,p), p);
1765 86664 : if (gc_needed(av,2))
1766 : {
1767 0 : if (DEBUGMEM>1) pari_warn(warnmem,"Flx_halfgcd (d = %ld)",degpol(b));
1768 0 : gerepileall(av,6, &a,&b,&u1,&v1,&u,&v);
1769 : }
1770 : }
1771 32608 : return gerepilecopy(av, mkmat2(mkcol2(u,u1), mkcol2(v,v1)));
1772 : }
1773 : /* ux + vy */
1774 : static GEN
1775 4446 : Flx_addmulmul(GEN u, GEN v, GEN x, GEN y, ulong p)
1776 4446 : { return Flx_add(Flx_mul(u,x, p), Flx_mul(v,y, p), p); }
1777 :
1778 : static GEN
1779 2220 : FlxM_Flx_mul2(GEN M, GEN x, GEN y, ulong p)
1780 : {
1781 2220 : GEN res = cgetg(3, t_COL);
1782 2220 : gel(res, 1) = Flx_addmulmul(gcoeff(M,1,1), gcoeff(M,1,2), x, y, p);
1783 2220 : gel(res, 2) = Flx_addmulmul(gcoeff(M,2,1), gcoeff(M,2,2), x, y, p);
1784 2220 : return res;
1785 : }
1786 :
1787 : #if 0
1788 : static GEN
1789 : FlxM_mul2_old(GEN M, GEN N, ulong p)
1790 : {
1791 : GEN res = cgetg(3, t_MAT);
1792 : gel(res, 1) = FlxM_Flx_mul2(M,gcoeff(N,1,1),gcoeff(N,2,1),p);
1793 : gel(res, 2) = FlxM_Flx_mul2(M,gcoeff(N,1,2),gcoeff(N,2,2),p);
1794 : return res;
1795 : }
1796 : #endif
1797 : /* A,B are 2x2 matrices, Flx entries. Return A x B using Strassen 7M formula */
1798 : static GEN
1799 1635 : FlxM_mul2(GEN A, GEN B, ulong p)
1800 : {
1801 1635 : GEN A11=gcoeff(A,1,1),A12=gcoeff(A,1,2), B11=gcoeff(B,1,1),B12=gcoeff(B,1,2);
1802 1635 : GEN A21=gcoeff(A,2,1),A22=gcoeff(A,2,2), B21=gcoeff(B,2,1),B22=gcoeff(B,2,2);
1803 1635 : GEN M1 = Flx_mul(Flx_add(A11,A22, p), Flx_add(B11,B22, p), p);
1804 1635 : GEN M2 = Flx_mul(Flx_add(A21,A22, p), B11, p);
1805 1635 : GEN M3 = Flx_mul(A11, Flx_sub(B12,B22, p), p);
1806 1635 : GEN M4 = Flx_mul(A22, Flx_sub(B21,B11, p), p);
1807 1635 : GEN M5 = Flx_mul(Flx_add(A11,A12, p), B22, p);
1808 1635 : GEN M6 = Flx_mul(Flx_sub(A21,A11, p), Flx_add(B11,B12, p), p);
1809 1635 : GEN M7 = Flx_mul(Flx_sub(A12,A22, p), Flx_add(B21,B22, p), p);
1810 1635 : GEN T1 = Flx_add(M1,M4, p), T2 = Flx_sub(M7,M5, p);
1811 1635 : GEN T3 = Flx_sub(M1,M2, p), T4 = Flx_add(M3,M6, p);
1812 1635 : retmkmat2(mkcol2(Flx_add(T1,T2, p), Flx_add(M2,M4, p)),
1813 : mkcol2(Flx_add(M3,M5, p), Flx_add(T3,T4, p)));
1814 : }
1815 :
1816 : /* Return [0,1;1,-q]*M */
1817 : static GEN
1818 1632 : Flx_FlxM_qmul(GEN q, GEN M, ulong p)
1819 : {
1820 1632 : GEN u, v, res = cgetg(3, t_MAT);
1821 1632 : u = Flx_sub(gcoeff(M,1,1), Flx_mul(gcoeff(M,2,1), q, p), p);
1822 1632 : gel(res,1) = mkcol2(gcoeff(M,2,1), u);
1823 1632 : v = Flx_sub(gcoeff(M,1,2), Flx_mul(gcoeff(M,2,2), q, p), p);
1824 1632 : gel(res,2) = mkcol2(gcoeff(M,2,2), v);
1825 1632 : return res;
1826 : }
1827 :
1828 : static GEN
1829 3 : matid2_FlxM(long v)
1830 : {
1831 3 : return mkmat2(mkcol2(pol1_Flx(v),pol0_Flx(v)),
1832 : mkcol2(pol0_Flx(v),pol1_Flx(v)));
1833 : }
1834 :
1835 : static GEN
1836 2194 : Flx_halfgcd_split(GEN x, GEN y, ulong p)
1837 : {
1838 2194 : pari_sp av=avma;
1839 : GEN R, S, V;
1840 : GEN y1, r, q;
1841 2194 : long l = lgpol(x), n = l>>1, k;
1842 2194 : if (lgpol(y)<=n) return matid2_FlxM(x[1]);
1843 2194 : R = Flx_halfgcd(Flx_shift(x,-n),Flx_shift(y,-n),p);
1844 2194 : V = FlxM_Flx_mul2(R,x,y,p); y1 = gel(V,2);
1845 2194 : if (lgpol(y1)<=n) return gerepilecopy(av, R);
1846 1632 : q = Flx_divrem(gel(V,1), y1, p, &r);
1847 1632 : k = 2*n-degpol(y1);
1848 1632 : S = Flx_halfgcd(Flx_shift(y1,-k), Flx_shift(r,-k),p);
1849 1632 : return gerepileupto(av, FlxM_mul2(S,Flx_FlxM_qmul(q,R,p),p));
1850 : }
1851 :
1852 : /* Return M in GL_2(Fl[X]) such that:
1853 : if [a',b']~=M*[a,b]~ then degpol(a')>= (lgpol(a)>>1) >degpol(b')
1854 : */
1855 :
1856 : static GEN
1857 34802 : Flx_halfgcd_i(GEN x, GEN y, ulong p)
1858 : {
1859 34802 : if (!Flx_multhreshold(x,p,
1860 : Flx_HALFGCD_QUARTMULII_LIMIT,
1861 : Flx_HALFGCD_HALFMULII_LIMIT,
1862 : Flx_HALFGCD_MULII_LIMIT,
1863 : Flx_HALFGCD_MULII2_LIMIT,
1864 : Flx_HALFGCD_KARATSUBA_LIMIT))
1865 32608 : return Flx_halfgcd_basecase(x,y,p);
1866 2194 : return Flx_halfgcd_split(x,y,p);
1867 : }
1868 :
1869 : GEN
1870 34802 : Flx_halfgcd(GEN x, GEN y, ulong p)
1871 : {
1872 : pari_sp av;
1873 : GEN M,q,r;
1874 34802 : long lx=lgpol(x), ly=lgpol(y);
1875 34802 : if (!lx)
1876 : {
1877 0 : long v = x[1];
1878 0 : retmkmat2(mkcol2(pol0_Flx(v),pol1_Flx(v)),
1879 : mkcol2(pol1_Flx(v),pol0_Flx(v)));
1880 : }
1881 34802 : if (ly < lx) return Flx_halfgcd_i(x,y,p);
1882 900 : av = avma;
1883 900 : q = Flx_divrem(y,x,p,&r);
1884 900 : M = Flx_halfgcd_i(x,r,p);
1885 900 : gcoeff(M,1,1) = Flx_sub(gcoeff(M,1,1), Flx_mul(q, gcoeff(M,1,2), p), p);
1886 900 : gcoeff(M,2,1) = Flx_sub(gcoeff(M,2,1), Flx_mul(q, gcoeff(M,2,2), p), p);
1887 900 : return gerepilecopy(av, M);
1888 : }
1889 :
1890 : /*Do not garbage collect*/
1891 : static GEN
1892 28086177 : Flx_gcd_basecase(GEN a, GEN b, ulong p)
1893 : {
1894 28086177 : pari_sp av = avma;
1895 28086177 : ulong iter = 0;
1896 28086177 : if (lg(b) > lg(a)) swap(a, b);
1897 142617076 : while (lgpol(b))
1898 : {
1899 86496403 : GEN c = Flx_rem(a,b,p);
1900 86444722 : iter++; a = b; b = c;
1901 86444722 : if (gc_needed(av,2))
1902 : {
1903 0 : if (DEBUGMEM>1) pari_warn(warnmem,"Flx_gcd (d = %ld)",degpol(c));
1904 0 : gerepileall(av,2, &a,&b);
1905 : }
1906 : }
1907 28063792 : return iter < 2 ? Flx_copy(a) : a;
1908 : }
1909 :
1910 : GEN
1911 28675922 : Flx_gcd(GEN x, GEN y, ulong p)
1912 : {
1913 28675922 : pari_sp av = avma;
1914 28675922 : if (!lgpol(x)) return Flx_copy(y);
1915 56173445 : while (lg(y)>Flx_GCD_LIMIT)
1916 : {
1917 : GEN c;
1918 23 : if (lgpol(y)<=(lgpol(x)>>1))
1919 : {
1920 0 : GEN r = Flx_rem(x, y, p);
1921 0 : x = y; y = r;
1922 : }
1923 23 : c = FlxM_Flx_mul2(Flx_halfgcd(x,y, p), x, y, p);
1924 23 : x = gel(c,1); y = gel(c,2);
1925 23 : if (gc_needed(av,2))
1926 : {
1927 0 : if (DEBUGMEM>1) pari_warn(warnmem,"Flx_gcd (y = %ld)",degpol(y));
1928 0 : gerepileall(av,2,&x,&y);
1929 : }
1930 : }
1931 28086865 : return gerepileuptoleaf(av, Flx_gcd_basecase(x,y,p));
1932 : }
1933 :
1934 : int
1935 3471788 : Flx_is_squarefree(GEN z, ulong p)
1936 : {
1937 3471788 : pari_sp av = avma;
1938 3471788 : GEN d = Flx_gcd(z, Flx_deriv(z,p) , p);
1939 3471788 : long res= (degpol(d) == 0);
1940 3471788 : avma = av; return res;
1941 : }
1942 :
1943 : static long
1944 93381 : Flx_is_smooth_squarefree(GEN f, long r, ulong p)
1945 : {
1946 93381 : pari_sp av = avma;
1947 : long i;
1948 93381 : GEN sx = polx_Flx(f[1]), a = sx;
1949 361622 : for(i=1;;i++)
1950 : {
1951 361622 : if (degpol(f)<=r) {avma = av; return 1;}
1952 349362 : a = Flxq_pow(Flx_rem(a,f,p),utoi(p),f,p);
1953 349584 : if (Flx_equal(a, sx)) {avma = av; return 1;}
1954 346562 : if (i==r) {avma = av; return 0;}
1955 268370 : f = Flx_div(f, Flx_gcd(Flx_sub(a,sx,p),f,p),p);
1956 268269 : }
1957 : }
1958 :
1959 : static long
1960 5013 : Flx_is_l_pow(GEN x, ulong p)
1961 : {
1962 5013 : ulong i, lx = lgpol(x);
1963 8749 : for (i=1; i<lx; i++)
1964 8053 : if (x[i+2] && i%p) return 0;
1965 696 : return 1;
1966 : }
1967 :
1968 : int
1969 88363 : Flx_is_smooth(GEN g, long r, ulong p)
1970 : {
1971 88363 : GEN f = gen_0;
1972 : while (1)
1973 : {
1974 93376 : f = Flx_gcd(g, Flx_deriv(g, p), p);
1975 93378 : if (!Flx_is_smooth_squarefree(Flx_div(g, f, p), r, p))
1976 78192 : return 0;
1977 15195 : if (degpol(f)==0) return 1;
1978 5013 : g = Flx_is_l_pow(f,p) ? Flx_deflate(f, p): f;
1979 5013 : }
1980 : }
1981 :
1982 : static GEN
1983 3568952 : Flx_extgcd_basecase(GEN a, GEN b, ulong p, GEN *ptu, GEN *ptv)
1984 : {
1985 3568952 : pari_sp av=avma;
1986 : GEN u,v,d,d1,v1;
1987 3568952 : long vx = a[1];
1988 3568952 : d = a; d1 = b;
1989 3568952 : v = pol0_Flx(vx); v1 = pol1_Flx(vx);
1990 22732398 : while (lgpol(d1))
1991 : {
1992 15594494 : GEN r, q = Flx_divrem(d,d1,p, &r);
1993 15594494 : v = Flx_sub(v,Flx_mul(q,v1,p),p);
1994 15594494 : u=v; v=v1; v1=u;
1995 15594494 : u=r; d=d1; d1=u;
1996 15594494 : if (gc_needed(av,2))
1997 : {
1998 0 : if (DEBUGMEM>1) pari_warn(warnmem,"Flx_extgcd (d = %ld)",degpol(d));
1999 0 : gerepileall(av,5, &d,&d1,&u,&v,&v1);
2000 : }
2001 : }
2002 3568952 : if (ptu) *ptu = Flx_div(Flx_sub(d, Flx_mul(b,v,p), p), a, p);
2003 3568952 : *ptv = v; return d;
2004 : }
2005 :
2006 : static GEN
2007 3 : Flx_extgcd_halfgcd(GEN x, GEN y, ulong p, GEN *ptu, GEN *ptv)
2008 : {
2009 3 : pari_sp av=avma;
2010 3 : GEN u,v,R = matid2_FlxM(x[1]);
2011 9 : while (lg(y)>Flx_EXTGCD_LIMIT)
2012 : {
2013 : GEN M, c;
2014 3 : if (lgpol(y)<=(lgpol(x)>>1))
2015 : {
2016 0 : GEN r, q = Flx_divrem(x, y, p, &r);
2017 0 : x = y; y = r;
2018 0 : R = Flx_FlxM_qmul(q, R, p);
2019 : }
2020 3 : M = Flx_halfgcd(x,y, p);
2021 3 : c = FlxM_Flx_mul2(M, x,y, p);
2022 3 : R = FlxM_mul2(M, R, p);
2023 3 : x = gel(c,1); y = gel(c,2);
2024 3 : gerepileall(av,3,&x,&y,&R);
2025 : }
2026 3 : y = Flx_extgcd_basecase(x,y,p,&u,&v);
2027 3 : if (ptu) *ptu = Flx_addmulmul(u,v,gcoeff(R,1,1),gcoeff(R,2,1),p);
2028 3 : *ptv = Flx_addmulmul(u,v,gcoeff(R,1,2),gcoeff(R,2,2),p);
2029 3 : return y;
2030 : }
2031 :
2032 : /* x and y in Z[X], return lift(gcd(x mod p, y mod p)). Set u and v st
2033 : * ux + vy = gcd (mod p) */
2034 : GEN
2035 3568952 : Flx_extgcd(GEN x, GEN y, ulong p, GEN *ptu, GEN *ptv)
2036 : {
2037 : GEN d;
2038 3568952 : pari_sp ltop=avma;
2039 3568952 : if (lg(y)>Flx_EXTGCD_LIMIT)
2040 3 : d = Flx_extgcd_halfgcd(x, y, p, ptu, ptv);
2041 : else
2042 3568949 : d = Flx_extgcd_basecase(x, y, p, ptu, ptv);
2043 3568952 : gerepileall(ltop,ptu?3:2,&d,ptv,ptu);
2044 3568952 : return d;
2045 : }
2046 :
2047 : ulong
2048 1939302 : Flx_resultant(GEN a, GEN b, ulong p)
2049 : {
2050 : long da,db,dc,cnt;
2051 1939302 : ulong lb, res = 1UL;
2052 : pari_sp av;
2053 : GEN c;
2054 :
2055 1939302 : if (lgpol(a)==0 || lgpol(b)==0) return 0;
2056 1939412 : da = degpol(a);
2057 1939440 : db = degpol(b);
2058 1945682 : if (db > da)
2059 : {
2060 84611 : swapspec(a,b, da,db);
2061 84611 : if (both_odd(da,db)) res = p-res;
2062 : }
2063 1861071 : else if (!da) return 1; /* = res * a[2] ^ db, since 0 <= db <= da = 0 */
2064 1945692 : cnt = 0; av = avma;
2065 32241282 : while (db)
2066 : {
2067 28356431 : lb = b[db+2];
2068 28356431 : c = Flx_rem(a,b, p);
2069 28269639 : a = b; b = c; dc = degpol(c);
2070 28273736 : if (dc < 0) { avma = av; return 0; }
2071 :
2072 28273582 : if (both_odd(da,db)) res = p - res;
2073 28296237 : if (lb != 1) res = Fl_mul(res, Fl_powu(lb, da - dc, p), p);
2074 28349898 : if (++cnt == 100) { cnt = 0; gerepileall(av, 2, &a, &b); }
2075 28349898 : da = db; /* = degpol(a) */
2076 28349898 : db = dc; /* = degpol(b) */
2077 : }
2078 1939159 : avma = av; return Fl_mul(res, Fl_powu(b[2], da, p), p);
2079 : }
2080 :
2081 : /* If resultant is 0, *ptU and *ptU are not set */
2082 : ulong
2083 109636 : Flx_extresultant(GEN a, GEN b, ulong p, GEN *ptU, GEN *ptV)
2084 : {
2085 109636 : GEN z,q,u,v, x = a, y = b;
2086 109636 : ulong lb, res = 1UL;
2087 109636 : pari_sp av = avma;
2088 : long dx, dy, dz;
2089 109636 : long vs=a[1];
2090 :
2091 109636 : dx = degpol(x);
2092 109636 : dy = degpol(y);
2093 109636 : if (dy > dx)
2094 : {
2095 379 : swap(x,y); lswap(dx,dy); pswap(ptU, ptV);
2096 379 : a = x; b = y;
2097 379 : if (both_odd(dx,dy)) res = p-res;
2098 : }
2099 : /* dx <= dy */
2100 109636 : if (dx < 0) return 0;
2101 :
2102 109636 : u = pol0_Flx(vs);
2103 109636 : v = pol1_Flx(vs); /* v = 1 */
2104 754273 : while (dy)
2105 : { /* b u = x (a), b v = y (a) */
2106 535008 : lb = y[dy+2];
2107 535008 : q = Flx_divrem(x,y, p, &z);
2108 535001 : x = y; y = z; /* (x,y) = (y, x - q y) */
2109 535001 : dz = degpol(z); if (dz < 0) { avma = av; return 0; }
2110 535001 : z = Flx_sub(u, Flx_mul(q,v, p), p);
2111 535001 : u = v; v = z; /* (u,v) = (v, u - q v) */
2112 :
2113 535001 : if (both_odd(dx,dy)) res = p - res;
2114 535001 : if (lb != 1) res = Fl_mul(res, Fl_powu(lb, dx-dz, p), p);
2115 535001 : dx = dy; /* = degpol(x) */
2116 535001 : dy = dz; /* = degpol(y) */
2117 : }
2118 109629 : res = Fl_mul(res, Fl_powu(y[2], dx, p), p);
2119 109629 : lb = Fl_mul(res, Fl_inv(y[2],p), p);
2120 109629 : v = gerepileuptoleaf(av, Flx_Fl_mul(v, lb, p));
2121 109629 : av = avma;
2122 109629 : u = Flx_sub(Fl_to_Flx(res,vs), Flx_mul(b,v,p), p);
2123 109629 : u = gerepileuptoleaf(av, Flx_div(u,a,p)); /* = (res - b v) / a */
2124 109629 : *ptU = u;
2125 109629 : *ptV = v; return res;
2126 : }
2127 :
2128 : ulong
2129 14570517 : Flx_eval_powers_pre(GEN x, GEN y, ulong p, ulong pi)
2130 : {
2131 14570517 : ulong l0, l1, h0, h1, v1, i = 1, lx = lg(x)-1;
2132 : LOCAL_OVERFLOW;
2133 : LOCAL_HIREMAINDER;
2134 14570517 : x++;
2135 :
2136 14570517 : if (lx == 1)
2137 2946449 : return 0;
2138 11624068 : l1 = mulll(uel(x,i), uel(y,i)); h1 = hiremainder; v1 = 0;
2139 61844519 : while (++i < lx) {
2140 38596383 : l0 = mulll(uel(x,i), uel(y,i)); h0 = hiremainder;
2141 38596383 : l1 = addll(l0, l1); h1 = addllx(h0, h1); v1 += overflow;
2142 : }
2143 11624068 : if (v1 == 0) return remll_pre(h1, l1, p, pi);
2144 5514 : else return remlll_pre(v1, h1, l1, p, pi);
2145 : }
2146 :
2147 : INLINE ulong
2148 3511191 : Flx_eval_pre_i(GEN x, ulong y, ulong p, ulong pi)
2149 : {
2150 : ulong p1;
2151 3511191 : long i=lg(x)-1;
2152 3511191 : if (i<=2)
2153 1437148 : return (i==2)? x[2]: 0;
2154 2074043 : p1 = x[i];
2155 9995087 : for (i--; i>=2; i--)
2156 7926178 : p1 = Fl_addmul_pre(uel(x, i), p1, y, p, pi);
2157 2068909 : return p1;
2158 : }
2159 :
2160 : ulong
2161 3581328 : Flx_eval_pre(GEN x, ulong y, ulong p, ulong pi)
2162 : {
2163 3581328 : if (degpol(x) > 15)
2164 : {
2165 77532 : pari_sp av = avma;
2166 77532 : GEN v = Fl_powers_pre(y, degpol(x), p, pi);
2167 77567 : ulong r = Flx_eval_powers_pre(x, v, p, pi);
2168 77585 : avma = av;
2169 77585 : return r;
2170 : }
2171 : else
2172 3503137 : return Flx_eval_pre_i(x, y, p, pi);
2173 : }
2174 :
2175 : ulong
2176 3577124 : Flx_eval(GEN x, ulong y, ulong p)
2177 : {
2178 3577124 : return Flx_eval_pre(x, y, p, get_Fl_red(p));
2179 : }
2180 :
2181 : ulong
2182 2975 : Flv_prod_pre(GEN x, ulong p, ulong pi)
2183 : {
2184 2975 : pari_sp ltop = avma;
2185 : GEN v;
2186 2975 : long i,k,lx = lg(x);
2187 : ulong r;
2188 2975 : if (lx == 1) return 1UL;
2189 2975 : if (lx == 2) return uel(x,1);
2190 2912 : v = cgetg(1+(lx << 1), t_VECSMALL);
2191 2912 : k = 1;
2192 25522 : for (i=1; i<lx-1; i+=2)
2193 22610 : uel(v,k++) = Fl_mul_pre(uel(x,i), uel(x,i+1), p, pi);
2194 2912 : if (i < lx) uel(v,k++) = uel(x,i);
2195 15526 : while (k > 2)
2196 : {
2197 9702 : lx = k; k = 1;
2198 32312 : for (i=1; i<lx-1; i+=2)
2199 22610 : uel(v,k++) = Fl_mul_pre(uel(v,i), uel(v,i+1), p, pi);
2200 9702 : if (i < lx) uel(v,k++) = uel(v,i);
2201 : }
2202 2912 : r = uel(v,1);
2203 2912 : avma = ltop; return r;
2204 : }
2205 :
2206 : ulong
2207 0 : Flv_prod(GEN v, ulong p)
2208 : {
2209 0 : return Flv_prod_pre(v, p, get_Fl_red(p));
2210 : }
2211 :
2212 : GEN
2213 0 : FlxV_prod(GEN V, ulong p)
2214 : {
2215 : struct _Flxq D;
2216 0 : D.T = NULL; D.aut = NULL; D.p = p;
2217 0 : return gen_product(V, (void *)&D, &_Flx_mul);
2218 : }
2219 :
2220 : /* compute prod (x - a[i]) */
2221 : GEN
2222 596999 : Flv_roots_to_pol(GEN a, ulong p, long vs)
2223 : {
2224 : struct _Flxq D;
2225 596999 : long i,k,lx = lg(a);
2226 : GEN p1;
2227 596999 : if (lx == 1) return pol1_Flx(vs);
2228 596999 : p1 = cgetg(lx, t_VEC);
2229 10089447 : for (k=1,i=1; i<lx-1; i+=2)
2230 18996437 : gel(p1,k++) = mkvecsmall4(vs, Fl_mul(a[i], a[i+1], p),
2231 9492676 : Fl_neg(Fl_add(a[i],a[i+1],p),p), 1);
2232 596771 : if (i < lx)
2233 51546 : gel(p1,k++) = mkvecsmall3(vs, Fl_neg(a[i],p), 1);
2234 596771 : D.T = NULL; D.aut = NULL; D.p = p;
2235 596771 : setlg(p1, k); return gen_product(p1, (void *)&D, _Flx_mul);
2236 : }
2237 :
2238 : INLINE void
2239 366817 : Flv_inv_pre_indir(GEN w, GEN v, ulong p, ulong pi)
2240 : {
2241 366817 : pari_sp av = avma;
2242 : GEN c;
2243 : register ulong u;
2244 366817 : register long n = lg(w), i;
2245 :
2246 366817 : if (n == 1)
2247 366816 : return;
2248 :
2249 366817 : c = cgetg(n, t_VECSMALL);
2250 366824 : c[1] = w[1];
2251 1564372 : for (i = 2; i < n; ++i)
2252 1197554 : c[i] = Fl_mul_pre(w[i], c[i - 1], p, pi);
2253 :
2254 366818 : i = n - 1;
2255 366818 : u = Fl_inv(c[i], p);
2256 1564385 : for ( ; i > 1; --i) {
2257 1197569 : ulong t = Fl_mul_pre(u, c[i - 1], p, pi);
2258 1197590 : u = Fl_mul_pre(u, w[i], p, pi);
2259 1197587 : v[i] = t;
2260 : }
2261 366816 : v[1] = u;
2262 366816 : avma = av;
2263 : }
2264 :
2265 : void
2266 336693 : Flv_inv_pre_inplace(GEN v, ulong p, ulong pi)
2267 : {
2268 336693 : Flv_inv_pre_indir(v, v, p, pi);
2269 336693 : }
2270 :
2271 : GEN
2272 9721 : Flv_inv_pre(GEN w, ulong p, ulong pi)
2273 : {
2274 9721 : GEN v = cgetg(lg(w), t_VECSMALL);
2275 9721 : Flv_inv_pre_indir(w, v, p, pi);
2276 9721 : return v;
2277 : }
2278 :
2279 : INLINE void
2280 27687 : Flv_inv_indir(GEN w, GEN v, ulong p)
2281 : {
2282 27687 : pari_sp av = avma;
2283 : GEN c;
2284 : register ulong u;
2285 27687 : register long n = lg(w), i;
2286 :
2287 27687 : if (n == 1)
2288 27688 : return;
2289 :
2290 27687 : c = cgetg(n, t_VECSMALL);
2291 27682 : c[1] = w[1];
2292 355671 : for (i = 2; i < n; ++i)
2293 327983 : c[i] = Fl_mul(w[i], c[i - 1], p);
2294 :
2295 27688 : i = n - 1;
2296 27688 : u = Fl_inv(c[i], p);
2297 355675 : for ( ; i > 1; --i) {
2298 327987 : ulong t = Fl_mul(u, c[i - 1], p);
2299 327981 : u = Fl_mul(u, w[i], p);
2300 327983 : v[i] = t;
2301 : }
2302 27688 : v[1] = u;
2303 27688 : avma = av;
2304 : }
2305 :
2306 : void
2307 0 : Flv_inv_inplace(GEN v, ulong p)
2308 : {
2309 0 : if (SMALL_ULONG(p))
2310 0 : Flv_inv_indir(v, v, p);
2311 : else
2312 0 : Flv_inv_pre_indir(v, v, p, get_Fl_red(p));
2313 0 : }
2314 :
2315 : GEN
2316 48090 : Flv_inv(GEN w, ulong p)
2317 : {
2318 48090 : GEN v = cgetg(lg(w), t_VECSMALL);
2319 48091 : if (SMALL_ULONG(p))
2320 27688 : Flv_inv_indir(w, v, p);
2321 : else
2322 20403 : Flv_inv_pre_indir(w, v, p, get_Fl_red(p));
2323 48090 : return v;
2324 : }
2325 :
2326 : GEN
2327 28449389 : Flx_div_by_X_x(GEN a, ulong x, ulong p, ulong *rem)
2328 : {
2329 28449389 : long l = lg(a), i;
2330 : GEN a0, z0;
2331 28449389 : GEN z = cgetg(l-1,t_VECSMALL);
2332 28415671 : z[1] = a[1];
2333 28415671 : a0 = a + l-1;
2334 28415671 : z0 = z + l-2; *z0 = *a0--;
2335 28415671 : if (SMALL_ULONG(p))
2336 : {
2337 69829146 : for (i=l-3; i>1; i--) /* z[i] = (a[i+1] + x*z[i+1]) % p */
2338 : {
2339 52441923 : ulong t = (*a0-- + x * *z0--) % p;
2340 52441923 : *z0 = (long)t;
2341 : }
2342 17387223 : if (rem) *rem = (*a0 + x * *z0) % p;
2343 : }
2344 : else
2345 : {
2346 43341730 : for (i=l-3; i>1; i--)
2347 : {
2348 32256091 : ulong t = Fl_add((ulong)*a0--, Fl_mul(x, *z0--, p), p);
2349 32313282 : *z0 = (long)t;
2350 : }
2351 11085639 : if (rem) *rem = Fl_add((ulong)*a0, Fl_mul(x, *z0, p), p);
2352 : }
2353 28469625 : return z;
2354 : }
2355 :
2356 : /* xa, ya = t_VECSMALL */
2357 : static GEN
2358 48090 : Flv_producttree(GEN xa, GEN s, ulong p, long vs)
2359 : {
2360 48090 : long n = lg(xa)-1;
2361 48090 : long m = n==1 ? 1: expu(n-1)+1;
2362 48089 : long i, j, k, ls = lg(s);
2363 48089 : GEN T = cgetg(m+1, t_VEC);
2364 48082 : GEN t = cgetg(ls, t_VEC);
2365 600425 : for (j=1, k=1; j<ls; k+=s[j++])
2366 1104680 : gel(t, j) = s[j] == 1 ?
2367 751851 : mkvecsmall3(vs, Fl_neg(xa[k], p), 1):
2368 199515 : mkvecsmall4(vs, Fl_mul(xa[k], xa[k+1], p),
2369 199485 : Fl_neg(Fl_add(xa[k],xa[k+1],p),p), 1);
2370 48086 : gel(T,1) = t;
2371 183934 : for (i=2; i<=m; i++)
2372 : {
2373 135842 : GEN u = gel(T, i-1);
2374 135842 : long n = lg(u)-1;
2375 135842 : GEN t = cgetg(((n+1)>>1)+1, t_VEC);
2376 640354 : for (j=1, k=1; k<n; j++, k+=2)
2377 504506 : gel(t, j) = Flx_mul(gel(u, k), gel(u, k+1), p);
2378 135848 : gel(T, i) = t;
2379 : }
2380 48092 : return T;
2381 : }
2382 :
2383 : static GEN
2384 48087 : Flx_Flv_multieval_tree(GEN P, GEN xa, GEN T, ulong p)
2385 : {
2386 : long i,j,k;
2387 48087 : long m = lg(T)-1;
2388 : GEN t;
2389 48087 : GEN R = cgetg(lg(xa), t_VECSMALL);
2390 48083 : GEN Tp = cgetg(m+1, t_VEC);
2391 48081 : gel(Tp, m) = mkvec(P);
2392 183909 : for (i=m-1; i>=1; i--)
2393 : {
2394 135811 : GEN u = gel(T, i);
2395 135811 : GEN v = gel(Tp, i+1);
2396 135811 : long n = lg(u)-1;
2397 135811 : t = cgetg(n+1, t_VEC);
2398 640214 : for (j=1, k=1; k<n; j++, k+=2)
2399 : {
2400 504396 : gel(t, k) = Flx_rem(gel(v, j), gel(u, k), p);
2401 504392 : gel(t, k+1) = Flx_rem(gel(v, j), gel(u, k+1), p);
2402 : }
2403 135818 : gel(Tp, i) = t;
2404 : }
2405 : {
2406 48098 : GEN u = gel(T, i+1);
2407 48098 : GEN v = gel(Tp, i+1);
2408 48098 : long n = lg(u)-1;
2409 600630 : for (j=1, k=1; j<=n; j++)
2410 : {
2411 552537 : long c, d = degpol(gel(u,j));
2412 1304538 : for (c=1; c<=d; c++, k++)
2413 752006 : R[k] = Flx_eval(gel(v, j), xa[k], p);
2414 : }
2415 48093 : avma = (pari_sp) R;
2416 48093 : return R;
2417 : }
2418 : }
2419 :
2420 : static GEN
2421 719320 : FlvV_polint_tree(GEN T, GEN R, GEN s, GEN xa, GEN ya, ulong p, long vs)
2422 : {
2423 719320 : pari_sp av = avma;
2424 719320 : long m = lg(T)-1;
2425 719320 : long i, j, k, ls = lg(s);
2426 719320 : GEN Tp = cgetg(m+1, t_VEC);
2427 718945 : GEN t = cgetg(ls, t_VEC);
2428 12819761 : for (j=1, k=1; j<ls; k+=s[j++])
2429 12100482 : if (s[j]==2)
2430 : {
2431 4093293 : ulong a = Fl_mul(ya[k], R[k], p);
2432 4107950 : ulong b = Fl_mul(ya[k+1], R[k+1], p);
2433 12327850 : gel(t, j) = mkvecsmall3(vs, Fl_neg(Fl_add(Fl_mul(xa[k], b, p ),
2434 8218302 : Fl_mul(xa[k+1], a, p), p), p), Fl_add(a, b, p));
2435 4105208 : gel(t, j) = Flx_renormalize(gel(t, j), 4);
2436 : }
2437 : else
2438 8007189 : gel(t, j) = Fl_to_Flx(Fl_mul(ya[k], R[k], p), vs);
2439 719279 : gel(Tp, 1) = t;
2440 3215809 : for (i=2; i<=m; i++)
2441 : {
2442 2496778 : GEN u = gel(T, i-1);
2443 2496778 : GEN t = cgetg(lg(gel(T,i)), t_VEC);
2444 2496600 : GEN v = gel(Tp, i-1);
2445 2496600 : long n = lg(v)-1;
2446 13879397 : for (j=1, k=1; k<n; j++, k+=2)
2447 34148601 : gel(t, j) = Flx_add(Flx_mul(gel(u, k), gel(v, k+1), p),
2448 22765734 : Flx_mul(gel(u, k+1), gel(v, k), p), p);
2449 2496530 : gel(Tp, i) = t;
2450 : }
2451 719031 : return gerepileuptoleaf(av, gmael(Tp,m,1));
2452 : }
2453 :
2454 : GEN
2455 0 : Flx_Flv_multieval(GEN P, GEN xa, ulong p)
2456 : {
2457 0 : pari_sp av = avma;
2458 0 : GEN s = producttree_scheme(lg(xa)-1);
2459 0 : GEN T = Flv_producttree(xa, s, p, P[1]);
2460 0 : return gerepileuptoleaf(av, Flx_Flv_multieval_tree(P, xa, T, p));
2461 : }
2462 :
2463 : GEN
2464 12657 : Flv_polint(GEN xa, GEN ya, ulong p, long vs)
2465 : {
2466 12657 : pari_sp av = avma;
2467 12657 : GEN s = producttree_scheme(lg(xa)-1);
2468 12658 : GEN T = Flv_producttree(xa, s, p, vs);
2469 12660 : long m = lg(T)-1;
2470 12660 : GEN P = Flx_deriv(gmael(T, m, 1), p);
2471 12661 : GEN R = Flv_inv(Flx_Flv_multieval_tree(P, xa, T, p), p);
2472 12660 : return gerepileuptoleaf(av, FlvV_polint_tree(T, R, s, xa, ya, p, vs));
2473 : }
2474 :
2475 : GEN
2476 33392 : Flv_Flm_polint(GEN xa, GEN ya, ulong p, long vs)
2477 : {
2478 33392 : pari_sp av = avma;
2479 33392 : GEN s = producttree_scheme(lg(xa)-1);
2480 33394 : GEN T = Flv_producttree(xa, s, p, vs);
2481 33391 : long i, m = lg(T)-1, l = lg(ya)-1;
2482 33391 : GEN P = Flx_deriv(gmael(T, m, 1), p);
2483 33388 : GEN R = Flv_inv(Flx_Flv_multieval_tree(P, xa, T, p), p);
2484 33391 : GEN M = cgetg(l+1, t_VEC);
2485 740070 : for (i=1; i<=l; i++)
2486 706684 : gel(M,i) = FlvV_polint_tree(T, R, s, xa, gel(ya,i), p, vs);
2487 33386 : return gerepileupto(av, M);
2488 : }
2489 :
2490 : GEN
2491 2039 : Flv_invVandermonde(GEN L, ulong den, ulong p)
2492 : {
2493 2039 : pari_sp av = avma;
2494 2039 : long i, n = lg(L);
2495 : GEN M, R;
2496 2039 : GEN s = producttree_scheme(n-1);
2497 2039 : GEN tree = Flv_producttree(L, s, p, 0);
2498 2039 : long m = lg(tree)-1;
2499 2039 : GEN T = gmael(tree, m, 1);
2500 2039 : R = Flv_inv(Flx_Flv_multieval_tree(Flx_deriv(T, p), L, tree, p), p);
2501 2039 : if (den!=1) R = Flv_Fl_mul(R, den, p);
2502 2039 : M = cgetg(n, t_MAT);
2503 6663 : for (i = 1; i < n; i++)
2504 : {
2505 4624 : GEN P = Flx_Fl_mul(Flx_div_by_X_x(T, uel(L,i), p, NULL), uel(R,i), p);
2506 4624 : gel(M,i) = Flx_to_Flv(P, n-1);
2507 : }
2508 2039 : return gerepilecopy(av, M);
2509 : }
2510 :
2511 : /***********************************************************************/
2512 : /** **/
2513 : /** Flxq **/
2514 : /** **/
2515 : /***********************************************************************/
2516 : /* Flxq objects are defined as follows:
2517 : They are Flx modulo another Flx called q.
2518 : */
2519 :
2520 : /* Product of y and x in Z/pZ[X]/(T), as t_VECSMALL. */
2521 : GEN
2522 128825594 : Flxq_mul(GEN x,GEN y,GEN T,ulong p)
2523 : {
2524 128825594 : return Flx_rem(Flx_mul(x,y,p),T,p);
2525 : }
2526 :
2527 : /* Square of y in Z/pZ[X]/(T), as t_VECSMALL. */
2528 : GEN
2529 200567297 : Flxq_sqr(GEN x,GEN T,ulong p)
2530 : {
2531 200567297 : return Flx_rem(Flx_sqr(x,p),T,p);
2532 : }
2533 :
2534 : static GEN
2535 7813057 : _Flxq_red(void *E, GEN x)
2536 7813057 : { struct _Flxq *s = (struct _Flxq *)E;
2537 7813057 : return Flx_rem(x, s->T, s->p); }
2538 : static GEN
2539 0 : _Flx_sub(void *E, GEN x, GEN y)
2540 0 : { struct _Flxq *s = (struct _Flxq *)E;
2541 0 : return Flx_sub(x,y,s->p); }
2542 : static GEN
2543 194917394 : _Flxq_sqr(void *data, GEN x)
2544 : {
2545 194917394 : struct _Flxq *D = (struct _Flxq*)data;
2546 194917394 : return Flxq_sqr(x, D->T, D->p);
2547 : }
2548 : static GEN
2549 112030926 : _Flxq_mul(void *data, GEN x, GEN y)
2550 : {
2551 112030926 : struct _Flxq *D = (struct _Flxq*)data;
2552 112030926 : return Flxq_mul(x,y, D->T, D->p);
2553 : }
2554 : static GEN
2555 9170314 : _Flxq_one(void *data)
2556 : {
2557 9170314 : struct _Flxq *D = (struct _Flxq*)data;
2558 9170314 : return pol1_Flx(get_Flx_var(D->T));
2559 : }
2560 : static GEN
2561 188468 : _Flxq_zero(void *data)
2562 : {
2563 188468 : struct _Flxq *D = (struct _Flxq*)data;
2564 188468 : return pol0_Flx(get_Flx_var(D->T));
2565 : }
2566 : static GEN
2567 20745190 : _Flxq_cmul(void *data, GEN P, long a, GEN x)
2568 : {
2569 20745190 : struct _Flxq *D = (struct _Flxq*)data;
2570 20745190 : return Flx_Fl_mul(x, P[a+2], D->p);
2571 : }
2572 :
2573 : /* n-Power of x in Z/pZ[X]/(T), as t_VECSMALL. */
2574 : GEN
2575 11070179 : Flxq_powu(GEN x, ulong n, GEN T, ulong p)
2576 : {
2577 11070179 : pari_sp av = avma;
2578 : struct _Flxq D;
2579 : GEN y;
2580 11070179 : switch(n)
2581 : {
2582 0 : case 0: return pol1_Flx(T[1]);
2583 32561 : case 1: return Flx_copy(x);
2584 118551 : case 2: return Flxq_sqr(x, T, p);
2585 : }
2586 10919067 : D.T = Flx_get_red(T, p); D.p = p;
2587 10917525 : y = gen_powu_i(x, n, (void*)&D, &_Flxq_sqr, &_Flxq_mul);
2588 10916469 : return gerepileuptoleaf(av, y);
2589 : }
2590 :
2591 : /* n-Power of x in Z/pZ[X]/(T), as t_VECSMALL. */
2592 : GEN
2593 24350849 : Flxq_pow(GEN x, GEN n, GEN T, ulong p)
2594 : {
2595 24350849 : pari_sp av = avma;
2596 : struct _Flxq D;
2597 : GEN y;
2598 24350849 : long s = signe(n);
2599 24350849 : if (!s) return pol1_Flx(get_Flx_var(T));
2600 24159394 : if (s < 0)
2601 586524 : x = Flxq_inv(x,T,p);
2602 24159394 : if (is_pm1(n)) return s < 0 ? x : Flx_copy(x);
2603 23382072 : D.T = Flx_get_red(T, p); D.p = p;
2604 23382006 : y = gen_pow_i(x, n, (void*)&D, &_Flxq_sqr, &_Flxq_mul);
2605 23381864 : return gerepileuptoleaf(av, y);
2606 : }
2607 :
2608 : /* Inverse of x in Z/lZ[X]/(T) or NULL if inverse doesn't exist
2609 : * not stack clean.
2610 : */
2611 : GEN
2612 3442335 : Flxq_invsafe(GEN x, GEN T, ulong p)
2613 : {
2614 3442335 : GEN V, z = Flx_extgcd(get_Flx_mod(T), x, p, NULL, &V);
2615 : ulong iz;
2616 3442335 : if (degpol(z)) return NULL;
2617 3442307 : iz = Fl_inv (uel(z,2), p);
2618 3442307 : return Flx_Fl_mul(V, iz, p);
2619 : }
2620 :
2621 : GEN
2622 3403204 : Flxq_inv(GEN x,GEN T,ulong p)
2623 : {
2624 3403204 : pari_sp av=avma;
2625 3403204 : GEN U = Flxq_invsafe(x, T, p);
2626 3403204 : if (!U) pari_err_INV("Flxq_inv",Flx_to_ZX(x));
2627 3403176 : return gerepileuptoleaf(av, U);
2628 : }
2629 :
2630 : GEN
2631 1824536 : Flxq_div(GEN x,GEN y,GEN T,ulong p)
2632 : {
2633 1824536 : pari_sp av = avma;
2634 1824536 : return gerepileuptoleaf(av, Flxq_mul(x,Flxq_inv(y,T,p),T,p));
2635 : }
2636 :
2637 : GEN
2638 2493909 : Flxq_powers(GEN x, long l, GEN T, ulong p)
2639 : {
2640 : struct _Flxq D;
2641 2493909 : int use_sqr = 2*degpol(x) >= get_Flx_degree(T);
2642 2493909 : D.T = Flx_get_red(T, p); D.p = p;
2643 2493909 : return gen_powers(x, l, use_sqr, (void*)&D, &_Flxq_sqr, &_Flxq_mul, &_Flxq_one);
2644 : }
2645 :
2646 : GEN
2647 301774 : Flxq_matrix_pow(GEN y, long n, long m, GEN P, ulong l)
2648 : {
2649 301774 : return FlxV_to_Flm(Flxq_powers(y,m-1,P,l),n);
2650 : }
2651 :
2652 : GEN
2653 3618868 : Flx_Frobenius(GEN T, ulong p)
2654 : {
2655 3618868 : return Flxq_powu(polx_Flx(get_Flx_var(T)), p, T, p);
2656 : }
2657 :
2658 : GEN
2659 292450 : Flx_matFrobenius(GEN T, ulong p)
2660 : {
2661 292450 : long n = get_Flx_degree(T);
2662 292450 : return Flxq_matrix_pow(Flx_Frobenius(T, p), n, n, T, p);
2663 : }
2664 :
2665 : static struct bb_algebra Flxq_algebra = { _Flxq_red, _Flx_add, _Flx_sub,
2666 : _Flxq_mul, _Flxq_sqr, _Flxq_one, _Flxq_zero};
2667 :
2668 : GEN
2669 2768365 : Flx_FlxqV_eval(GEN Q, GEN x, GEN T, ulong p)
2670 : {
2671 : struct _Flxq D;
2672 2768365 : D.T = Flx_get_red(T, p); D.p=p;
2673 2768365 : return gen_bkeval_powers(Q,degpol(Q),x,(void*)&D,&Flxq_algebra,_Flxq_cmul);
2674 : }
2675 :
2676 : GEN
2677 694660 : Flx_Flxq_eval(GEN Q, GEN x, GEN T, ulong p)
2678 : {
2679 694660 : int use_sqr = 2*degpol(x) >= get_Flx_degree(T);
2680 : struct _Flxq D;
2681 694660 : D.T = Flx_get_red(T, p); D.p=p;
2682 694660 : return gen_bkeval(Q,degpol(Q),x,use_sqr,(void*)&D,&Flxq_algebra,_Flxq_cmul);
2683 : }
2684 :
2685 : static GEN
2686 376686 : Flxq_autpow_sqr(void *E, GEN x)
2687 : {
2688 376686 : struct _Flxq *D = (struct _Flxq*)E;
2689 376686 : return Flx_Flxq_eval(x, x, D->T, D->p);
2690 : }
2691 : static GEN
2692 20454 : Flxq_autpow_mul(void *E, GEN x, GEN y)
2693 : {
2694 20454 : struct _Flxq *D = (struct _Flxq*)E;
2695 20454 : return Flx_Flxq_eval(x, y, D->T, D->p);
2696 : }
2697 :
2698 : GEN
2699 303788 : Flxq_autpow(GEN x, ulong n, GEN T, ulong p)
2700 : {
2701 : struct _Flxq D;
2702 303788 : D.T = Flx_get_red(T, p); D.p = p;
2703 303788 : if (n==0) return polx_Flx(T[1]);
2704 303788 : if (n==1) return Flx_copy(x);
2705 303319 : return gen_powu(x,n,(void*)&D,Flxq_autpow_sqr,Flxq_autpow_mul);
2706 : }
2707 :
2708 : static GEN
2709 610088 : Flxq_autsum_mul(void *E, GEN x, GEN y)
2710 : {
2711 610088 : struct _Flxq *D = (struct _Flxq*)E;
2712 610088 : GEN T = D->T;
2713 610088 : ulong p = D->p;
2714 610088 : GEN phi1 = gel(x,1), a1 = gel(x,2);
2715 610088 : GEN phi2 = gel(y,1), a2 = gel(y,2);
2716 610088 : ulong d = brent_kung_optpow(maxss(degpol(phi1),degpol(a1)),2,1);
2717 610088 : GEN V2 = Flxq_powers(phi2, d, T, p);
2718 610088 : GEN phi3 = Flx_FlxqV_eval(phi1, V2, T, p);
2719 610088 : GEN aphi = Flx_FlxqV_eval(a1, V2, T, p);
2720 610088 : GEN a3 = Flxq_mul(aphi, a2, T, p);
2721 610088 : return mkvec2(phi3, a3);
2722 : }
2723 : static GEN
2724 363460 : Flxq_autsum_sqr(void *E, GEN x)
2725 363460 : { return Flxq_autsum_mul(E, x, x); }
2726 :
2727 : GEN
2728 306359 : Flxq_autsum(GEN x, ulong n, GEN T, ulong p)
2729 : {
2730 : struct _Flxq D;
2731 306359 : D.T = Flx_get_red(T, p); D.p = p;
2732 306359 : return gen_powu(x,n,(void*)&D,Flxq_autsum_sqr,Flxq_autsum_mul);
2733 : }
2734 :
2735 : static GEN
2736 57630 : Flxq_auttrace_mul(void *E, GEN x, GEN y)
2737 : {
2738 57630 : struct _Flxq *D = (struct _Flxq*)E;
2739 57630 : GEN T = D->T;
2740 57630 : ulong p = D->p;
2741 57630 : GEN phi1 = gel(x,1), a1 = gel(x,2);
2742 57630 : GEN phi2 = gel(y,1), a2 = gel(y,2);
2743 57630 : ulong d = brent_kung_optpow(maxss(degpol(phi1),degpol(a1)),2,1);
2744 57630 : GEN V1 = Flxq_powers(phi1, d, T, p);
2745 57630 : GEN phi3 = Flx_FlxqV_eval(phi2, V1, T, p);
2746 57630 : GEN aphi = Flx_FlxqV_eval(a2, V1, T, p);
2747 57630 : GEN a3 = Flx_add(a1, aphi, p);
2748 57630 : return mkvec2(phi3, a3);
2749 : }
2750 :
2751 : static GEN
2752 45947 : Flxq_auttrace_sqr(void *E, GEN x)
2753 45947 : { return Flxq_auttrace_mul(E, x, x); }
2754 :
2755 : GEN
2756 43431 : Flxq_auttrace(GEN x, ulong n, GEN T, ulong p)
2757 : {
2758 : struct _Flxq D;
2759 43431 : D.T = Flx_get_red(T, p); D.p = p;
2760 43431 : return gen_powu(x,n,(void*)&D,Flxq_auttrace_sqr,Flxq_auttrace_mul);
2761 : }
2762 :
2763 : static long
2764 660803 : bounded_order(ulong p, GEN b, long k)
2765 : {
2766 : long i;
2767 660803 : GEN a=modii(utoi(p),b);
2768 1677057 : for(i=1;i<k;i++)
2769 : {
2770 1390311 : if (equali1(a))
2771 374057 : return i;
2772 1016254 : a = modii(muliu(a,p),b);
2773 : }
2774 286746 : return 0;
2775 : }
2776 :
2777 : /*
2778 : n = (p^d-a)\b
2779 : b = bb*p^vb
2780 : p^k = 1 [bb]
2781 : d = m*k+r+vb
2782 : u = (p^k-1)/bb;
2783 : v = (p^(r+vb)-a)/b;
2784 : w = (p^(m*k)-1)/(p^k-1)
2785 : n = p^r*w*u+v
2786 : w*u = p^vb*(p^(m*k)-1)/b
2787 : n = p^(r+vb)*(p^(m*k)-1)/b+(p^(r+vb)-a)/b
2788 : */
2789 :
2790 : static GEN
2791 23770317 : Flxq_pow_Frobenius(GEN x, GEN n, GEN aut, GEN T, ulong p)
2792 : {
2793 23770317 : pari_sp av=avma;
2794 23770317 : long d = get_Flx_degree(T);
2795 23770317 : GEN an = absi(n), z, q;
2796 23770317 : if (abscmpiu(an,p)<0 || cmpis(an,d)<=0)
2797 23108751 : return Flxq_pow(x, n, T, p);
2798 661566 : q = powuu(p, d);
2799 661566 : if (dvdii(q, n))
2800 : {
2801 756 : long vn = logint(an,utoi(p));
2802 756 : GEN autvn = vn==1 ? aut: Flxq_autpow(aut,vn,T,p);
2803 756 : z = Flx_Flxq_eval(x,autvn,T,p);
2804 : } else
2805 : {
2806 660810 : GEN b = diviiround(q, an), a = subii(q, mulii(an,b));
2807 : GEN bb, u, v, autk;
2808 660810 : long vb = Z_lvalrem(b,p,&bb);
2809 660810 : long m, r, k = is_pm1(bb) ? 1 : bounded_order(p,bb,d);
2810 660810 : if (!k || d-vb<k) return Flxq_pow(x,n, T, p);
2811 374057 : m = (d-vb)/k; r = (d-vb)%k;
2812 374057 : u = diviiexact(subiu(powuu(p,k),1),bb);
2813 374057 : v = diviiexact(subii(powuu(p,r+vb),a),b);
2814 374057 : autk = k==1 ? aut: Flxq_autpow(aut,k,T,p);
2815 374057 : if (r)
2816 : {
2817 93382 : GEN autr = r==1 ? aut: Flxq_autpow(aut,r,T,p);
2818 93382 : z = Flx_Flxq_eval(x,autr,T,p);
2819 280675 : } else z = x;
2820 374057 : if (m > 1) z = gel(Flxq_autsum(mkvec2(autk, z), m, T, p), 2);
2821 374057 : if (!is_pm1(u)) z = Flxq_pow(z, u, T, p);
2822 374057 : if (signe(v)) z = Flxq_mul(z, Flxq_pow(x, v, T, p), T, p);
2823 : }
2824 374813 : return gerepileupto(av,signe(n)>0 ? z : Flxq_inv(z,T,p));
2825 : }
2826 :
2827 : static GEN
2828 23751746 : _Flxq_pow(void *data, GEN x, GEN n)
2829 : {
2830 23751746 : struct _Flxq *D = (struct _Flxq*)data;
2831 23751746 : return Flxq_pow_Frobenius(x, n, D->aut, D->T, D->p);
2832 : }
2833 :
2834 : static GEN
2835 314776 : _Flxq_rand(void *data)
2836 : {
2837 314776 : pari_sp av=avma;
2838 314776 : struct _Flxq *D = (struct _Flxq*)data;
2839 : GEN z;
2840 : do
2841 : {
2842 317597 : avma = av;
2843 317597 : z = random_Flx(get_Flx_degree(D->T),get_Flx_var(D->T),D->p);
2844 317597 : } while (lgpol(z)==0);
2845 314776 : return z;
2846 : }
2847 :
2848 : /* discrete log in FpXQ for a in Fp^*, g in FpXQ^* of order ord */
2849 : static GEN
2850 10955 : Fl_Flxq_log(ulong a, GEN g, GEN o, GEN T, ulong p)
2851 : {
2852 10955 : pari_sp av = avma;
2853 : GEN q,n_q,ord,ordp, op;
2854 :
2855 10955 : if (a == 1UL) return gen_0;
2856 : /* p > 2 */
2857 :
2858 10955 : ordp = utoi(p - 1);
2859 10955 : ord = get_arith_Z(o);
2860 10955 : if (!ord) ord = T? subiu(powuu(p, get_FpX_degree(T)), 1): ordp;
2861 10955 : if (a == p - 1) /* -1 */
2862 693 : return gerepileuptoint(av, shifti(ord,-1));
2863 10262 : ordp = gcdii(ordp, ord);
2864 10262 : op = typ(o)==t_MAT ? famat_Z_gcd(o, ordp) : ordp;
2865 :
2866 10262 : q = NULL;
2867 10262 : if (T)
2868 : { /* we want < g > = Fp^* */
2869 10262 : if (!equalii(ord,ordp)) {
2870 547 : q = diviiexact(ord,ordp);
2871 547 : g = Flxq_pow(g,q,T,p);
2872 : }
2873 : }
2874 10262 : n_q = Fp_log(utoi(a), utoi(uel(g,2)), op, utoi(p));
2875 10262 : if (lg(n_q)==1) return gerepileuptoleaf(av, n_q);
2876 10262 : if (q) n_q = mulii(q, n_q);
2877 10262 : return gerepileuptoint(av, n_q);
2878 : }
2879 :
2880 : static GEN
2881 321523 : Flxq_easylog(void* E, GEN a, GEN g, GEN ord)
2882 : {
2883 321523 : struct _Flxq *f = (struct _Flxq *)E;
2884 321523 : GEN T = f->T;
2885 321523 : ulong p = f->p;
2886 321523 : long d = get_Flx_degree(T);
2887 321523 : if (Flx_equal1(a)) return gen_0;
2888 270002 : if (Flx_equal(a,g)) return gen_1;
2889 59654 : if (!degpol(a))
2890 10955 : return Fl_Flxq_log(uel(a,2), g, ord, T, p);
2891 48699 : if (typ(ord)!=t_INT || d <= 4 || d == 6 || abscmpiu(ord,1UL<<27)<0)
2892 48678 : return NULL;
2893 21 : return Flxq_log_index(a, g, ord, T, p);
2894 : }
2895 :
2896 : int
2897 25679878 : Flx_equal(GEN V, GEN W)
2898 : {
2899 25679878 : long l = lg(V);
2900 25679878 : if (lg(W) != l) return 0;
2901 51071796 : while (--l > 1) /* do not compare variables, V[1] */
2902 25447092 : if (V[l] != W[l]) return 0;
2903 602798 : return 1;
2904 : }
2905 :
2906 : static const struct bb_group Flxq_star={_Flxq_mul,_Flxq_pow,_Flxq_rand,hash_GEN,Flx_equal,Flx_equal1,Flxq_easylog};
2907 :
2908 : const struct bb_group *
2909 210482 : get_Flxq_star(void **E, GEN T, ulong p)
2910 : {
2911 210482 : struct _Flxq *e = (struct _Flxq *) stack_malloc(sizeof(struct _Flxq));
2912 210482 : e->T = T; e->p = p; e->aut = Flx_Frobenius(T, p);
2913 210482 : *E = (void*)e; return &Flxq_star;
2914 : }
2915 :
2916 : GEN
2917 12296 : Flxq_order(GEN a, GEN ord, GEN T, ulong p)
2918 : {
2919 : void *E;
2920 12296 : const struct bb_group *S = get_Flxq_star(&E,T,p);
2921 12296 : return gen_order(a,ord,E,S);
2922 : }
2923 :
2924 : GEN
2925 35174 : Flxq_log(GEN a, GEN g, GEN ord, GEN T, ulong p)
2926 : {
2927 : void *E;
2928 35174 : pari_sp av = avma;
2929 35174 : const struct bb_group *S = get_Flxq_star(&E,T,p);
2930 35174 : GEN v = get_arith_ZZM(ord), F = gmael(v,2,1);
2931 35174 : if (Flxq_log_use_index(gel(F,lg(F)-1), T, p))
2932 9261 : v = mkvec2(gel(v, 1), ZM_famat_limit(gel(v, 2), int2n(27)));
2933 35174 : return gerepileuptoleaf(av, gen_PH_log(a, g, v, E, S));
2934 : }
2935 :
2936 : GEN
2937 164825 : Flxq_sqrtn(GEN a, GEN n, GEN T, ulong p, GEN *zeta)
2938 : {
2939 164825 : if (!lgpol(a))
2940 : {
2941 1813 : if (signe(n) < 0) pari_err_INV("Flxq_sqrtn",a);
2942 1806 : if (zeta)
2943 0 : *zeta=pol1_Flx(get_Flx_var(T));
2944 1806 : return pol0_Flx(get_Flx_var(T));
2945 : }
2946 : else
2947 : {
2948 : void *E;
2949 163012 : pari_sp av = avma;
2950 163012 : const struct bb_group *S = get_Flxq_star(&E,T,p);
2951 163012 : GEN o = subiu(powuu(p,get_Flx_degree(T)), 1);
2952 163012 : GEN s = gen_Shanks_sqrtn(a,n,o,zeta,E,S);
2953 163012 : if (s) gerepileall(av, zeta?2:1, &s, zeta);
2954 163012 : return s;
2955 : }
2956 : }
2957 :
2958 : GEN
2959 157430 : Flxq_sqrt(GEN a, GEN T, ulong p)
2960 : {
2961 157430 : return Flxq_sqrtn(a, gen_2, T, p, NULL);
2962 : }
2963 :
2964 : /* assume T irreducible mod p */
2965 : int
2966 352195 : Flxq_issquare(GEN x, GEN T, ulong p)
2967 : {
2968 352195 : if (lgpol(x) == 0 || p == 2) return 1;
2969 350242 : return krouu(Flxq_norm(x,T,p), p) == 1;
2970 : }
2971 :
2972 : /* assume T irreducible mod p */
2973 : int
2974 280 : Flxq_is2npower(GEN x, long n, GEN T, ulong p)
2975 : {
2976 : pari_sp av;
2977 : GEN m;
2978 : int z;
2979 280 : if (n==1) return Flxq_issquare(x, T, p);
2980 280 : if (lgpol(x) == 0 || p == 2) return 1;
2981 280 : av = avma;
2982 280 : m = shifti(subiu(powuu(p, get_Flx_degree(T)), 1), -n);
2983 280 : z = Flx_equal1(Flxq_pow(x, m, T, p));
2984 280 : avma = av; return z;
2985 : }
2986 :
2987 : GEN
2988 113505 : Flxq_lroot_fast(GEN a, GEN sqx, GEN T, long p)
2989 : {
2990 113505 : pari_sp av=avma;
2991 113505 : GEN A = Flx_splitting(a,p);
2992 113505 : return gerepileuptoleaf(av, FlxqV_dotproduct(A,sqx,T,p));
2993 : }
2994 :
2995 : GEN
2996 25032 : Flxq_lroot(GEN a, GEN T, long p)
2997 : {
2998 25032 : pari_sp av=avma;
2999 25032 : long n = get_Flx_degree(T), d = degpol(a);
3000 : GEN sqx, V;
3001 25032 : if (n==1) return leafcopy(a);
3002 25032 : if (n==2) return Flxq_powu(a, p, T, p);
3003 25032 : sqx = Flxq_autpow(Flx_Frobenius(T, p), n-1, T, p);
3004 25032 : if (d==1 && a[2]==0 && a[3]==1) return gerepileuptoleaf(av, sqx);
3005 0 : if (d>=p)
3006 : {
3007 0 : V = Flxq_powers(sqx,p-1,T,p);
3008 0 : return gerepileuptoleaf(av, Flxq_lroot_fast(a,V,T,p));
3009 : } else
3010 0 : return gerepileuptoleaf(av, Flx_Flxq_eval(a,sqx,T,p));
3011 : }
3012 :
3013 : ulong
3014 379862 : Flxq_norm(GEN x, GEN TB, ulong p)
3015 : {
3016 379862 : GEN T = get_Flx_mod(TB);
3017 379862 : ulong y = Flx_resultant(T, x, p);
3018 379862 : ulong L = Flx_lead(T);
3019 379862 : if ( L==1 || lgpol(x)==0) return y;
3020 0 : return Fl_div(y, Fl_powu(L, (ulong)degpol(x), p), p);
3021 : }
3022 :
3023 : ulong
3024 3114 : Flxq_trace(GEN x, GEN TB, ulong p)
3025 : {
3026 3114 : pari_sp av = avma;
3027 : ulong t;
3028 3114 : GEN T = get_Flx_mod(TB);
3029 3114 : long n = degpol(T)-1;
3030 3114 : GEN z = Flxq_mul(x, Flx_deriv(T, p), TB, p);
3031 3114 : t = degpol(z)<n ? 0 : Fl_div(z[2+n],T[3+n],p);
3032 3114 : avma=av;
3033 3114 : return t;
3034 : }
3035 :
3036 : /*x must be reduced*/
3037 : GEN
3038 27 : Flxq_charpoly(GEN x, GEN TB, ulong p)
3039 : {
3040 27 : pari_sp ltop=avma;
3041 27 : GEN T = get_Flx_mod(TB);
3042 27 : long vs = evalvarn(fetch_var());
3043 27 : GEN xm1 = deg1pol_shallow(pol1_Flx(x[1]),Flx_neg(x,p),vs);
3044 27 : GEN r = Flx_FlxY_resultant(T, xm1, p);
3045 27 : r[1] = x[1];
3046 27 : (void)delete_var(); return gerepileupto(ltop, r);
3047 : }
3048 :
3049 : /* Computing minimal polynomial : */
3050 : /* cf Shoup 'Efficient Computation of Minimal Polynomials */
3051 : /* in Algebraic Extensions of Finite Fields' */
3052 :
3053 : GEN
3054 139628 : Flxn_mul(GEN a, GEN b, long n, ulong p)
3055 : {
3056 139628 : GEN c = Flx_mul(a, b, p);
3057 139628 : return vecsmall_shorten(c, minss(lg(c)-1,n+1));
3058 : }
3059 :
3060 : /* Let v a linear form, return the linear form z->v(tau*z)
3061 : that is, v*(M_tau) */
3062 :
3063 : static GEN
3064 60112 : Flxq_transmul_init(GEN tau, GEN T, ulong p)
3065 : {
3066 : GEN bht;
3067 60112 : GEN h, Tp = get_Flx_red(T, &h);
3068 60112 : long n = degpol(Tp), vT = Tp[1];
3069 60112 : GEN ft = Flx_recipspec(Tp+2, n+1, n+1);
3070 60112 : GEN bt = Flx_recipspec(tau+2, lgpol(tau), n);
3071 60112 : ft[1] = vT; bt[1] = vT;
3072 60112 : if (h)
3073 710 : bht = Flxn_mul(bt, h, n-1, p);
3074 : else
3075 : {
3076 59402 : GEN bh = Flx_div(Flx_shift(tau, n-1), T, p);
3077 59402 : bht = Flx_recipspec(bh+2, lgpol(bh), n-1);
3078 59402 : bht[1] = vT;
3079 : }
3080 60112 : return mkvec3(bt, bht, ft);
3081 : }
3082 :
3083 : static GEN
3084 152870 : Flxq_transmul(GEN tau, GEN a, long n, ulong p)
3085 : {
3086 152870 : pari_sp ltop = avma;
3087 : GEN t1, t2, t3, vec;
3088 152870 : GEN bt = gel(tau, 1), bht = gel(tau, 2), ft = gel(tau, 3);
3089 152870 : if (lgpol(a)==0) return pol0_Flx(a[1]);
3090 149012 : t2 = Flx_shift(Flx_mul(bt, a, p),1-n);
3091 149012 : if (lgpol(bht)==0) return gerepileuptoleaf(ltop, t2);
3092 93705 : t1 = Flx_shift(Flx_mul(ft, a, p),-n);
3093 93705 : t3 = Flxn_mul(t1, bht, n-1, p);
3094 93705 : vec = Flx_sub(t2, Flx_shift(t3, 1), p);
3095 93705 : return gerepileuptoleaf(ltop, vec);
3096 : }
3097 :
3098 : GEN
3099 25330 : Flxq_minpoly(GEN x, GEN T, ulong p)
3100 : {
3101 25330 : pari_sp ltop = avma;
3102 25330 : long vT = get_Flx_var(T), n = get_Flx_degree(T);
3103 : GEN v_x;
3104 25330 : GEN g = pol1_Flx(vT), tau = pol1_Flx(vT);
3105 25330 : T = Flx_get_red(T, p);
3106 25330 : v_x = Flxq_powers(x, usqrt(2*n), T, p);
3107 80716 : while (lgpol(tau) != 0)
3108 : {
3109 : long i, j, m, k1;
3110 : GEN M, v, tr;
3111 : GEN g_prime, c;
3112 30056 : if (degpol(g) == n) { tau = pol1_Flx(vT); g = pol1_Flx(vT); }
3113 30056 : v = random_Flx(n, vT, p);
3114 30056 : tr = Flxq_transmul_init(tau, T, p);
3115 30056 : v = Flxq_transmul(tr, v, n, p);
3116 30056 : m = 2*(n-degpol(g));
3117 30056 : k1 = usqrt(m);
3118 30056 : tr = Flxq_transmul_init(gel(v_x,k1+1), T, p);
3119 30056 : c = cgetg(m+2,t_VECSMALL);
3120 30056 : c[1] = T[1];
3121 152870 : for (i=0; i<m; i+=k1)
3122 : {
3123 122814 : long mj = minss(m-i, k1);
3124 522678 : for (j=0; j<mj; j++)
3125 399864 : uel(c,m+1-(i+j)) = Flx_dotproduct(v, gel(v_x,j+1), p);
3126 122814 : v = Flxq_transmul(tr, v, n, p);
3127 : }
3128 30056 : c = Flx_renormalize(c, m+2);
3129 : /* now c contains <v,x^i> , i = 0..m-1 */
3130 30056 : M = Flx_halfgcd(monomial_Flx(1, m, vT), c, p);
3131 30056 : g_prime = gmael(M, 2, 2);
3132 30056 : if (degpol(g_prime) < 1) continue;
3133 28418 : g = Flx_mul(g, g_prime, p);
3134 28418 : tau = Flxq_mul(tau, Flx_FlxqV_eval(g_prime, v_x, T, p), T, p);
3135 : }
3136 25330 : g = Flx_normalize(g,p);
3137 25330 : return gerepileuptoleaf(ltop,g);
3138 : }
3139 :
3140 : /* return (x % X^n). Shallow */
3141 : static GEN
3142 1162 : Flxn_red_shallow(GEN a, long n)
3143 : {
3144 1162 : long i, L, l = lg(a);
3145 : GEN b;
3146 1162 : if (l == 2 || !n) return zero_Flx(a[1]);
3147 1162 : L = n+2; if (L > l) L = l;
3148 1162 : b = cgetg(L, t_POL); b[1] = a[1];
3149 1162 : for (i=2; i<L; i++) b[i] = a[i];
3150 1162 : return Flx_renormalize(b,L);
3151 : }
3152 : GEN
3153 210 : Flxn_inv(GEN f, long e, ulong p)
3154 : {
3155 210 : pari_sp av = avma, av2;
3156 : ulong mask;
3157 : GEN W;
3158 210 : long n=1;
3159 210 : if (lg(f)==2) pari_err_INV("Flxn_inv",f);
3160 210 : W = Fl_to_Flx(Fl_inv(f[2],p), f[1]);
3161 210 : mask = quadratic_prec_mask(e);
3162 210 : av2 = avma;
3163 1582 : for (;mask>1;)
3164 : {
3165 : GEN u, fr;
3166 1162 : long n2 = n;
3167 1162 : n<<=1; if (mask & 1) n--;
3168 1162 : mask >>= 1;
3169 1162 : fr = Flxn_red_shallow(f, n);
3170 1162 : u = Flx_shift(Flxn_mul(W, fr, n, p), -n2);
3171 1162 : W = Flx_sub(W, Flx_shift(Flxn_mul(u, W, n-n2, p), n2), p);
3172 1162 : if (gc_needed(av2,2))
3173 : {
3174 0 : if(DEBUGMEM>1) pari_warn(warnmem,"RgXn_inv, e = %ld", n);
3175 0 : W = gerepileupto(av2, W);
3176 : }
3177 : }
3178 210 : return gerepileupto(av, W);
3179 : }
3180 :
3181 : GEN
3182 20 : Flxq_conjvec(GEN x, GEN T, ulong p)
3183 : {
3184 20 : long i, l = 1+get_Flx_degree(T);
3185 20 : GEN z = cgetg(l,t_COL);
3186 20 : T = Flx_get_red(T,p);
3187 20 : gel(z,1) = Flx_copy(x);
3188 20 : for (i=2; i<l; i++) gel(z,i) = Flxq_powu(gel(z,i-1), p, T, p);
3189 20 : return z;
3190 : }
3191 :
3192 : GEN
3193 9196 : gener_Flxq(GEN T, ulong p, GEN *po)
3194 : {
3195 : long i, j;
3196 9196 : long vT = get_Flx_var(T), f =get_Flx_degree(T);
3197 : ulong p_1;
3198 : GEN g, L, L2, o, q, F;
3199 : pari_sp av0, av;
3200 :
3201 9196 : if (f == 1) {
3202 : GEN fa;
3203 28 : o = utoipos(p-1);
3204 28 : fa = Z_factor(o);
3205 28 : L = gel(fa,1);
3206 28 : L = vecslice(L, 2, lg(L)-1); /* remove 2 for efficiency */
3207 28 : g = Fl_to_Flx(pgener_Fl_local(p, vec_to_vecsmall(L)), vT);
3208 28 : if (po) *po = mkvec2(o, fa);
3209 28 : return g;
3210 : }
3211 :
3212 9168 : av0 = avma; p_1 = p - 1;
3213 9168 : q = diviuexact(subiu(powuu(p,f), 1), p_1);
3214 :
3215 9168 : L = cgetg(1, t_VECSMALL);
3216 9168 : if (p > 3)
3217 : {
3218 : ulong t;
3219 1111 : (void)u_lvalrem(p_1, 2, &t);
3220 1111 : L = gel(factoru(t),1);
3221 1111 : for (i=lg(L)-1; i; i--) L[i] = p_1 / L[i];
3222 : }
3223 9168 : o = factor_pn_1(utoipos(p),f);
3224 9168 : L2 = leafcopy( gel(o, 1) );
3225 25267 : for (i = j = 1; i < lg(L2); i++)
3226 : {
3227 16099 : if (umodui(p_1, gel(L2,i)) == 0) continue;
3228 13306 : gel(L2,j++) = diviiexact(q, gel(L2,i));
3229 : }
3230 9168 : setlg(L2, j);
3231 9168 : F = Flx_Frobenius(T, p);
3232 19611 : for (av = avma;; avma = av)
3233 : {
3234 : ulong RES;
3235 : GEN tt;
3236 19611 : g = random_Flx(f, vT, p);
3237 19611 : if (degpol(g) < 1) continue;
3238 15089 : if (p == 2) tt = g;
3239 : else
3240 : {
3241 4568 : ulong t = Flxq_norm(g, T, p);
3242 4568 : if (t == 1 || !is_gener_Fl(t, p, p_1, L)) continue;
3243 2632 : tt = Flxq_powu(g, p_1>>1, T, p);
3244 : }
3245 13153 : RES = p_1;
3246 27739 : for (i = 1; i < j; i++)
3247 : {
3248 18571 : GEN a = Flxq_pow_Frobenius(tt, gel(L2,i), F, T, p);
3249 18571 : if (!degpol(a) && uel(a,2) == RES) break;
3250 : }
3251 13153 : if (i == j) break;
3252 10443 : }
3253 9168 : if (!po)
3254 : {
3255 173 : avma = (pari_sp)g;
3256 173 : g = gerepileuptoleaf(av0, g);
3257 : }
3258 : else {
3259 8995 : *po = mkvec2(subiu(powuu(p,f), 1), o);
3260 8995 : gerepileall(av0, 2, &g, po);
3261 : }
3262 9168 : return g;
3263 : }
3264 :
3265 : static GEN
3266 5887 : _Flxq_neg(void *E, GEN x)
3267 5887 : { struct _Flxq *s = (struct _Flxq *)E;
3268 5887 : return Flx_neg(x,s->p); }
3269 :
3270 : static GEN
3271 56833 : _Flxq_rmul(void *E, GEN x, GEN y)
3272 56833 : { struct _Flxq *s = (struct _Flxq *)E;
3273 56833 : return Flx_mul(x,y,s->p); }
3274 :
3275 : static GEN
3276 5544 : _Flxq_inv(void *E, GEN x)
3277 5544 : { struct _Flxq *s = (struct _Flxq *)E;
3278 5544 : return Flxq_inv(x,s->T,s->p); }
3279 :
3280 : static int
3281 29778 : _Flxq_equal0(GEN x) { return lgpol(x)==0; }
3282 :
3283 : static GEN
3284 11935 : _Flxq_s(void *E, long x)
3285 11935 : { struct _Flxq *s = (struct _Flxq *)E;
3286 11935 : ulong u = x<0 ? s->p+x: (ulong)x;
3287 11935 : return Fl_to_Flx(u, get_Flx_var(s->T));
3288 : }
3289 :
3290 : static const struct bb_field Flxq_field={_Flxq_red,_Flx_add,_Flxq_rmul,_Flxq_neg,
3291 : _Flxq_inv,_Flxq_equal0,_Flxq_s};
3292 :
3293 5796 : const struct bb_field *get_Flxq_field(void **E, GEN T, ulong p)
3294 : {
3295 5796 : GEN z = new_chunk(sizeof(struct _Flxq));
3296 5796 : struct _Flxq *e = (struct _Flxq *) z;
3297 5796 : e->T = Flx_get_red(T, p); e->p = p; *E = (void*)e;
3298 5796 : return &Flxq_field;
3299 : }
3300 :
3301 : /***********************************************************************/
3302 : /** **/
3303 : /** Fl2 **/
3304 : /** **/
3305 : /***********************************************************************/
3306 : /* Fl2 objects are Flv of length 2 [a,b] representing a+bsqrt(D) for
3307 : a non-square D.
3308 : */
3309 :
3310 : INLINE GEN
3311 10816160 : mkF2(ulong a, ulong b) { return mkvecsmall2(a,b); }
3312 :
3313 : GEN
3314 2890686 : Fl2_mul_pre(GEN x, GEN y, ulong D, ulong p, ulong pi)
3315 : {
3316 : ulong xaya, xbyb, Db2, mid;
3317 : ulong z1, z2;
3318 2890686 : ulong x1 = x[1], x2 = x[2], y1 = y[1], y2 = y[2];
3319 2890686 : xaya = Fl_mul_pre(x1,y1,p,pi);
3320 2890750 : if (x2==0 && y2==0) return mkF2(xaya,0);
3321 2746853 : if (x2==0) return mkF2(xaya,Fl_mul_pre(x1,y2,p,pi));
3322 2711906 : if (y2==0) return mkF2(xaya,Fl_mul_pre(x2,y1,p,pi));
3323 2711641 : xbyb = Fl_mul_pre(x2,y2,p,pi);
3324 2711634 : mid = Fl_mul_pre(Fl_add(x1,x2,p), Fl_add(y1,y2,p),p,pi);
3325 2711647 : Db2 = Fl_mul_pre(D, xbyb, p,pi);
3326 2711670 : z1 = Fl_add(xaya,Db2,p);
3327 2711649 : z2 = Fl_sub(mid,Fl_add(xaya,xbyb,p),p);
3328 2711616 : return mkF2(z1,z2);
3329 : }
3330 :
3331 : GEN
3332 7355190 : Fl2_sqr_pre(GEN x, ulong D, ulong p, ulong pi)
3333 : {
3334 7355190 : ulong a = x[1], b = x[2];
3335 : ulong a2, Db2, ab;
3336 7355190 : a2 = Fl_sqr_pre(a,p,pi);
3337 7355530 : if (b==0) return mkF2(a2,0);
3338 6947519 : Db2= Fl_mul_pre(D, Fl_sqr_pre(b,p,pi), p,pi);
3339 6947539 : ab = Fl_mul_pre(a,b,p,pi);
3340 6947554 : return mkF2(Fl_add(a2,Db2,p), Fl_double(ab,p));
3341 : }
3342 :
3343 : ulong
3344 106939 : Fl2_norm_pre(GEN x, ulong D, ulong p, ulong pi)
3345 : {
3346 106939 : ulong a2 = Fl_sqr_pre(x[1],p,pi);
3347 106939 : return x[2]? Fl_sub(a2, Fl_mul_pre(D, Fl_sqr_pre(x[2], p,pi), p,pi), p): a2;
3348 : }
3349 :
3350 : GEN
3351 290859 : Fl2_inv_pre(GEN x, ulong D, ulong p, ulong pi)
3352 : {
3353 : ulong n, ni;
3354 290859 : if (x[2] == 0) return mkF2(Fl_inv(x[1],p),0);
3355 225143 : n = Fl_sub(Fl_sqr_pre(x[1], p,pi),
3356 225143 : Fl_mul_pre(D, Fl_sqr_pre(x[2], p,pi), p,pi), p);
3357 225141 : ni = Fl_inv(n,p);
3358 225142 : return mkF2(Fl_mul_pre(x[1], ni, p,pi),
3359 225142 : Fl_neg(Fl_mul_pre(x[2], ni, p,pi), p));
3360 : }
3361 :
3362 : int
3363 673343 : Fl2_equal1(GEN x) { return x[1]==1 && x[2]==0; }
3364 :
3365 : struct _Fl2 {
3366 : ulong p, pi, D;
3367 : };
3368 :
3369 :
3370 : static GEN
3371 7355008 : _Fl2_sqr(void *data, GEN x)
3372 : {
3373 7355008 : struct _Fl2 *D = (struct _Fl2*)data;
3374 7355008 : return Fl2_sqr_pre(x, D->D, D->p, D->pi);
3375 : }
3376 : static GEN
3377 2862916 : _Fl2_mul(void *data, GEN x, GEN y)
3378 : {
3379 2862916 : struct _Fl2 *D = (struct _Fl2*)data;
3380 2862916 : return Fl2_mul_pre(x,y, D->D, D->p, D->pi);
3381 : }
3382 :
3383 : /* n-Power of x in Z/pZ[X]/(T), as t_VECSMALL. */
3384 : GEN
3385 997898 : Fl2_pow_pre(GEN x, GEN n, ulong D, ulong p, ulong pi)
3386 : {
3387 997898 : pari_sp av = avma;
3388 : struct _Fl2 d;
3389 : GEN y;
3390 997898 : long s = signe(n);
3391 997898 : if (!s) return mkF2(1,0);
3392 890236 : if (s < 0)
3393 290859 : x = Fl2_inv_pre(x,D,p,pi);
3394 890232 : if (is_pm1(n)) return s < 0 ? x : zv_copy(x);
3395 656998 : d.p = p; d.pi = pi; d.D=D;
3396 656998 : y = gen_pow_i(x, n, (void*)&d, &_Fl2_sqr, &_Fl2_mul);
3397 657001 : return gerepileuptoleaf(av, y);
3398 : }
3399 :
3400 : static GEN
3401 997893 : _Fl2_pow(void *data, GEN x, GEN n)
3402 : {
3403 997893 : struct _Fl2 *D = (struct _Fl2*)data;
3404 997893 : return Fl2_pow_pre(x, n, D->D, D->p, D->pi);
3405 : }
3406 :
3407 : static GEN
3408 162312 : _Fl2_rand(void *data)
3409 : {
3410 162312 : struct _Fl2 *D = (struct _Fl2*)data;
3411 162312 : ulong a = random_Fl(D->p), b=random_Fl(D->p-1)+1;
3412 162312 : return mkF2(a,b);
3413 : }
3414 :
3415 : static const struct bb_group Fl2_star={_Fl2_mul, _Fl2_pow, _Fl2_rand,
3416 : hash_GEN, zv_equal, Fl2_equal1, NULL};
3417 :
3418 : GEN
3419 107663 : Fl2_sqrtn_pre(GEN a, GEN n, ulong D, ulong p, ulong pi, GEN *zeta)
3420 : {
3421 : struct _Fl2 E;
3422 : GEN o;
3423 107663 : if (a[1]==0 && a[2]==0)
3424 : {
3425 0 : if (signe(n) < 0) pari_err_INV("Flxq_sqrtn",a);
3426 0 : if (zeta) *zeta=mkF2(1,0);
3427 0 : return zv_copy(a);
3428 : }
3429 107663 : E.p=p; E.pi = pi; E.D = D;
3430 107663 : o = subiu(powuu(p,2), 1);
3431 107659 : return gen_Shanks_sqrtn(a,n,o,zeta,(void*)&E,&Fl2_star);
3432 : }
3433 :
3434 : GEN
3435 10108 : Flx_Fl2_eval_pre(GEN x, GEN y, ulong D, ulong p, ulong pi)
3436 : {
3437 : GEN p1;
3438 10108 : long i = lg(x)-1;
3439 10108 : if (i <= 2)
3440 1883 : return mkF2(i == 2? x[2]: 0, 0);
3441 8225 : p1 = mkF2(x[i], 0);
3442 35952 : for (i--; i>=2; i--)
3443 : {
3444 27727 : p1 = Fl2_mul_pre(p1, y, D, p, pi);
3445 27727 : uel(p1,1) = Fl_add(uel(p1,1), uel(x,i), p);
3446 : }
3447 8225 : return p1;
3448 : }
3449 :
3450 :
3451 : /***********************************************************************/
3452 : /** **/
3453 : /** FlxV **/
3454 : /** **/
3455 : /***********************************************************************/
3456 : /* FlxV are t_VEC with Flx coefficients. */
3457 :
3458 : GEN
3459 0 : FlxV_Flc_mul(GEN V, GEN W, ulong p)
3460 : {
3461 0 : pari_sp ltop=avma;
3462 : long i;
3463 0 : GEN z = Flx_Fl_mul(gel(V,1),W[1],p);
3464 0 : for(i=2;i<lg(V);i++)
3465 0 : z=Flx_add(z,Flx_Fl_mul(gel(V,i),W[i],p),p);
3466 0 : return gerepileuptoleaf(ltop,z);
3467 : }
3468 :
3469 : GEN
3470 0 : ZXV_to_FlxV(GEN v, ulong p)
3471 : {
3472 0 : long j, N = lg(v);
3473 0 : GEN y = cgetg(N, t_VEC);
3474 0 : for (j=1; j<N; j++) gel(y,j) = ZX_to_Flx(gel(v,j), p);
3475 0 : return y;
3476 : }
3477 :
3478 : GEN
3479 1334321 : ZXT_to_FlxT(GEN z, ulong p)
3480 : {
3481 1334321 : if (typ(z) == t_POL)
3482 1279929 : return ZX_to_Flx(z, p);
3483 : else
3484 : {
3485 54392 : long i,l = lg(z);
3486 54392 : GEN x = cgetg(l, t_VEC);
3487 54390 : for (i=1; i<l; i++) gel(x,i) = ZXT_to_FlxT(gel(z,i), p);
3488 54393 : return x;
3489 : }
3490 : }
3491 :
3492 : GEN
3493 301774 : FlxV_to_Flm(GEN v, long n)
3494 : {
3495 301774 : long j, N = lg(v);
3496 301774 : GEN y = cgetg(N, t_MAT);
3497 301774 : for (j=1; j<N; j++) gel(y,j) = Flx_to_Flv(gel(v,j), n);
3498 301774 : return y;
3499 : }
3500 :
3501 : GEN
3502 0 : FlxV_red(GEN z, ulong p)
3503 : {
3504 : GEN res;
3505 0 : long i, l = lg(z);
3506 0 : res = cgetg(l,t_VEC);
3507 0 : for(i=1;i<l;i++) gel(res,i) = Flx_red(gel(z,i),p);
3508 0 : return res;
3509 : }
3510 :
3511 : GEN
3512 312115 : FlxT_red(GEN z, ulong p)
3513 : {
3514 312115 : if (typ(z) == t_VECSMALL)
3515 209880 : return Flx_red(z, p);
3516 : else
3517 : {
3518 102235 : long i,l = lg(z);
3519 102235 : GEN x = cgetg(l, t_VEC);
3520 102227 : for (i=1; i<l; i++) gel(x,i) = FlxT_red(gel(z,i), p);
3521 102238 : return x;
3522 : }
3523 : }
3524 :
3525 : GEN
3526 113505 : FlxqV_dotproduct(GEN x, GEN y, GEN T, ulong p)
3527 : {
3528 113505 : long i, lx = lg(x);
3529 : pari_sp av;
3530 : GEN c;
3531 113505 : if (lx == 1) return gen_0;
3532 113505 : av = avma; c = Flx_mul(gel(x,1),gel(y,1), p);
3533 113505 : for (i=2; i<lx; i++) c = Flx_add(c, Flx_mul(gel(x,i),gel(y,i), p), p);
3534 113505 : return gerepileuptoleaf(av, Flx_rem(c,T,p));
3535 : }
3536 :
3537 : GEN
3538 968 : FlxqX_dotproduct(GEN x, GEN y, GEN T, ulong p)
3539 : {
3540 968 : long i, l = minss(lg(x), lg(y));
3541 : pari_sp av;
3542 : GEN c;
3543 968 : if (l == 2) return gen_0;
3544 968 : av = avma; c = Flx_mul(gel(x,2),gel(y,2), p);
3545 968 : for (i=3; i<l; i++) c = Flx_add(c, Flx_mul(gel(x,i),gel(y,i), p), p);
3546 968 : return gerepileuptoleaf(av, Flx_rem(c,T,p));
3547 : }
3548 :
3549 : GEN
3550 41416 : FlxC_eval_powers_pre(GEN z, GEN x, ulong p, ulong pi)
3551 : {
3552 41416 : long i, l = lg(z);
3553 41416 : GEN y = cgetg(l, t_VECSMALL);
3554 1363149 : for (i=1; i<l; i++)
3555 1321733 : uel(y,i) = Flx_eval_powers_pre(gel(z,i), x, p, pi);
3556 41416 : return y;
3557 : }
3558 :
3559 : /***********************************************************************/
3560 : /** **/
3561 : /** FlxM **/
3562 : /** **/
3563 : /***********************************************************************/
3564 :
3565 : GEN
3566 6948 : FlxM_eval_powers_pre(GEN z, GEN x, ulong p, ulong pi)
3567 : {
3568 6948 : long i, l = lg(z);
3569 6948 : GEN y = cgetg(l, t_MAT);
3570 48364 : for (i=1; i<l; i++)
3571 41416 : gel(y,i) = FlxC_eval_powers_pre(gel(z,i), x, p, pi);
3572 6948 : return y;
3573 : }
3574 :
3575 : GEN
3576 2590 : zero_FlxC(long n, long sv)
3577 : {
3578 : long i;
3579 2590 : GEN x = cgetg(n + 1, t_COL);
3580 2590 : GEN z = zero_Flx(sv);
3581 12299 : for (i = 1; i <= n; i++)
3582 9709 : gel(x, i) = z;
3583 2590 : return x;
3584 : }
3585 :
3586 : GEN
3587 5481 : FlxC_neg(GEN x, ulong p)
3588 : {
3589 5481 : long i, l = lg(x);
3590 5481 : GEN z = cgetg(l, t_COL);
3591 17836 : for (i = 1; i < l; i++)
3592 12355 : gel(z, i) = Flx_neg(gel(x, i), p);
3593 5481 : return z;
3594 : }
3595 :
3596 : GEN
3597 148505 : FlxC_sub(GEN x, GEN y, ulong p)
3598 : {
3599 148505 : long i, l = lg(x);
3600 148505 : GEN z = cgetg(l, t_COL);
3601 444731 : for (i = 1; i < l; i++)
3602 296226 : gel(z, i) = Flx_sub(gel(x, i), gel(y, i), p);
3603 148505 : return z;
3604 : }
3605 :
3606 : GEN
3607 2576 : zero_FlxM(long r, long c, long sv)
3608 : {
3609 : long j;
3610 2576 : GEN x = cgetg(c + 1, t_MAT);
3611 2576 : GEN z = zero_FlxC(r, sv);
3612 9121 : for (j = 1; j <= c; j++)
3613 6545 : gel(x, j) = z;
3614 2576 : return x;
3615 : }
3616 :
3617 : GEN
3618 1750 : FlxM_neg(GEN x, ulong p)
3619 : {
3620 1750 : long j, l = lg(x);
3621 1750 : GEN z = cgetg(l, t_MAT);
3622 7217 : for (j = 1; j < l; j++)
3623 5467 : gel(z, j) = FlxC_neg(gel(x, j), p);
3624 1750 : return z;
3625 : }
3626 :
3627 : GEN
3628 20048 : FlxM_sub(GEN x, GEN y, ulong p)
3629 : {
3630 20048 : long j, l = lg(x);
3631 20048 : GEN z = cgetg(l, t_MAT);
3632 168553 : for (j = 1; j < l; j++)
3633 148505 : gel(z, j) = FlxC_sub(gel(x, j), gel(y, j), p);
3634 20048 : return z;
3635 : }
3636 :
3637 : /***********************************************************************/
3638 : /** **/
3639 : /** FlxX **/
3640 : /** **/
3641 : /***********************************************************************/
3642 :
3643 : /* FlxX are t_POL with Flx coefficients.
3644 : * Normally the variable ordering should be respected.*/
3645 :
3646 : /*Similar to normalizepol, in place*/
3647 : /*FlxX_renormalize=zxX_renormalize */
3648 : GEN
3649 7451805 : FlxX_renormalize(GEN /*in place*/ x, long lx)
3650 : {
3651 : long i;
3652 10255622 : for (i = lx-1; i>1; i--)
3653 9388997 : if (lgpol(gel(x,i))) break;
3654 7451808 : stackdummy((pari_sp)(x + lg(x)), (pari_sp)(x + i+1));
3655 7451803 : setlg(x, i+1); setsigne(x, i!=1); return x;
3656 : }
3657 :
3658 : GEN
3659 863226 : pol1_FlxX(long v, long sv)
3660 : {
3661 863226 : GEN z = cgetg(3, t_POL);
3662 863226 : z[1] = evalsigne(1) | evalvarn(v);
3663 863226 : gel(z,2) = pol1_Flx(sv); return z;
3664 : }
3665 :
3666 : GEN
3667 5057 : polx_FlxX(long v, long sv)
3668 : {
3669 5057 : GEN z = cgetg(4, t_POL);
3670 5057 : z[1] = evalsigne(1) | evalvarn(v);
3671 5057 : gel(z,2) = pol0_Flx(sv);
3672 5057 : gel(z,3) = pol1_Flx(sv); return z;
3673 : }
3674 :
3675 : long
3676 1013002 : FlxY_degreex(GEN b)
3677 : {
3678 1013002 : long deg = -1, i;
3679 1013002 : if (!signe(b)) return -1;
3680 4846548 : for (i = 2; i < lg(b); ++i)
3681 3833546 : deg = maxss(deg, degpol(gel(b, i)));
3682 1013002 : return deg;
3683 : }
3684 :
3685 : /*Lift coefficient of B to constant Flx, to give a FlxY*/
3686 : GEN
3687 2981 : Fly_to_FlxY(GEN B, long sv)
3688 : {
3689 2981 : long lb=lg(B);
3690 : long i;
3691 2981 : GEN b=cgetg(lb,t_POL);
3692 2992 : b[1]=evalsigne(1)|(((ulong)B[1])&VARNBITS);
3693 73669 : for (i=2; i<lb; i++)
3694 70688 : gel(b,i) = Fl_to_Flx(B[i], sv);
3695 2981 : return FlxX_renormalize(b, lb);
3696 : }
3697 :
3698 : GEN
3699 837060 : zxX_to_FlxX(GEN B, ulong p)
3700 : {
3701 837060 : long i, lb = lg(B);
3702 837060 : GEN b = cgetg(lb,t_POL);
3703 3690869 : for (i=2; i<lb; i++)
3704 2853809 : gel(b,i) = zx_to_Flx(gel(B,i), p);
3705 837060 : b[1] = B[1]; return FlxX_renormalize(b, lb);
3706 : }
3707 :
3708 : GEN
3709 426040 : FlxX_to_ZXX(GEN B)
3710 : {
3711 426040 : long i, lb = lg(B);
3712 426040 : GEN b = cgetg(lb,t_POL);
3713 2390481 : for (i=2; i<lb; i++)
3714 : {
3715 1964441 : GEN c = gel(B,i);
3716 1964441 : switch(lgpol(c))
3717 : {
3718 46317 : case 0: c = gen_0; break;
3719 54465 : case 1: c = utoi(c[2]); break;
3720 1863659 : default: c = Flx_to_ZX(c); break;
3721 : }
3722 1964441 : gel(b,i) = c;
3723 : }
3724 426040 : b[1] = B[1]; return b;
3725 : }
3726 :
3727 : GEN
3728 938 : FlxXC_to_ZXXC(GEN B)
3729 : {
3730 938 : long i, l = lg(B);
3731 938 : GEN z = cgetg(l, t_COL);
3732 7203 : for (i=1; i<l; i++)
3733 6265 : gel(z,i) = FlxX_to_ZXX(gel(B,i));
3734 938 : return z;
3735 : }
3736 :
3737 : GEN
3738 0 : FlxXM_to_ZXXM(GEN B)
3739 : {
3740 0 : long i, l = lg(B);
3741 0 : GEN z = cgetg(l, t_MAT);
3742 0 : for (i=1; i<l; i++)
3743 0 : gel(z,i) = FlxXC_to_ZXXC(gel(B,i));
3744 0 : return z;
3745 : }
3746 :
3747 : /* Note: v is used _only_ for the t_INT. It must match
3748 : * the variable of any t_POL coefficients. */
3749 : GEN
3750 472588 : ZXX_to_FlxX(GEN B, ulong p, long v)
3751 : {
3752 472588 : long lb=lg(B);
3753 : long i;
3754 472588 : GEN b=cgetg(lb,t_POL);
3755 472591 : b[1]=evalsigne(1)|(((ulong)B[1])&VARNBITS);
3756 4111329 : for (i=2; i<lb; i++)
3757 3638738 : switch (typ(gel(B,i)))
3758 : {
3759 : case t_INT:
3760 798559 : gel(b,i) = Z_to_Flx(gel(B,i), p, evalvarn(v));
3761 798558 : break;
3762 : case t_POL:
3763 2840185 : gel(b,i) = ZX_to_Flx(gel(B,i), p);
3764 2840186 : break;
3765 : }
3766 472591 : return FlxX_renormalize(b, lb);
3767 : }
3768 :
3769 : GEN
3770 12 : ZXXV_to_FlxXV(GEN V, ulong p, long v)
3771 : {
3772 12 : long j, N = lg(V);
3773 12 : GEN y = cgetg(N, t_VEC);
3774 12 : for (j=1; j<N; j++) gel(y,j) = ZXX_to_FlxX(gel(V,j), p, v);
3775 12 : return y;
3776 : }
3777 :
3778 : GEN
3779 285 : ZXXT_to_FlxXT(GEN z, ulong p, long v)
3780 : {
3781 285 : if (typ(z) == t_POL)
3782 278 : return ZXX_to_FlxX(z, p, v);
3783 : else
3784 : {
3785 7 : long i,l = lg(z);
3786 7 : GEN x = cgetg(l, t_VEC);
3787 7 : for (i=1; i<l; i++) gel(x,i) = ZXXT_to_FlxXT(gel(z,i), p, v);
3788 7 : return x;
3789 : }
3790 : }
3791 :
3792 : GEN
3793 0 : FlxX_to_FlxC(GEN x, long N, long sv)
3794 : {
3795 : long i, l;
3796 : GEN z;
3797 0 : l = lg(x)-1; x++;
3798 0 : if (l > N+1) l = N+1; /* truncate higher degree terms */
3799 0 : z = cgetg(N+1,t_COL);
3800 0 : for (i=1; i<l ; i++) gel(z,i) = gel(x,i);
3801 0 : for ( ; i<=N; i++) gel(z,i) = pol0_Flx(sv);
3802 0 : return z;
3803 : }
3804 :
3805 : GEN
3806 0 : FlxXV_to_FlxM(GEN v, long n, long sv)
3807 : {
3808 0 : long j, N = lg(v);
3809 0 : GEN y = cgetg(N, t_MAT);
3810 0 : for (j=1; j<N; j++) gel(y,j) = FlxX_to_FlxC(gel(v,j), n, sv);
3811 0 : return y;
3812 : }
3813 :
3814 : /* matrix whose entries are given by the coeffs of the polynomial v in
3815 : * two variables (considered as degree n polynomials) */
3816 : GEN
3817 8748 : FlxX_to_Flm(GEN v, long n)
3818 : {
3819 8748 : long j, N = lg(v)-1;
3820 8748 : GEN y = cgetg(N, t_MAT);
3821 8736 : v++;
3822 8736 : for (j=1; j<N; j++) gel(y,j) = Flx_to_Flv(gel(v,j), n);
3823 8747 : return y;
3824 : }
3825 :
3826 : GEN
3827 30938 : FlxX_to_Flx(GEN f)
3828 : {
3829 30938 : long i, l = lg(f);
3830 30938 : GEN V = cgetg(l, t_VECSMALL);
3831 30938 : V[1] = ((ulong)f[1])&VARNBITS;
3832 216342 : for(i=2; i<l; i++)
3833 185404 : V[i] = lgpol(gel(f,i)) ? mael(f,i,2): 0L;
3834 30938 : return V;
3835 : }
3836 :
3837 : GEN
3838 19725 : Flm_to_FlxX(GEN x, long v,long w)
3839 : {
3840 19725 : long j, lx = lg(x);
3841 19725 : GEN y = cgetg(lx+1, t_POL);
3842 19726 : y[1]=evalsigne(1) | v;
3843 19726 : y++;
3844 19726 : for (j=1; j<lx; j++) gel(y,j) = Flv_to_Flx(gel(x,j), w);
3845 19723 : return FlxX_renormalize(--y, lx+1);
3846 : }
3847 :
3848 : /* P(X,Y) --> P(Y,X), n-1 is the degree in Y */
3849 : GEN
3850 12908 : FlxX_swap(GEN x, long n, long ws)
3851 : {
3852 12908 : long j, lx = lg(x), ly = n+3;
3853 12908 : GEN y = cgetg(ly, t_POL);
3854 12908 : y[1] = x[1];
3855 141092 : for (j=2; j<ly; j++)
3856 : {
3857 : long k;
3858 128184 : GEN p1 = cgetg(lx, t_VECSMALL);
3859 128184 : p1[1] = ws;
3860 5177963 : for (k=2; k<lx; k++)
3861 5049779 : if (j<lg(gel(x,k)))
3862 4234231 : p1[k] = mael(x,k,j);
3863 : else
3864 815548 : p1[k] = 0;
3865 128184 : gel(y,j) = Flx_renormalize(p1,lx);
3866 : }
3867 12908 : return FlxX_renormalize(y,ly);
3868 : }
3869 :
3870 : static GEN
3871 1247384 : zxX_to_Kronecker_spec(GEN P, long lp, long n)
3872 : { /* P(X) = sum Pi(Y) * X^i, return P( Y^(2n-1) ) */
3873 1247384 : long i, j, k, l, N = (n<<1) + 1;
3874 1247384 : GEN y = cgetg((N-2)*lp + 2, t_VECSMALL) + 2;
3875 12629498 : for (k=i=0; i<lp; i++)
3876 : {
3877 12626469 : GEN c = gel(P,i);
3878 12626469 : l = lg(c);
3879 12626469 : if (l-3 >= n)
3880 0 : pari_err_BUG("zxX_to_Kronecker, P is not reduced mod Q");
3881 12626469 : for (j=2; j < l; j++) y[k++] = c[j];
3882 12626469 : if (i == lp-1) break;
3883 11382114 : for ( ; j < N; j++) y[k++] = 0;
3884 : }
3885 1247384 : y -= 2;
3886 1247384 : y[1] = P[1]; setlg(y, k+2); return y;
3887 : }
3888 :
3889 : GEN
3890 1026240 : zxX_to_Kronecker(GEN P, GEN Q)
3891 : {
3892 1026240 : GEN z = zxX_to_Kronecker_spec(P+2, lg(P)-2, degpol(Q));
3893 1026240 : z[1] = P[1]; return z;
3894 : }
3895 :
3896 : GEN
3897 503104 : FlxX_add(GEN x, GEN y, ulong p)
3898 : {
3899 : long i,lz;
3900 : GEN z;
3901 503104 : long lx=lg(x);
3902 503104 : long ly=lg(y);
3903 503104 : if (ly>lx) swapspec(x,y, lx,ly);
3904 503104 : lz = lx; z = cgetg(lz, t_POL); z[1]=x[1];
3905 503104 : for (i=2; i<ly; i++) gel(z,i) = Flx_add(gel(x,i), gel(y,i), p);
3906 503104 : for ( ; i<lx; i++) gel(z,i) = Flx_copy(gel(x,i));
3907 503104 : return FlxX_renormalize(z, lz);
3908 : }
3909 :
3910 : GEN
3911 0 : FlxX_Flx_add(GEN y, GEN x, ulong p)
3912 : {
3913 0 : long i, lz = lg(y);
3914 : GEN z;
3915 0 : if (signe(y) == 0) return scalarpol(x, varn(y));
3916 0 : z = cgetg(lz,t_POL); z[1] = y[1];
3917 0 : gel(z,2) = Flx_add(gel(y,2), x, p);
3918 0 : if (lz == 3) z = FlxX_renormalize(z,lz);
3919 : else
3920 0 : for(i=3;i<lz;i++) gel(z,i) = Flx_copy(gel(y,i));
3921 0 : return z;
3922 : }
3923 :
3924 : GEN
3925 10238 : FlxX_Flx_sub(GEN y, GEN x, ulong p)
3926 : {
3927 10238 : long i, lz = lg(y);
3928 : GEN z;
3929 10238 : if (signe(y) == 0) return scalarpol(x, varn(y));
3930 10238 : z = cgetg(lz,t_POL); z[1] = y[1];
3931 10238 : gel(z,2) = Flx_sub(gel(y,2), x, p);
3932 10238 : if (lz == 3) z = FlxX_renormalize(z,lz);
3933 : else
3934 8601 : for(i=3;i<lz;i++) gel(z,i) = Flx_copy(gel(y,i));
3935 10238 : return z;
3936 : }
3937 :
3938 : GEN
3939 1265 : FlxX_neg(GEN x, ulong p)
3940 : {
3941 1265 : long i, lx=lg(x);
3942 1265 : GEN z = cgetg(lx, t_POL);
3943 1265 : z[1]=x[1];
3944 1265 : for (i=2; i<lx; i++) gel(z,i) = Flx_neg(gel(x,i), p);
3945 1265 : return z;
3946 : }
3947 :
3948 : GEN
3949 205 : FlxX_Fl_mul(GEN x, ulong y, ulong p)
3950 : {
3951 205 : long i, lx=lg(x);
3952 205 : GEN z = cgetg(lx, t_POL);
3953 205 : z[1]=x[1];
3954 205 : for (i=2; i<lx; i++) gel(z,i) = Flx_Fl_mul(gel(x,i), y, p);
3955 205 : return FlxX_renormalize(z, lx);
3956 : }
3957 :
3958 : GEN
3959 0 : FlxX_triple(GEN x, ulong p)
3960 : {
3961 0 : long i, lx=lg(x);
3962 0 : GEN z = cgetg(lx, t_POL);
3963 0 : z[1]=x[1];
3964 0 : for (i=2; i<lx; i++) gel(z,i) = Flx_triple(gel(x,i), p);
3965 0 : return FlxX_renormalize(z, lx);
3966 : }
3967 :
3968 : GEN
3969 205 : FlxX_double(GEN x, ulong p)
3970 : {
3971 205 : long i, lx=lg(x);
3972 205 : GEN z = cgetg(lx, t_POL);
3973 205 : z[1]=x[1];
3974 205 : for (i=2; i<lx; i++) gel(z,i) = Flx_double(gel(x,i), p);
3975 205 : return FlxX_renormalize(z, lx);
3976 : }
3977 :
3978 : GEN
3979 59793 : FlxX_deriv(GEN z, ulong p)
3980 : {
3981 59793 : long i,l = lg(z)-1;
3982 : GEN x;
3983 59793 : if (l < 2) l = 2;
3984 59793 : x = cgetg(l, t_POL); x[1] = z[1];
3985 59793 : for (i=2; i<l; i++) gel(x,i) = Flx_mulu(gel(z,i+1), (ulong) i-1, p);
3986 59793 : return FlxX_renormalize(x,l);
3987 : }
3988 :
3989 : static GEN
3990 43062 : FlxX_subspec(GEN x, GEN y, ulong p, long lx, long ly)
3991 : {
3992 : long i,lz;
3993 : GEN z;
3994 :
3995 43062 : if (ly <= lx)
3996 : {
3997 43062 : lz = lx+2; z = cgetg(lz, t_POL)+2;
3998 43062 : for (i=0; i<ly; i++) gel(z,i) = Flx_sub(gel(x,i),gel(y,i),p);
3999 43062 : for ( ; i<lx; i++) gel(z,i) = Flx_copy(gel(x,i));
4000 : }
4001 : else
4002 : {
4003 0 : lz = ly+2; z = cgetg(lz, t_POL)+2;
4004 0 : for (i=0; i<lx; i++) gel(z,i) = Flx_sub(gel(x,i),gel(y,i),p);
4005 0 : for ( ; i<ly; i++) gel(z,i) = Flx_neg(gel(y,i),p);
4006 : }
4007 43062 : return FlxX_renormalize(z-2, lz);
4008 : }
4009 :
4010 : GEN
4011 108524 : FlxX_sub(GEN x, GEN y, ulong p)
4012 : {
4013 : long lx,ly,i,lz;
4014 : GEN z;
4015 108524 : lx = lg(x); ly = lg(y);
4016 108524 : lz=maxss(lx,ly);
4017 108524 : z = cgetg(lz,t_POL);
4018 108524 : if (lx >= ly)
4019 : {
4020 68268 : z[1] = x[1];
4021 68268 : for (i=2; i<ly; i++) gel(z,i) = Flx_sub(gel(x,i),gel(y,i),p);
4022 68268 : for ( ; i<lx; i++) gel(z,i) = Flx_copy(gel(x,i));
4023 68268 : if (lx==ly) z = FlxX_renormalize(z, lz);
4024 : }
4025 : else
4026 : {
4027 40256 : z[1] = y[1];
4028 40256 : for (i=2; i<lx; i++) gel(z,i) = Flx_sub(gel(x,i),gel(y,i),p);
4029 40256 : for ( ; i<ly; i++) gel(z,i) = Flx_neg(gel(y,i),p);
4030 : }
4031 108524 : if (!lgpol(z)) { avma = (pari_sp)(z + lz); z = pol_0(varn(x)); }
4032 108524 : return z;
4033 : }
4034 :
4035 : GEN
4036 616402 : FlxX_Flx_mul(GEN P, GEN U, ulong p)
4037 : {
4038 616402 : long i, lP = lg(P);
4039 616402 : GEN res = cgetg(lP,t_POL);
4040 616402 : res[1] = P[1];
4041 6199432 : for(i=2; i<lP; i++)
4042 5583030 : gel(res,i) = Flx_mul(U,gel(P,i), p);
4043 616402 : return FlxX_renormalize(res, lP);
4044 : }
4045 :
4046 : GEN
4047 261071 : FlxY_evalx(GEN Q, ulong x, ulong p)
4048 : {
4049 : GEN z;
4050 261071 : long i, lb = lg(Q);
4051 261071 : z = cgetg(lb,t_VECSMALL); z[1] = evalvarn(varn(Q));
4052 261427 : for (i=2; i<lb; i++) z[i] = Flx_eval(gel(Q,i), x, p);
4053 261049 : return Flx_renormalize(z, lb);
4054 : }
4055 :
4056 : GEN
4057 0 : FlxY_Flx_translate(GEN P, GEN c, ulong p)
4058 : {
4059 0 : pari_sp av = avma;
4060 : GEN Q;
4061 : long i, k, n;
4062 :
4063 0 : if (!signe(P) || gequal0(c)) return RgX_copy(P);
4064 0 : Q = leafcopy(P); n = degpol(P);
4065 0 : for (i=1; i<=n; i++)
4066 : {
4067 0 : for (k=n-i; k<n; k++)
4068 0 : gel(Q,2+k) = Flx_add(gel(Q,2+k), Flx_mul(gel(Q,2+k+1), c, p), p);
4069 0 : if (gc_needed(av,2))
4070 : {
4071 0 : if(DEBUGMEM>1)
4072 0 : pari_warn(warnmem,"FlxY_Flx_translate, i = %ld/%ld", i,n);
4073 0 : Q = gerepilecopy(av, Q);
4074 : }
4075 : }
4076 0 : return gerepilecopy(av, Q);
4077 : }
4078 :
4079 : GEN
4080 3030603 : FlxY_evalx_powers_pre(GEN pol, GEN ypowers, ulong p, ulong pi)
4081 : {
4082 3030603 : long i, len = lg(pol);
4083 3030603 : GEN res = cgetg(len, t_VECSMALL);
4084 3030603 : res[1] = pol[1] & VARNBITS;
4085 14266987 : for (i = 2; i < len; ++i)
4086 11236384 : res[i] = Flx_eval_powers_pre(gel(pol, i), ypowers, p, pi);
4087 3030603 : return Flx_renormalize(res, len);
4088 : }
4089 :
4090 : ulong
4091 1934784 : FlxY_eval_powers_pre(GEN pol, GEN ypowers, GEN xpowers, ulong p, ulong pi)
4092 : {
4093 1934784 : pari_sp av = avma;
4094 1934784 : GEN t = FlxY_evalx_powers_pre(pol, ypowers, p, pi);
4095 1934784 : ulong out = Flx_eval_powers_pre(t, xpowers, p, pi);
4096 1934784 : avma = av;
4097 1934784 : return out;
4098 : }
4099 :
4100 : GEN
4101 117440 : FlxY_FlxqV_evalx(GEN P, GEN x, GEN T, ulong p)
4102 : {
4103 117440 : long i, lP = lg(P);
4104 117440 : GEN res = cgetg(lP,t_POL);
4105 117440 : res[1] = P[1];
4106 721343 : for(i=2; i<lP; i++)
4107 603903 : gel(res,i) = Flx_FlxqV_eval(gel(P,i), x, T, p);
4108 117440 : return FlxX_renormalize(res, lP);
4109 : }
4110 :
4111 : GEN
4112 0 : FlxY_Flxq_evalx(GEN P, GEN x, GEN T, ulong p)
4113 : {
4114 0 : pari_sp av = avma;
4115 0 : long n = brent_kung_optpow(get_Flx_degree(T)-1,lgpol(P),1);
4116 0 : GEN xp = Flxq_powers(x, n, T, p);
4117 0 : return gerepileupto(av, FlxY_FlxqV_evalx(P, xp, T, p));
4118 : }
4119 :
4120 : GEN
4121 9084 : FlxY_Flx_div(GEN x, GEN y, ulong p)
4122 : {
4123 : long i, l;
4124 : GEN z;
4125 9084 : if (degpol(y) == 0)
4126 : {
4127 6490 : ulong t = uel(y,2);
4128 6490 : if (t == 1) return x;
4129 0 : t = Fl_inv(t, p);
4130 0 : z = cgetg_copy(x, &l); z[1] = x[1];
4131 0 : for (i=2; i<l; i++) gel(z,i) = Flx_Fl_mul(gel(x,i),t,p);
4132 : }
4133 : else
4134 : {
4135 2595 : z = cgetg_copy(x, &l); z[1] = x[1];
4136 2595 : for (i=2; i<l; i++) gel(z,i) = Flx_div(gel(x,i),y,p);
4137 : }
4138 2594 : return z;
4139 : }
4140 :
4141 : GEN
4142 0 : FlxX_shift(GEN a, long n, long vs)
4143 : {
4144 0 : long i, l = lg(a);
4145 : GEN b;
4146 0 : if (l == 2 || !n) return a;
4147 0 : l += n;
4148 0 : if (n < 0)
4149 : {
4150 0 : if (l <= 2) return pol_0(varn(a));
4151 0 : b = cgetg(l, t_POL); b[1] = a[1];
4152 0 : a -= n;
4153 0 : for (i=2; i<l; i++) gel(b,i) = gel(a,i);
4154 : } else {
4155 0 : b = cgetg(l, t_POL); b[1] = a[1];
4156 0 : a -= n; n += 2;
4157 0 : for (i=2; i<n; i++) gel(b,i) = pol0_Flx(vs);
4158 0 : for ( ; i<l; i++) gel(b,i) = gel(a,i);
4159 : }
4160 0 : return b;
4161 : }
4162 :
4163 : static GEN
4164 89190 : FlxX_recipspec(GEN x, long l, long n, long vs)
4165 : {
4166 : long i;
4167 89190 : GEN z=cgetg(n+2,t_POL)+2;
4168 2337830 : for(i=0; i<l; i++)
4169 2248640 : gel(z,n-i-1) = Flx_copy(gel(x,i));
4170 89866 : for( ; i<n; i++)
4171 676 : gel(z,n-i-1) = pol0_Flx(vs);
4172 89190 : return FlxX_renormalize(z-2,n+2);
4173 : }
4174 :
4175 : /***********************************************************************/
4176 : /** **/
4177 : /** FlxqX **/
4178 : /** **/
4179 : /***********************************************************************/
4180 :
4181 : static GEN
4182 1397376 : get_FlxqX_red(GEN T, GEN *B)
4183 : {
4184 1397376 : if (typ(T)!=t_VEC) { *B=NULL; return T; }
4185 57904 : *B = gel(T,1); return gel(T,2);
4186 : }
4187 :
4188 : GEN
4189 21803 : RgX_to_FlxqX(GEN x, GEN T, ulong p)
4190 : {
4191 21803 : long i, l = lg(x);
4192 21803 : GEN z = cgetg(l, t_POL); z[1] = x[1];
4193 175742 : for (i = 2; i < l; i++)
4194 153939 : gel(z,i) = Rg_to_Flxq(gel(x,i), T, p);
4195 21803 : return FlxX_renormalize(z, l);
4196 : }
4197 :
4198 : /* FlxqX are t_POL with Flxq coefficients.
4199 : * Normally the variable ordering should be respected.*/
4200 :
4201 : GEN
4202 299 : random_FlxqX(long d1, long v, GEN T, ulong p)
4203 : {
4204 299 : long dT = get_Flx_degree(T), vT = get_Flx_var(T);
4205 299 : long i, d = d1+2;
4206 299 : GEN y = cgetg(d,t_POL); y[1] = evalsigne(1) | evalvarn(v);
4207 299 : for (i=2; i<d; i++) gel(y,i) = random_Flx(dT, vT, p);
4208 299 : return FlxX_renormalize(y,d);
4209 : }
4210 :
4211 : /*Not stack clean*/
4212 : GEN
4213 723394 : Kronecker_to_FlxqX(GEN z, GEN T, ulong p)
4214 : {
4215 723394 : long i,j,lx,l, N = (get_Flx_degree(T)<<1) + 1;
4216 723394 : GEN x, t = cgetg(N,t_VECSMALL);
4217 723394 : t[1] = get_Flx_var(T);
4218 723394 : l = lg(z); lx = (l-2) / (N-2);
4219 723394 : x = cgetg(lx+3,t_POL);
4220 723394 : x[1] = z[1];
4221 13002993 : for (i=2; i<lx+2; i++)
4222 : {
4223 12279599 : for (j=2; j<N; j++) t[j] = z[j];
4224 12279599 : z += (N-2);
4225 12279599 : gel(x,i) = Flx_rem(Flx_renormalize(t,N), T,p);
4226 : }
4227 723394 : N = (l-2) % (N-2) + 2;
4228 723394 : for (j=2; j<N; j++) t[j] = z[j];
4229 723394 : gel(x,i) = Flx_rem(Flx_renormalize(t,N), T,p);
4230 723394 : return FlxX_renormalize(x, i+1);
4231 : }
4232 :
4233 : GEN
4234 953344 : FlxqX_red(GEN z, GEN T, ulong p)
4235 : {
4236 : GEN res;
4237 953344 : long i, l = lg(z);
4238 953344 : res = cgetg(l,t_POL); res[1] = z[1];
4239 953344 : for(i=2;i<l;i++) gel(res,i) = Flx_rem(gel(z,i),T,p);
4240 953344 : return FlxX_renormalize(res,l);
4241 : }
4242 :
4243 : static GEN
4244 110572 : FlxqX_mulspec(GEN x, GEN y, GEN T, ulong p, long lx, long ly)
4245 : {
4246 110572 : pari_sp ltop=avma;
4247 : GEN z,kx,ky;
4248 110572 : long dT = get_Flx_degree(T);
4249 110572 : kx= zxX_to_Kronecker_spec(x,lx,dT);
4250 110572 : ky= zxX_to_Kronecker_spec(y,ly,dT);
4251 110572 : z = Flx_mul(ky, kx, p);
4252 110572 : z = Kronecker_to_FlxqX(z,T,p);
4253 110572 : return gerepileupto(ltop,z);
4254 : }
4255 :
4256 : GEN
4257 413418 : FlxqX_mul(GEN x, GEN y, GEN T, ulong p)
4258 : {
4259 413418 : pari_sp ltop=avma;
4260 : GEN z,kx,ky;
4261 413418 : kx= zxX_to_Kronecker(x,get_Flx_mod(T));
4262 413418 : ky= zxX_to_Kronecker(y,get_Flx_mod(T));
4263 413418 : z = Flx_mul(ky, kx, p);
4264 413418 : z = Kronecker_to_FlxqX(z,T,p);
4265 413418 : return gerepileupto(ltop,z);
4266 : }
4267 :
4268 : GEN
4269 199404 : FlxqX_sqr(GEN x, GEN T, ulong p)
4270 : {
4271 199404 : pari_sp ltop=avma;
4272 : GEN z,kx;
4273 199404 : kx= zxX_to_Kronecker(x,get_Flx_mod(T));
4274 199404 : z = Flx_sqr(kx, p);
4275 199404 : z = Kronecker_to_FlxqX(z,T,p);
4276 199404 : return gerepileupto(ltop,z);
4277 : }
4278 :
4279 : GEN
4280 7882 : FlxqX_Flxq_mul(GEN P, GEN U, GEN T, ulong p)
4281 : {
4282 7882 : long i, lP = lg(P);
4283 7882 : GEN res = cgetg(lP,t_POL);
4284 7882 : res[1] = P[1];
4285 36015 : for(i=2; i<lP; i++)
4286 28133 : gel(res,i) = Flxq_mul(U,gel(P,i), T,p);
4287 7882 : return FlxX_renormalize(res, lP);
4288 : }
4289 : GEN
4290 207744 : FlxqX_Flxq_mul_to_monic(GEN P, GEN U, GEN T, ulong p)
4291 : {
4292 207744 : long i, lP = lg(P);
4293 207744 : GEN res = cgetg(lP,t_POL);
4294 207744 : res[1] = P[1];
4295 207744 : for(i=2; i<lP-1; i++) gel(res,i) = Flxq_mul(U,gel(P,i), T,p);
4296 207744 : gel(res,lP-1) = pol1_Flx(get_Flx_var(T));
4297 207744 : return FlxX_renormalize(res, lP);
4298 : }
4299 :
4300 : GEN
4301 168648 : FlxqX_normalize(GEN z, GEN T, ulong p)
4302 : {
4303 168648 : GEN p1 = leading_coeff(z);
4304 168648 : if (!lgpol(z) || (!degpol(p1) && p1[1] == 1)) return z;
4305 168627 : return FlxqX_Flxq_mul_to_monic(z, Flxq_inv(p1,T,p), T,p);
4306 : }
4307 :
4308 : /* x and y in Z[Y][X]. Assume T irreducible mod p */
4309 : static GEN
4310 1136631 : FlxqX_divrem_basecase(GEN x, GEN y, GEN T, ulong p, GEN *pr)
4311 : {
4312 : long vx, dx, dy, dz, i, j, sx, lr;
4313 : pari_sp av0, av, tetpil;
4314 : GEN z,p1,rem,lead;
4315 :
4316 1136631 : if (!signe(y)) pari_err_INV("FlxqX_divrem",y);
4317 1136631 : vx=varn(x); dy=degpol(y); dx=degpol(x);
4318 1136631 : if (dx < dy)
4319 : {
4320 12928 : if (pr)
4321 : {
4322 12782 : av0 = avma; x = FlxqX_red(x, T, p);
4323 12782 : if (pr == ONLY_DIVIDES) { avma=av0; return signe(x)? NULL: pol_0(vx); }
4324 12691 : if (pr == ONLY_REM) return x;
4325 12691 : *pr = x;
4326 : }
4327 12837 : return pol_0(vx);
4328 : }
4329 1123703 : lead = leading_coeff(y);
4330 1123703 : if (!dy) /* y is constant */
4331 : {
4332 111712 : if (pr && pr != ONLY_DIVIDES)
4333 : {
4334 106824 : if (pr == ONLY_REM) return pol_0(vx);
4335 5908 : *pr = pol_0(vx);
4336 : }
4337 10796 : if (Flx_equal1(lead)) return gcopy(x);
4338 6552 : av0 = avma; x = FlxqX_Flxq_mul(x,Flxq_inv(lead,T,p),T,p);
4339 6552 : return gerepileupto(av0,x);
4340 : }
4341 1011991 : av0 = avma; dz = dx-dy;
4342 1011991 : lead = Flx_equal1(lead)? NULL: gclone(Flxq_inv(lead,T,p));
4343 1011991 : avma = av0;
4344 1011991 : z = cgetg(dz+3,t_POL); z[1] = x[1];
4345 1011991 : x += 2; y += 2; z += 2;
4346 :
4347 1011991 : p1 = gel(x,dx); av = avma;
4348 1011991 : gel(z,dz) = lead? gerepileupto(av, Flxq_mul(p1,lead, T, p)): gcopy(p1);
4349 2791174 : for (i=dx-1; i>=dy; i--)
4350 : {
4351 1779183 : av=avma; p1=gel(x,i);
4352 6626271 : for (j=i-dy+1; j<=i && j<=dz; j++)
4353 4847088 : p1 = Flx_sub(p1, Flx_mul(gel(z,j),gel(y,i-j),p),p);
4354 1779183 : if (lead) p1 = Flx_mul(p1, lead,p);
4355 1779183 : tetpil=avma; gel(z,i-dy) = gerepile(av,tetpil,Flx_rem(p1,T,p));
4356 : }
4357 1011991 : if (!pr) { if (lead) gunclone(lead); return z-2; }
4358 :
4359 982579 : rem = (GEN)avma; av = (pari_sp)new_chunk(dx+3);
4360 1145680 : for (sx=0; ; i--)
4361 : {
4362 1145680 : p1 = gel(x,i);
4363 3889688 : for (j=0; j<=i && j<=dz; j++)
4364 2744008 : p1 = Flx_sub(p1, Flx_mul(gel(z,j),gel(y,i-j),p),p);
4365 1145680 : tetpil=avma; p1 = Flx_rem(p1, T, p); if (lgpol(p1)) { sx = 1; break; }
4366 217183 : if (!i) break;
4367 163101 : avma=av;
4368 163101 : }
4369 982579 : if (pr == ONLY_DIVIDES)
4370 : {
4371 133 : if (lead) gunclone(lead);
4372 133 : if (sx) { avma=av0; return NULL; }
4373 133 : avma = (pari_sp)rem; return z-2;
4374 : }
4375 982446 : lr=i+3; rem -= lr;
4376 982446 : rem[0] = evaltyp(t_POL) | evallg(lr);
4377 982446 : rem[1] = z[-1];
4378 982446 : p1 = gerepile((pari_sp)rem,tetpil,p1);
4379 982446 : rem += 2; gel(rem,i) = p1;
4380 7818340 : for (i--; i>=0; i--)
4381 : {
4382 6835894 : av=avma; p1 = gel(x,i);
4383 21972629 : for (j=0; j<=i && j<=dz; j++)
4384 15136735 : p1 = Flx_sub(p1, Flx_mul(gel(z,j),gel(y,i-j),p), p);
4385 6835894 : tetpil=avma; gel(rem,i) = gerepile(av,tetpil, Flx_rem(p1, T, p));
4386 : }
4387 982446 : rem -= 2;
4388 982446 : if (lead) gunclone(lead);
4389 982446 : if (!sx) (void)FlxX_renormalize(rem, lr);
4390 982446 : if (pr == ONLY_REM) return gerepileupto(av0,rem);
4391 196298 : *pr = rem; return z-2;
4392 : }
4393 :
4394 : static GEN
4395 507 : FlxqX_invBarrett_basecase(GEN T, GEN Q, ulong p)
4396 : {
4397 507 : long i, l=lg(T)-1, lr = l-1, k;
4398 507 : long sv=Q[1];
4399 507 : GEN r=cgetg(lr,t_POL); r[1]=T[1];
4400 507 : gel(r,2) = pol1_Flx(sv);
4401 6111 : for (i=3;i<lr;i++)
4402 : {
4403 5604 : pari_sp ltop=avma;
4404 5604 : GEN u = Flx_neg(gel(T,l-i+2),p);
4405 41331 : for (k=3;k<i;k++)
4406 35727 : u = Flx_sub(u, Flxq_mul(gel(T,l-i+k),gel(r,k),Q,p),p);
4407 5604 : gel(r,i) = gerepileupto(ltop, u);
4408 : }
4409 507 : r = FlxX_renormalize(r,lr);
4410 507 : return r;
4411 : }
4412 :
4413 : /* Return new lgpol */
4414 : static long
4415 121680 : FlxX_lgrenormalizespec(GEN x, long lx)
4416 : {
4417 : long i;
4418 127407 : for (i = lx-1; i>=0; i--)
4419 127407 : if (lgpol(gel(x,i))) break;
4420 121680 : return i+1;
4421 : }
4422 :
4423 : static GEN
4424 2106 : FlxqX_invBarrett_Newton(GEN S, GEN T, ulong p)
4425 : {
4426 2106 : pari_sp av = avma;
4427 2106 : long nold, lx, lz, lq, l = degpol(S), i, lQ;
4428 2106 : GEN q, y, z, x = cgetg(l+2, t_POL) + 2;
4429 2106 : long dT = get_Flx_degree(T);
4430 2106 : ulong mask = quadratic_prec_mask(l-2); /* assume l > 2 */
4431 2106 : for (i=0;i<l;i++) gel(x,i) = pol0_Flx(T[1]);
4432 2106 : q = FlxX_recipspec(S+2,l+1,l+1,dT);
4433 2106 : lQ = lgpol(q); q+=2;
4434 : /* We work on _spec_ FlxX's, all the l[xzq] below are lgpol's */
4435 :
4436 : /* initialize */
4437 2106 : gel(x,0) = Flxq_inv(gel(q,0),T, p);
4438 2106 : if (lQ>1 && degpol(gel(q,1)) >= dT)
4439 0 : gel(q,1) = Flx_rem(gel(q,1), T, p);
4440 2106 : if (lQ>1 && lgpol(gel(q,1)))
4441 1298 : {
4442 1298 : GEN u = gel(q, 1);
4443 1298 : if (!Flx_equal1(gel(x,0))) u = Flxq_mul(u, Flxq_sqr(gel(x,0), T,p), T,p);
4444 1298 : gel(x,1) = Flx_neg(u, p); lx = 2;
4445 : }
4446 : else
4447 808 : lx = 1;
4448 2106 : nold = 1;
4449 16744 : for (; mask > 1; )
4450 : { /* set x -= x(x*q - 1) + O(t^(nnew + 1)), knowing x*q = 1 + O(t^(nold+1)) */
4451 12532 : long i, lnew, nnew = nold << 1;
4452 :
4453 12532 : if (mask & 1) nnew--;
4454 12532 : mask >>= 1;
4455 :
4456 12532 : lnew = nnew + 1;
4457 12532 : lq = FlxX_lgrenormalizespec(q, minss(lQ,lnew));
4458 12532 : z = FlxqX_mulspec(x, q, T, p, lx, lq); /* FIXME: high product */
4459 12532 : lz = lgpol(z); if (lz > lnew) lz = lnew;
4460 12532 : z += 2;
4461 : /* subtract 1 [=>first nold words are 0]: renormalize so that z(0) != 0 */
4462 12532 : for (i = nold; i < lz; i++) if (lgpol(gel(z,i))) break;
4463 12532 : nold = nnew;
4464 12532 : if (i >= lz) continue; /* z-1 = 0(t^(nnew + 1)) */
4465 :
4466 : /* z + i represents (x*q - 1) / t^i */
4467 11916 : lz = FlxX_lgrenormalizespec (z+i, lz-i);
4468 11916 : z = FlxqX_mulspec(x, z+i, T,p, lx, lz); /* FIXME: low product */
4469 11916 : lz = lgpol(z); z += 2;
4470 11916 : if (lz > lnew-i) lz = FlxX_lgrenormalizespec(z, lnew-i);
4471 :
4472 11916 : lx = lz+ i;
4473 11916 : y = x + i; /* x -= z * t^i, in place */
4474 11916 : for (i = 0; i < lz; i++) gel(y,i) = Flx_neg(gel(z,i), p);
4475 : }
4476 2106 : x -= 2; setlg(x, lx + 2); x[1] = S[1];
4477 2106 : return gerepilecopy(av, x);
4478 : }
4479 :
4480 : /* x/polrecip(P)+O(x^n) */
4481 : GEN
4482 2627 : FlxqX_invBarrett(GEN T, GEN Q, ulong p)
4483 : {
4484 2627 : pari_sp ltop=avma;
4485 2627 : long l=lg(T), v = varn(T);
4486 : GEN r;
4487 2627 : GEN c = gel(T,l-1);
4488 2627 : if (l<5) return pol_0(v);
4489 2613 : if (l<=FlxqX_INVBARRETT_LIMIT)
4490 : {
4491 507 : if (!Flx_equal1(c))
4492 : {
4493 0 : GEN ci = Flxq_inv(c,Q,p);
4494 0 : T = FlxqX_Flxq_mul(T, ci, Q, p);
4495 0 : r = FlxqX_invBarrett_basecase(T,Q,p);
4496 0 : r = FlxqX_Flxq_mul(r,ci,Q,p);
4497 : } else
4498 507 : r = FlxqX_invBarrett_basecase(T,Q,p);
4499 : } else
4500 2106 : r = FlxqX_invBarrett_Newton(T,Q,p);
4501 2613 : return gerepileupto(ltop, r);
4502 : }
4503 :
4504 : GEN
4505 291747 : FlxqX_get_red(GEN S, GEN T, ulong p)
4506 : {
4507 291747 : if (typ(S)==t_POL && lg(S)>FlxqX_BARRETT_LIMIT)
4508 1543 : retmkvec2(FlxqX_invBarrett(S, T, p), S);
4509 290204 : return S;
4510 : }
4511 :
4512 : /* Compute x mod S where 2 <= degpol(S) <= l+1 <= 2*(degpol(S)-1)
4513 : * * and mg is the Barrett inverse of S. */
4514 : static GEN
4515 43062 : FlxqX_divrem_Barrettspec(GEN x, long l, GEN mg, GEN S, GEN T, ulong p, GEN *pr)
4516 : {
4517 : GEN q, r;
4518 43062 : long lt = degpol(S); /*We discard the leading term*/
4519 : long ld, lm, lT, lmg;
4520 43062 : ld = l-lt;
4521 43062 : lm = minss(ld, lgpol(mg));
4522 43062 : lT = FlxX_lgrenormalizespec(S+2,lt);
4523 43062 : lmg = FlxX_lgrenormalizespec(mg+2,lm);
4524 43062 : q = FlxX_recipspec(x+lt,ld,ld,0); /* q = rec(x) lq<=ld*/
4525 43062 : q = FlxqX_mulspec(q+2,mg+2,T,p,lgpol(q),lmg); /* q = rec(x) * mg lq<=ld+lm*/
4526 43062 : q = FlxX_recipspec(q+2,minss(ld,lgpol(q)),ld,0);/* q = rec (rec(x) * mg) lq<=ld*/
4527 43062 : if (!pr) return q;
4528 43062 : r = FlxqX_mulspec(q+2,S+2,T,p,lgpol(q),lT); /* r = q*pol lr<=ld+lt*/
4529 43062 : r = FlxX_subspec(x,r+2,p,lt,minss(lt,lgpol(r)));/* r = x - r lr<=lt */
4530 43062 : if (pr == ONLY_REM) return r;
4531 43062 : *pr = r; return q;
4532 : }
4533 :
4534 : static GEN
4535 40371 : FlxqX_divrem_Barrett_noGC(GEN x, GEN mg, GEN S, GEN T, ulong p, GEN *pr)
4536 : {
4537 40371 : long l = lgpol(x), lt = degpol(S), lm = 2*lt-1;
4538 40371 : GEN q = NULL, r;
4539 : long i;
4540 40371 : if (l <= lt)
4541 : {
4542 0 : if (pr == ONLY_REM) return RgX_copy(x);
4543 0 : if (pr == ONLY_DIVIDES) return signe(x)? NULL: pol_0(varn(x));
4544 0 : if (pr) *pr = RgX_copy(x);
4545 0 : return pol_0(varn(x));
4546 : }
4547 40371 : if (lt <= 1)
4548 14 : return FlxqX_divrem_basecase(x,S,T,p,pr);
4549 40357 : if (pr != ONLY_REM && l>lm)
4550 : {
4551 596 : long vT = get_Flx_var(T);
4552 596 : q = cgetg(l-lt+2, t_POL);
4553 596 : for (i=0;i<l-lt;i++) gel(q+2,i) = pol0_Flx(vT);
4554 : }
4555 40357 : r = l>lm ? shallowcopy(x): x;
4556 83494 : while (l>lm)
4557 : {
4558 2780 : GEN zr, zq = FlxqX_divrem_Barrettspec(r+2+l-lm,lm,mg,S,T,p,&zr);
4559 2780 : long lz = lgpol(zr);
4560 2780 : if (pr != ONLY_REM)
4561 : {
4562 671 : long lq = lgpol(zq);
4563 671 : for(i=0; i<lq; i++) gel(q+2+l-lm,i) = gel(zq,2+i);
4564 : }
4565 2780 : for(i=0; i<lz; i++) gel(r+2+l-lm,i) = gel(zr,2+i);
4566 2780 : l = l-lm+lz;
4567 : }
4568 40357 : if (pr != ONLY_REM)
4569 : {
4570 911 : if (l > lt)
4571 : {
4572 836 : GEN zq = FlxqX_divrem_Barrettspec(r+2,l,mg,S,T,p,&r);
4573 836 : if (!q) q = zq;
4574 : else
4575 : {
4576 521 : long lq = lgpol(zq);
4577 521 : for(i=0; i<lq; i++) gel(q+2,i) = gel(zq,2+i);
4578 : }
4579 : }
4580 : else
4581 75 : { setlg(r, l+2); r = RgX_copy(r); }
4582 : }
4583 : else
4584 : {
4585 39446 : if (l > lt)
4586 39446 : (void) FlxqX_divrem_Barrettspec(r+2,l,mg,S,T,p,&r);
4587 : else
4588 0 : { setlg(r, l+2); r = RgX_copy(r); }
4589 39446 : r[1] = x[1]; return FlxX_renormalize(r, lg(r));
4590 : }
4591 911 : if (pr) { r[1] = x[1]; r = FlxX_renormalize(r, lg(r)); }
4592 911 : q[1] = x[1]; q = FlxX_renormalize(q, lg(q));
4593 911 : if (pr == ONLY_DIVIDES) return signe(r)? NULL: q;
4594 911 : if (pr) *pr = r;
4595 911 : return q;
4596 : }
4597 :
4598 : GEN
4599 250478 : FlxqX_divrem(GEN x, GEN S, GEN T, ulong p, GEN *pr)
4600 : {
4601 250478 : GEN B, y = get_FlxqX_red(S, &B);
4602 250478 : long dy = degpol(y), dx = degpol(x), d = dx-dy;
4603 250478 : if (pr==ONLY_REM) return FlxqX_rem(x, y, T, p);
4604 250478 : if (!B && d+3 < FlxqX_DIVREM_BARRETT_LIMIT)
4605 249553 : return FlxqX_divrem_basecase(x,y,T,p,pr);
4606 : else
4607 : {
4608 925 : pari_sp av=avma;
4609 925 : GEN mg = B? B: FlxqX_invBarrett(y, T, p);
4610 925 : GEN q = FlxqX_divrem_Barrett_noGC(x,mg,y,T,p,pr);
4611 925 : if (!q) {avma=av; return NULL;}
4612 925 : if (!pr || pr==ONLY_DIVIDES) return gerepilecopy(av, q);
4613 806 : gerepileall(av,2,&q,pr);
4614 806 : return q;
4615 : }
4616 : }
4617 :
4618 : GEN
4619 1146578 : FlxqX_rem(GEN x, GEN S, GEN T, ulong p)
4620 : {
4621 1146578 : GEN B, y = get_FlxqX_red(S, &B);
4622 1146578 : long dy = degpol(y), dx = degpol(x), d = dx-dy;
4623 1146578 : if (d < 0) return FlxqX_red(x, T, p);
4624 926510 : if (!B && d+3 < FlxqX_REM_BARRETT_LIMIT)
4625 887064 : return FlxqX_divrem_basecase(x,y, T, p, ONLY_REM);
4626 : else
4627 : {
4628 39446 : pari_sp av=avma;
4629 39446 : GEN mg = B? B: FlxqX_invBarrett(y, T, p);
4630 39446 : GEN r = FlxqX_divrem_Barrett_noGC(x, mg, y, T, p, ONLY_REM);
4631 39446 : return gerepileupto(av, r);
4632 : }
4633 : }
4634 :
4635 : static GEN
4636 544 : FlxqX_halfgcd_basecase(GEN a, GEN b, GEN T, ulong p)
4637 : {
4638 544 : pari_sp av=avma;
4639 : GEN u,u1,v,v1;
4640 544 : long vx = varn(a);
4641 544 : long n = lgpol(a)>>1;
4642 544 : u1 = v = pol_0(vx);
4643 544 : u = v1 = pol1_FlxX(vx, get_Flx_var(T));
4644 9255 : while (lgpol(b)>n)
4645 : {
4646 8167 : GEN r, q = FlxqX_divrem(a,b, T, p, &r);
4647 8167 : a = b; b = r; swap(u,u1); swap(v,v1);
4648 8167 : u1 = FlxX_sub(u1, FlxqX_mul(u, q, T, p), p);
4649 8167 : v1 = FlxX_sub(v1, FlxqX_mul(v, q ,T, p), p);
4650 8167 : if (gc_needed(av,2))
4651 : {
4652 0 : if (DEBUGMEM>1) pari_warn(warnmem,"FlxqX_halfgcd (d = %ld)",degpol(b));
4653 0 : gerepileall(av,6, &a,&b,&u1,&v1,&u,&v);
4654 : }
4655 : }
4656 544 : return gerepilecopy(av, mkmat2(mkcol2(u,u1), mkcol2(v,v1)));
4657 : }
4658 : static GEN
4659 768 : FlxqX_addmulmul(GEN u, GEN v, GEN x, GEN y, GEN T, ulong p)
4660 : {
4661 768 : return FlxX_add(FlxqX_mul(u, x, T, p),FlxqX_mul(v, y, T, p), p);
4662 : }
4663 :
4664 : static GEN
4665 384 : FlxqXM_FlxqX_mul2(GEN M, GEN x, GEN y, GEN T, ulong p)
4666 : {
4667 384 : GEN res = cgetg(3, t_COL);
4668 384 : gel(res, 1) = FlxqX_addmulmul(gcoeff(M,1,1), gcoeff(M,1,2), x, y, T, p);
4669 384 : gel(res, 2) = FlxqX_addmulmul(gcoeff(M,2,1), gcoeff(M,2,2), x, y, T, p);
4670 384 : return res;
4671 : }
4672 :
4673 : static GEN
4674 363 : FlxqXM_mul2(GEN A, GEN B, GEN T, ulong p)
4675 : {
4676 363 : GEN A11=gcoeff(A,1,1),A12=gcoeff(A,1,2), B11=gcoeff(B,1,1),B12=gcoeff(B,1,2);
4677 363 : GEN A21=gcoeff(A,2,1),A22=gcoeff(A,2,2), B21=gcoeff(B,2,1),B22=gcoeff(B,2,2);
4678 363 : GEN M1 = FlxqX_mul(FlxX_add(A11,A22, p), FlxX_add(B11,B22, p), T, p);
4679 363 : GEN M2 = FlxqX_mul(FlxX_add(A21,A22, p), B11, T, p);
4680 363 : GEN M3 = FlxqX_mul(A11, FlxX_sub(B12,B22, p), T, p);
4681 363 : GEN M4 = FlxqX_mul(A22, FlxX_sub(B21,B11, p), T, p);
4682 363 : GEN M5 = FlxqX_mul(FlxX_add(A11,A12, p), B22, T, p);
4683 363 : GEN M6 = FlxqX_mul(FlxX_sub(A21,A11, p), FlxX_add(B11,B12, p), T, p);
4684 363 : GEN M7 = FlxqX_mul(FlxX_sub(A12,A22, p), FlxX_add(B21,B22, p), T, p);
4685 363 : GEN T1 = FlxX_add(M1,M4, p), T2 = FlxX_sub(M7,M5, p);
4686 363 : GEN T3 = FlxX_sub(M1,M2, p), T4 = FlxX_add(M3,M6, p);
4687 363 : retmkmat2(mkcol2(FlxX_add(T1,T2, p), FlxX_add(M2,M4, p)),
4688 : mkcol2(FlxX_add(M3,M5, p), FlxX_add(T3,T4, p)));
4689 : }
4690 :
4691 : /* Return [0,1;1,-q]*M */
4692 : static GEN
4693 363 : FlxqX_FlxqXM_qmul(GEN q, GEN M, GEN T, ulong p)
4694 : {
4695 363 : GEN u, v, res = cgetg(3, t_MAT);
4696 363 : u = FlxX_sub(gcoeff(M,1,1), FlxqX_mul(gcoeff(M,2,1), q, T, p), p);
4697 363 : gel(res,1) = mkcol2(gcoeff(M,2,1), u);
4698 363 : v = FlxX_sub(gcoeff(M,1,2), FlxqX_mul(gcoeff(M,2,2), q, T, p), p);
4699 363 : gel(res,2) = mkcol2(gcoeff(M,2,2), v);
4700 363 : return res;
4701 : }
4702 :
4703 : static GEN
4704 0 : matid2_FlxXM(long v, long sv)
4705 : {
4706 0 : retmkmat2(mkcol2(pol1_FlxX(v, sv),pol_0(v)),
4707 : mkcol2(pol_0(v),pol1_FlxX(v, sv)));
4708 : }
4709 :
4710 : static GEN
4711 363 : FlxqX_halfgcd_split(GEN x, GEN y, GEN T, ulong p)
4712 : {
4713 363 : pari_sp av=avma;
4714 : GEN R, S, V;
4715 : GEN y1, r, q;
4716 363 : long l = lgpol(x), n = l>>1, k;
4717 363 : if (lgpol(y)<=n) return matid2_FlxXM(varn(x),T[1]);
4718 363 : R = FlxqX_halfgcd(RgX_shift_shallow(x,-n),RgX_shift_shallow(y,-n), T, p);
4719 363 : V = FlxqXM_FlxqX_mul2(R,x,y, T, p); y1 = gel(V,2);
4720 363 : if (lgpol(y1)<=n) return gerepilecopy(av, R);
4721 363 : q = FlxqX_divrem(gel(V,1), y1, T, p, &r);
4722 363 : k = 2*n-degpol(y1);
4723 363 : S = FlxqX_halfgcd(RgX_shift_shallow(y1,-k), RgX_shift_shallow(r,-k), T, p);
4724 363 : return gerepileupto(av, FlxqXM_mul2(S,FlxqX_FlxqXM_qmul(q,R, T, p), T, p));
4725 : }
4726 :
4727 : /* Return M in GL_2(Fp[X]) such that:
4728 : if [a',b']~=M*[a,b]~ then degpol(a')>= (lgpol(a)>>1) >degpol(b')
4729 : */
4730 :
4731 : static GEN
4732 907 : FlxqX_halfgcd_i(GEN x, GEN y, GEN T, ulong p)
4733 : {
4734 907 : if (lg(x)<=FlxqX_HALFGCD_LIMIT) return FlxqX_halfgcd_basecase(x, y, T, p);
4735 363 : return FlxqX_halfgcd_split(x, y, T, p);
4736 : }
4737 :
4738 : GEN
4739 907 : FlxqX_halfgcd(GEN x, GEN y, GEN T, ulong p)
4740 : {
4741 907 : pari_sp av = avma;
4742 : GEN M,q,r;
4743 907 : if (!signe(x))
4744 : {
4745 0 : long v = varn(x), vT = get_Flx_var(T);
4746 0 : retmkmat2(mkcol2(pol_0(v),pol1_FlxX(v,vT)),
4747 : mkcol2(pol1_FlxX(v,vT),pol_0(v)));
4748 : }
4749 907 : if (degpol(y)<degpol(x)) return FlxqX_halfgcd_i(x, y, T, p);
4750 12 : q = FlxqX_divrem(y, x, T, p, &r);
4751 12 : M = FlxqX_halfgcd_i(x, r, T, p);
4752 12 : gcoeff(M,1,1) = FlxX_sub(gcoeff(M,1,1), FlxqX_mul(q, gcoeff(M,1,2), T, p), p);
4753 12 : gcoeff(M,2,1) = FlxX_sub(gcoeff(M,2,1), FlxqX_mul(q, gcoeff(M,2,2), T, p), p);
4754 12 : return gerepilecopy(av, M);
4755 : }
4756 :
4757 : static GEN
4758 146016 : FlxqX_gcd_basecase(GEN a, GEN b, GEN T, ulong p)
4759 : {
4760 146016 : pari_sp av = avma, av0=avma;
4761 894732 : while (signe(b))
4762 : {
4763 : GEN c;
4764 602700 : if (gc_needed(av0,2))
4765 : {
4766 32 : if (DEBUGMEM>1) pari_warn(warnmem,"FlxqX_gcd (d = %ld)",degpol(b));
4767 32 : gerepileall(av0,2, &a,&b);
4768 : }
4769 602700 : av = avma; c = FlxqX_rem(a, b, T, p); a=b; b=c;
4770 : }
4771 146016 : avma = av; return a;
4772 : }
4773 :
4774 : GEN
4775 150008 : FlxqX_gcd(GEN x, GEN y, GEN T, ulong p)
4776 : {
4777 150008 : pari_sp av = avma;
4778 150008 : x = FlxqX_red(x, T, p);
4779 150008 : y = FlxqX_red(y, T, p);
4780 150008 : if (!signe(x)) return gerepileupto(av, y);
4781 292053 : while (lg(y)>FlxqX_GCD_LIMIT)
4782 : {
4783 : GEN c;
4784 21 : if (lgpol(y)<=(lgpol(x)>>1))
4785 : {
4786 0 : GEN r = FlxqX_rem(x, y, T, p);
4787 0 : x = y; y = r;
4788 : }
4789 21 : c = FlxqXM_FlxqX_mul2(FlxqX_halfgcd(x,y, T, p), x, y, T, p);
4790 21 : x = gel(c,1); y = gel(c,2);
4791 21 : gerepileall(av,2,&x,&y);
4792 : }
4793 146016 : return gerepileupto(av, FlxqX_gcd_basecase(x, y, T, p));
4794 : }
4795 :
4796 : static GEN
4797 5915 : FlxqX_extgcd_basecase(GEN a, GEN b, GEN T, ulong p, GEN *ptu, GEN *ptv)
4798 : {
4799 5915 : pari_sp av=avma;
4800 : GEN u,v,d,d1,v1;
4801 5915 : long vx = varn(a);
4802 5915 : d = a; d1 = b;
4803 5915 : v = pol_0(vx); v1 = pol1_FlxX(vx, get_Flx_var(T));
4804 29792 : while (signe(d1))
4805 : {
4806 17962 : GEN r, q = FlxqX_divrem(d, d1, T, p, &r);
4807 17962 : v = FlxX_sub(v,FlxqX_mul(q,v1,T, p),p);
4808 17962 : u=v; v=v1; v1=u;
4809 17962 : u=r; d=d1; d1=u;
4810 17962 : if (gc_needed(av,2))
4811 : {
4812 0 : if (DEBUGMEM>1) pari_warn(warnmem,"FlxqX_extgcd (d = %ld)",degpol(d));
4813 0 : gerepileall(av,5, &d,&d1,&u,&v,&v1);
4814 : }
4815 : }
4816 5915 : if (ptu) *ptu = FlxqX_div(FlxX_sub(d,FlxqX_mul(b,v, T, p), p), a, T, p);
4817 5915 : *ptv = v; return d;
4818 : }
4819 :
4820 : static GEN
4821 0 : FlxqX_extgcd_halfgcd(GEN x, GEN y, GEN T, ulong p, GEN *ptu, GEN *ptv)
4822 : {
4823 0 : pari_sp av=avma;
4824 0 : GEN u,v,R = matid2_FlxXM(varn(x), get_Flx_var(T));
4825 0 : while (lg(y)>FlxqX_EXTGCD_LIMIT)
4826 : {
4827 : GEN M, c;
4828 0 : if (lgpol(y)<=(lgpol(x)>>1))
4829 : {
4830 0 : GEN r, q = FlxqX_divrem(x, y, T, p, &r);
4831 0 : x = y; y = r;
4832 0 : R = FlxqX_FlxqXM_qmul(q, R, T, p);
4833 : }
4834 0 : M = FlxqX_halfgcd(x,y, T, p);
4835 0 : c = FlxqXM_FlxqX_mul2(M, x,y, T, p);
4836 0 : R = FlxqXM_mul2(M, R, T, p);
4837 0 : x = gel(c,1); y = gel(c,2);
4838 0 : gerepileall(av,3,&x,&y,&R);
4839 : }
4840 0 : y = FlxqX_extgcd_basecase(x,y, T, p, &u,&v);
4841 0 : if (ptu) *ptu = FlxqX_addmulmul(u,v,gcoeff(R,1,1),gcoeff(R,2,1), T, p);
4842 0 : *ptv = FlxqX_addmulmul(u,v,gcoeff(R,1,2),gcoeff(R,2,2), T, p);
4843 0 : return y;
4844 : }
4845 :
4846 : /* x and y in Z[Y][X], return lift(gcd(x mod T,p, y mod T,p)). Set u and v st
4847 : * ux + vy = gcd (mod T,p) */
4848 : GEN
4849 5915 : FlxqX_extgcd(GEN x, GEN y, GEN T, ulong p, GEN *ptu, GEN *ptv)
4850 : {
4851 : GEN d;
4852 5915 : pari_sp ltop=avma;
4853 5915 : x = FlxqX_red(x, T, p);
4854 5915 : y = FlxqX_red(y, T, p);
4855 5915 : if (lg(y)>FlxqX_EXTGCD_LIMIT)
4856 0 : d = FlxqX_extgcd_halfgcd(x, y, T, p, ptu, ptv);
4857 : else
4858 5915 : d = FlxqX_extgcd_basecase(x, y, T, p, ptu, ptv);
4859 5915 : gerepileall(ltop,ptu?3:2,&d,ptv,ptu);
4860 5915 : return d;
4861 : }
4862 :
4863 : GEN
4864 9029 : FlxqX_safegcd(GEN P, GEN Q, GEN T, ulong p)
4865 : {
4866 9029 : pari_sp btop, ltop = avma;
4867 : GEN U;
4868 9029 : if (!signe(P)) return gcopy(Q);
4869 9029 : if (!signe(Q)) return gcopy(P);
4870 9029 : btop = avma;
4871 : for(;;)
4872 : {
4873 39117 : U = Flxq_invsafe(leading_coeff(Q), T, p);
4874 39117 : if (!U) { avma = ltop; return NULL; }
4875 39117 : Q = FlxqX_Flxq_mul_to_monic(Q,U,T,p);
4876 39117 : P = FlxqX_rem(P,Q,T,p);
4877 39117 : if (!signe(P)) break;
4878 30088 : if (gc_needed(btop, 1))
4879 : {
4880 0 : if (DEBUGMEM>1) pari_warn(warnmem,"FlxqX_safegcd");
4881 0 : gerepileall(btop, 2, &P,&Q);
4882 : }
4883 30088 : swap(P, Q);
4884 30088 : }
4885 9029 : return gerepileupto(ltop, Q);
4886 : }
4887 :
4888 : struct _FlxqX {ulong p; GEN T;};
4889 2099 : static GEN _FlxqX_mul(void *data,GEN a,GEN b)
4890 : {
4891 2099 : struct _FlxqX *d=(struct _FlxqX*)data;
4892 2099 : return FlxqX_mul(a,b,d->T,d->p);
4893 : }
4894 10255 : static GEN _FlxqX_sqr(void *data,GEN a)
4895 : {
4896 10255 : struct _FlxqX *d=(struct _FlxqX*)data;
4897 10255 : return FlxqX_sqr(a,d->T,d->p);
4898 : }
4899 :
4900 : GEN
4901 10227 : FlxqX_powu(GEN V, ulong n, GEN T, ulong p)
4902 : {
4903 10227 : struct _FlxqX d; d.p=p; d.T=T;
4904 10227 : return gen_powu(V, n, (void*)&d, &_FlxqX_sqr, &_FlxqX_mul);
4905 : }
4906 :
4907 : GEN
4908 918 : FlxqXV_prod(GEN V, GEN T, ulong p)
4909 : {
4910 918 : struct _FlxqX d; d.p=p; d.T=T;
4911 918 : return gen_product(V, (void*)&d, &_FlxqX_mul);
4912 : }
4913 :
4914 : GEN
4915 906 : FlxqV_roots_to_pol(GEN V, GEN T, ulong p, long v)
4916 : {
4917 906 : pari_sp ltop = avma;
4918 906 : long k, sv = get_Flx_var(T);
4919 906 : GEN W = cgetg(lg(V),t_VEC);
4920 3819 : for(k=1; k < lg(V); k++)
4921 2913 : gel(W,k) = deg1pol_shallow(pol1_Flx(sv),Flx_neg(gel(V,k),p),v);
4922 906 : return gerepileupto(ltop, FlxqXV_prod(W, T, p));
4923 : }
4924 :
4925 : /*** FlxqM ***/
4926 :
4927 : GEN
4928 67725 : FlxqC_Flxq_mul(GEN x, GEN y, GEN T, ulong p)
4929 : {
4930 67725 : long i, l = lg(x);
4931 67725 : GEN z = cgetg(l, t_COL);
4932 149856 : for (i = 1; i < l; i++)
4933 82131 : gel(z, i) = Flxq_mul(gel(x, i), y, T, p);
4934 67725 : return z;
4935 : }
4936 :
4937 : GEN
4938 10689 : FlxqM_Flxq_mul(GEN x, GEN y, GEN T, ulong p)
4939 : {
4940 10689 : long j, l = lg(x);
4941 10689 : GEN z = cgetg(l, t_MAT);
4942 78414 : for (j = 1; j < l; j++)
4943 67725 : gel(z, j) = FlxqC_Flxq_mul(gel(x, j), y, T, p);
4944 10689 : return z;
4945 : }
4946 :
4947 : static GEN
4948 328775 : kron_pack_Flx_spec_half(GEN x, long l) {
4949 328775 : if (l == 0)
4950 166350 : return gen_0;
4951 162425 : return Flx_to_int_halfspec(x, l);
4952 : }
4953 :
4954 : static GEN
4955 20833 : kron_pack_Flx_spec(GEN x, long l) {
4956 : long i;
4957 : GEN w, y;
4958 20833 : if (l == 0)
4959 3092 : return gen_0;
4960 17741 : y = cgetipos(l + 2);
4961 70810 : for (i = 0, w = int_LSW(y); i < l; i++, w = int_nextW(w))
4962 53069 : *w = x[i];
4963 17741 : return y;
4964 : }
4965 :
4966 : static GEN
4967 0 : kron_pack_Flx_spec_2(GEN x, long l) {
4968 0 : return Flx_eval2BILspec(x, 2, l);
4969 : }
4970 :
4971 : static GEN
4972 0 : kron_pack_Flx_spec_3(GEN x, long l) {
4973 0 : return Flx_eval2BILspec(x, 3, l);
4974 : }
4975 :
4976 : static GEN
4977 48380 : kron_pack_Flx_spec_bits(GEN x, long b, long l) {
4978 : GEN y;
4979 : long i;
4980 48380 : if (l == 0)
4981 14903 : return gen_0;
4982 33477 : y = cgetg(l + 1, t_VECSMALL);
4983 176754 : for(i = 1; i <= l; i++)
4984 143277 : y[i] = x[l - i];
4985 33477 : return nv_fromdigits_2k(y, b);
4986 : }
4987 :
4988 : static GEN
4989 14200 : kron_unpack_Flx(GEN z, ulong p)
4990 : {
4991 14200 : long i, l = lgefint(z);
4992 14200 : GEN x = cgetg(l, t_VECSMALL), w;
4993 73639 : for (w = int_LSW(z), i = 2; i < l; w = int_nextW(w), i++)
4994 59439 : x[i] = ((ulong) *w) % p;
4995 14200 : return Flx_renormalize(x, l);
4996 : }
4997 :
4998 : static GEN
4999 0 : kron_unpack_Flx_2(GEN x, ulong p) {
5000 0 : long d = (lgefint(x)-1)/2 - 1;
5001 0 : return Z_mod2BIL_Flx_2(x, d, p);
5002 : }
5003 :
5004 : static GEN
5005 0 : kron_unpack_Flx_3(GEN x, ulong p) {
5006 0 : long d = lgefint(x)/3 - 1;
5007 0 : return Z_mod2BIL_Flx_3(x, d, p);
5008 : }
5009 :
5010 : /* assume b < BITS_IN_LONG */
5011 : static GEN
5012 15992 : kron_unpack_Flx_bits_narrow(GEN z, long b, ulong p) {
5013 15992 : GEN v = binary_2k_nv(z, b), x;
5014 15992 : long i, l = lg(v) + 1;
5015 15992 : x = cgetg(l, t_VECSMALL);
5016 92195 : for (i = 2; i < l; i++)
5017 76203 : x[i] = v[l - i] % p;
5018 15992 : return Flx_renormalize(x, l);
5019 : }
5020 :
5021 : static GEN
5022 7000 : kron_unpack_Flx_bits_wide(GEN z, long b, ulong p, ulong pi) {
5023 7000 : GEN v = binary_2k(z, b), x, y;
5024 7000 : long i, l = lg(v) + 1, ly;
5025 7000 : x = cgetg(l, t_VECSMALL);
5026 70000 : for (i = 2; i < l; i++) {
5027 63000 : y = gel(v, l - i);
5028 63000 : ly = lgefint(y);
5029 63000 : switch (ly) {
5030 0 : case 2: x[i] = 0; break;
5031 7849 : case 3: x[i] = *int_W_lg(y, 0, ly) % p; break;
5032 31574 : case 4: x[i] = remll_pre(*int_W_lg(y, 1, ly), *int_W_lg(y, 0, ly), p, pi); break;
5033 47154 : case 5: x[i] = remlll_pre(*int_W_lg(y, 2, ly), *int_W_lg(y, 1, ly),
5034 47154 : *int_W_lg(y, 0, ly), p, pi); break;
5035 0 : default: x[i] = umodiu(gel(v, l - i), p);
5036 : }
5037 : }
5038 7000 : return Flx_renormalize(x, l);
5039 : }
5040 :
5041 : static GEN
5042 17808 : FlxM_pack_ZM(GEN M, GEN (*pack)(GEN, long)) {
5043 : long i, j, l, lc;
5044 17808 : GEN N = cgetg_copy(M, &l), x;
5045 17808 : if (l == 1)
5046 0 : return N;
5047 17808 : lc = lgcols(M);
5048 121548 : for (j = 1; j < l; j++) {
5049 103740 : gel(N, j) = cgetg(lc, t_COL);
5050 453348 : for (i = 1; i < lc; i++) {
5051 349608 : x = gcoeff(M, i, j);
5052 349608 : gcoeff(N, i, j) = pack(x + 2, lgpol(x));
5053 : }
5054 : }
5055 17808 : return N;
5056 : }
5057 :
5058 : static GEN
5059 1797 : FlxM_pack_ZM_bits(GEN M, long b)
5060 : {
5061 : long i, j, l, lc;
5062 1797 : GEN N = cgetg_copy(M, &l), x;
5063 1797 : if (l == 1)
5064 0 : return N;
5065 1797 : lc = lgcols(M);
5066 12830 : for (j = 1; j < l; j++) {
5067 11033 : gel(N, j) = cgetg(lc, t_COL);
5068 59413 : for (i = 1; i < lc; i++) {
5069 48380 : x = gcoeff(M, i, j);
5070 48380 : gcoeff(N, i, j) = kron_pack_Flx_spec_bits(x + 2, b, lgpol(x));
5071 : }
5072 : }
5073 1797 : return N;
5074 : }
5075 :
5076 : static GEN
5077 8904 : ZM_unpack_FlxqM(GEN M, GEN T, ulong p, GEN (*unpack)(GEN, ulong))
5078 : {
5079 8904 : long i, j, l, lc, sv = get_Flx_var(T);
5080 8904 : GEN N = cgetg_copy(M, &l), x;
5081 8904 : if (l == 1)
5082 0 : return N;
5083 8904 : lc = lgcols(M);
5084 86352 : for (j = 1; j < l; j++) {
5085 77448 : gel(N, j) = cgetg(lc, t_COL);
5086 281001 : for (i = 1; i < lc; i++) {
5087 203553 : x = unpack(gcoeff(M, i, j), p);
5088 203553 : x[1] = sv;
5089 203553 : gcoeff(N, i, j) = Flx_rem(x, T, p);
5090 : }
5091 : }
5092 8904 : return N;
5093 : }
5094 :
5095 : static GEN
5096 912 : ZM_unpack_FlxqM_bits(GEN M, long b, GEN T, ulong p)
5097 : {
5098 912 : long i, j, l, lc, sv = get_Flx_var(T);
5099 912 : GEN N = cgetg_copy(M, &l), x;
5100 912 : if (l == 1)
5101 0 : return N;
5102 912 : lc = lgcols(M);
5103 912 : if (b < BITS_IN_LONG) {
5104 7827 : for (j = 1; j < l; j++) {
5105 6985 : gel(N, j) = cgetg(lc, t_COL);
5106 22977 : for (i = 1; i < lc; i++) {
5107 15992 : x = kron_unpack_Flx_bits_narrow(gcoeff(M, i, j), b, p);
5108 15992 : x[1] = sv;
5109 15992 : gcoeff(N, i, j) = Flx_rem(x, T, p);
5110 : }
5111 : }
5112 : } else {
5113 70 : ulong pi = get_Fl_red(p);
5114 770 : for (j = 1; j < l; j++) {
5115 700 : gel(N, j) = cgetg(lc, t_COL);
5116 7700 : for (i = 1; i < lc; i++) {
5117 7000 : x = kron_unpack_Flx_bits_wide(gcoeff(M, i, j), b, p, pi);
5118 7000 : x[1] = sv;
5119 7000 : gcoeff(N, i, j) = Flx_rem(x, T, p);
5120 : }
5121 : }
5122 : }
5123 912 : return N;
5124 : }
5125 :
5126 : GEN
5127 9816 : FlxqM_mul_Kronecker(GEN A, GEN B, GEN T, ulong p)
5128 : {
5129 9816 : pari_sp av = avma;
5130 9816 : long b, d = degpol(T), n = lg(A) - 1;
5131 : GEN C, D, z;
5132 : GEN (*pack)(GEN, long), (*unpack)(GEN, ulong);
5133 9816 : int is_sqr = A==B;
5134 :
5135 9816 : z = muliu(muliu(sqru(p - 1), d), n);
5136 9816 : b = expi(z) + 1;
5137 : /* only do expensive bit-packing if it saves at least 1 limb */
5138 9816 : if (b <= BITS_IN_HALFULONG) {
5139 9383 : if (nbits2lg(d*b) - 2 == (d + 1)/2)
5140 8576 : b = BITS_IN_HALFULONG;
5141 : } else {
5142 433 : long l = lgefint(z) - 2;
5143 433 : if (nbits2lg(d*b) - 2 == d*l)
5144 328 : b = l*BITS_IN_LONG;
5145 : }
5146 9816 : avma = av;
5147 :
5148 9816 : switch (b) {
5149 : case BITS_IN_HALFULONG:
5150 8576 : pack = kron_pack_Flx_spec_half;
5151 8576 : unpack = int_to_Flx_half;
5152 8576 : break;
5153 : case BITS_IN_LONG:
5154 328 : pack = kron_pack_Flx_spec;
5155 328 : unpack = kron_unpack_Flx;
5156 328 : break;
5157 : case 2*BITS_IN_LONG:
5158 0 : pack = kron_pack_Flx_spec_2;
5159 0 : unpack = kron_unpack_Flx_2;
5160 0 : break;
5161 : case 3*BITS_IN_LONG:
5162 0 : pack = kron_pack_Flx_spec_3;
5163 0 : unpack = kron_unpack_Flx_3;
5164 0 : break;
5165 : default:
5166 912 : A = FlxM_pack_ZM_bits(A, b);
5167 912 : B = is_sqr? A: FlxM_pack_ZM_bits(B, b);
5168 912 : C = ZM_mul(A, B);
5169 912 : D = ZM_unpack_FlxqM_bits(C, b, T, p);
5170 912 : return gerepilecopy(av, D);
5171 : }
5172 8904 : A = FlxM_pack_ZM(A, pack);
5173 8904 : B = is_sqr? A: FlxM_pack_ZM(B, pack);
5174 8904 : C = ZM_mul(A, B);
5175 8904 : D = ZM_unpack_FlxqM(C, T, p, unpack);
5176 8904 : return gerepilecopy(av, D);
5177 : }
5178 :
5179 : /*******************************************************************/
5180 : /* */
5181 : /* (Fl[X]/T(X))[Y] / S(Y) */
5182 : /* */
5183 : /*******************************************************************/
5184 :
5185 : GEN
5186 300560 : FlxqXQ_mul(GEN x, GEN y, GEN S, GEN T, ulong p) {
5187 300560 : return FlxqX_rem(FlxqX_mul(x,y,T,p),S,T,p);
5188 : }
5189 :
5190 : GEN
5191 183766 : FlxqXQ_sqr(GEN x, GEN S, GEN T, ulong p) {
5192 183766 : return FlxqX_rem(FlxqX_sqr(x,T,p),S,T,p);
5193 : }
5194 :
5195 : GEN
5196 14 : FlxqXQ_invsafe(GEN x, GEN S, GEN T, ulong p)
5197 : {
5198 14 : GEN V, z = FlxqX_extgcd(get_FlxqX_mod(S), x, T, p, NULL, &V);
5199 14 : if (degpol(z)) return NULL;
5200 14 : z = Flxq_invsafe(gel(z,2),T,p);
5201 14 : if (!z) return NULL;
5202 14 : return FlxqX_Flxq_mul(V, z, T, p);
5203 : }
5204 :
5205 : GEN
5206 14 : FlxqXQ_inv(GEN x, GEN S, GEN T,ulong p)
5207 : {
5208 14 : pari_sp av = avma;
5209 14 : GEN U = FlxqXQ_invsafe(x, S, T, p);
5210 14 : if (!U) pari_err_INV("FlxqXQ_inv",x);
5211 14 : return gerepileupto(av, U);
5212 : }
5213 :
5214 : GEN
5215 0 : FlxqXQ_div(GEN x, GEN y, GEN S, GEN T, ulong p) {
5216 0 : return FlxqXQ_mul(x, FlxqXQ_inv(y,S,T,p),S,T,p);
5217 : }
5218 :
5219 : struct _FlxqXQ {
5220 : GEN T, S;
5221 : ulong p;
5222 : };
5223 : static GEN
5224 497960 : _FlxqXQ_add(void *data, GEN x, GEN y) {
5225 497960 : struct _FlxqXQ *d = (struct _FlxqXQ*) data;
5226 497960 : return FlxX_add(x,y, d->p);
5227 : }
5228 : static GEN
5229 2338 : _FlxqXQ_sub(void *data, GEN x, GEN y) {
5230 2338 : struct _FlxqXQ *d = (struct _FlxqXQ*) data;
5231 2338 : return FlxX_sub(x,y, d->p);
5232 : }
5233 : static GEN
5234 616402 : _FlxqXQ_cmul(void *data, GEN P, long a, GEN x) {
5235 616402 : struct _FlxqXQ *d = (struct _FlxqXQ*) data;
5236 616402 : return FlxX_Flx_mul(x,gel(P,a+2), d->p);
5237 : }
5238 : static GEN
5239 339539 : _FlxqXQ_red(void *data, GEN x) {
5240 339539 : struct _FlxqXQ *d = (struct _FlxqXQ*) data;
5241 339539 : return FlxqX_red(x, d->T, d->p);
5242 : }
5243 : static GEN
5244 270596 : _FlxqXQ_mul(void *data, GEN x, GEN y) {
5245 270596 : struct _FlxqXQ *d = (struct _FlxqXQ*) data;
5246 270596 : return FlxqXQ_mul(x,y, d->S,d->T, d->p);
5247 : }
5248 : static GEN
5249 183395 : _FlxqXQ_sqr(void *data, GEN x) {
5250 183395 : struct _FlxqXQ *d = (struct _FlxqXQ*) data;
5251 183395 : return FlxqXQ_sqr(x, d->S,d->T, d->p);
5252 : }
5253 :
5254 : static GEN
5255 350313 : _FlxqXQ_one(void *data) {
5256 350313 : struct _FlxqXQ *d = (struct _FlxqXQ*) data;
5257 350313 : return pol1_FlxX(get_FlxqX_var(d->S),get_Flx_var(d->T));
5258 : }
5259 :
5260 : static GEN
5261 170 : _FlxqXQ_zero(void *data) {
5262 170 : struct _FlxqXQ *d = (struct _FlxqXQ*) data;
5263 170 : return pol_0(get_FlxqX_var(d->S));
5264 : }
5265 :
5266 : static struct bb_algebra FlxqXQ_algebra = { _FlxqXQ_red, _FlxqXQ_add,
5267 : _FlxqXQ_sub, _FlxqXQ_mul, _FlxqXQ_sqr, _FlxqXQ_one, _FlxqXQ_zero };
5268 :
5269 : const struct bb_algebra *
5270 205 : get_FlxqXQ_algebra(void **E, GEN S, GEN T, ulong p)
5271 : {
5272 205 : GEN z = new_chunk(sizeof(struct _FlxqXQ));
5273 205 : struct _FlxqXQ *e = (struct _FlxqXQ *) z;
5274 205 : e->T = Flx_get_red(T, p);
5275 205 : e->S = FlxqX_get_red(S, e->T, p);
5276 205 : e->p = p; *E = (void*)e;
5277 205 : return &FlxqXQ_algebra;
5278 : }
5279 :
5280 : /* x over Fq, return lift(x^n) mod S */
5281 : GEN
5282 21 : FlxqXQ_pow(GEN x, GEN n, GEN S, GEN T, ulong p)
5283 : {
5284 : struct _FlxqXQ D;
5285 21 : long s = signe(n);
5286 21 : if (!s) return pol1_FlxX(get_FlxqX_var(S),get_Flx_var(T));
5287 21 : if (s < 0) x = FlxqXQ_inv(x,S,T,p);
5288 21 : if (is_pm1(n)) return s < 0 ? x : gcopy(x);
5289 21 : if (degpol(x)>=degpol(S)) x = FlxqX_rem(x,S,T,p);
5290 21 : T = Flx_get_red(T, p);
5291 21 : S = FlxqX_get_red(S, T, p);
5292 21 : D.S = S;
5293 21 : D.T = T;
5294 21 : D.p = p;
5295 21 : return gen_pow(x, n, (void*)&D, &_FlxqXQ_sqr, &_FlxqXQ_mul);
5296 : }
5297 :
5298 : /* x over Fq, return lift(x^n) mod S */
5299 : GEN
5300 71485 : FlxqXQ_powu(GEN x, ulong n, GEN S, GEN T, ulong p)
5301 : {
5302 : struct _FlxqXQ D;
5303 71485 : switch(n)
5304 : {
5305 0 : case 0: return pol1_FlxX(get_FlxqX_var(S),get_Flx_var(T));
5306 7294 : case 1: return gcopy(x);
5307 371 : case 2: return FlxqXQ_sqr(x, S, T, p);
5308 : }
5309 63820 : T = Flx_get_red(T, p);
5310 63820 : S = FlxqX_get_red(S, T, p);
5311 63820 : D.S = S; D.T = T; D.p = p;
5312 63820 : return gen_powu(x, n, (void*)&D, &_FlxqXQ_sqr, &_FlxqXQ_mul);
5313 : }
5314 :
5315 : GEN
5316 28302 : FlxqXQ_powers(GEN x, long l, GEN S, GEN T, ulong p)
5317 : {
5318 : struct _FlxqXQ D;
5319 28302 : int use_sqr = 2*degpol(x) >= get_FlxqX_degree(S);
5320 28302 : T = Flx_get_red(T, p);
5321 28302 : S = FlxqX_get_red(S, T, p);
5322 28302 : D.S = S; D.T = T; D.p = p;
5323 28302 : return gen_powers(x, l, use_sqr, (void*)&D, &_FlxqXQ_sqr, &_FlxqXQ_mul,&_FlxqXQ_one);
5324 : }
5325 :
5326 : static GEN
5327 500 : FlxqXn_mul(GEN a, GEN b, long n, GEN T, ulong p)
5328 : {
5329 500 : return RgXn_red_shallow(FlxqX_mul(a, b, T, p), n);
5330 : }
5331 :
5332 : /* Let v a linear form, return the linear form z->v(tau*z)
5333 : that is, v*(M_tau) */
5334 :
5335 : static GEN
5336 320 : FlxqXQ_transmul_init(GEN tau, GEN S, GEN T, ulong p)
5337 : {
5338 : GEN bht;
5339 320 : GEN h, Sp = get_FlxqX_red(S, &h);
5340 320 : long n = degpol(Sp), vS = varn(Sp), vT = get_Flx_var(T);
5341 320 : GEN ft = FlxX_recipspec(Sp+2, n+1, n+1, vT);
5342 320 : GEN bt = FlxX_recipspec(tau+2, lgpol(tau), n, vT);
5343 320 : setvarn(ft, vS); setvarn(bt, vS);
5344 320 : if (h)
5345 0 : bht = FlxqXn_mul(bt, h, n-1, T, p);
5346 : else
5347 : {
5348 320 : GEN bh = FlxqX_div(RgX_shift_shallow(tau, n-1), S, T, p);
5349 320 : bht = FlxX_recipspec(bh+2, lgpol(bh), n-1, vT);
5350 320 : setvarn(bht, vS);
5351 : }
5352 320 : return mkvec3(bt, bht, ft);
5353 : }
5354 :
5355 : static GEN
5356 639 : FlxqXQ_transmul(GEN tau, GEN a, long n, GEN T, ulong p)
5357 : {
5358 639 : pari_sp ltop = avma;
5359 : GEN t1, t2, t3, vec;
5360 639 : GEN bt = gel(tau, 1), bht = gel(tau, 2), ft = gel(tau, 3);
5361 639 : if (signe(a)==0) return pol_0(varn(a));
5362 639 : t2 = RgX_shift_shallow(FlxqX_mul(bt, a, T, p),1-n);
5363 639 : if (signe(bht)==0) return gerepilecopy(ltop, t2);
5364 500 : t1 = RgX_shift_shallow(FlxqX_mul(ft, a, T, p),-n);
5365 500 : t3 = FlxqXn_mul(t1, bht, n-1, T, p);
5366 500 : vec = FlxX_sub(t2, RgX_shift_shallow(t3, 1), p);
5367 500 : return gerepileupto(ltop, vec);
5368 : }
5369 :
5370 : static GEN
5371 160 : polxn_FlxX(long n, long v, long vT)
5372 : {
5373 160 : long i, a = n+2;
5374 160 : GEN p = cgetg(a+1, t_POL);
5375 160 : p[1] = evalsigne(1)|evalvarn(v);
5376 160 : for (i = 2; i < a; i++) gel(p,i) = pol0_Flx(vT);
5377 160 : gel(p,a) = pol1_Flx(vT); return p;
5378 : }
5379 :
5380 : GEN
5381 139 : FlxqXQ_minpoly(GEN x, GEN S, GEN T, ulong p)
5382 : {
5383 139 : pari_sp ltop = avma;
5384 : long vS, vT, n;
5385 : GEN v_x, g, tau;
5386 139 : vS = get_FlxqX_var(S);
5387 139 : vT = get_Flx_var(T);
5388 139 : n = get_FlxqX_degree(S);
5389 139 : g = pol_1(vS);
5390 139 : tau = pol_1(vS);
5391 139 : S = FlxqX_get_red(S, T, p);
5392 139 : v_x = FlxqXQ_powers(x, usqrt(2*n), S, T, p);
5393 438 : while(signe(tau) != 0)
5394 : {
5395 : long i, j, m, k1;
5396 : GEN M, v, tr;
5397 : GEN g_prime, c;
5398 160 : if (degpol(g) == n) { tau = pol1_FlxX(vS, vT); g = pol1_FlxX(vS, vT); }
5399 160 : v = random_FlxqX(n, vS, T, p);
5400 160 : tr = FlxqXQ_transmul_init(tau, S, T, p);
5401 160 : v = FlxqXQ_transmul(tr, v, n, T, p);
5402 160 : m = 2*(n-degpol(g));
5403 160 : k1 = usqrt(m);
5404 160 : tr = FlxqXQ_transmul_init(gel(v_x,k1+1), S, T, p);
5405 160 : c = cgetg(m+2,t_POL);
5406 160 : c[1] = evalsigne(1)|evalvarn(vS);
5407 639 : for (i=0; i<m; i+=k1)
5408 : {
5409 479 : long mj = minss(m-i, k1);
5410 1447 : for (j=0; j<mj; j++)
5411 968 : gel(c,m+1-(i+j)) = FlxqX_dotproduct(v, gel(v_x,j+1), T, p);
5412 479 : v = FlxqXQ_transmul(tr, v, n, T, p);
5413 : }
5414 160 : c = FlxX_renormalize(c, m+2);
5415 : /* now c contains <v,x^i> , i = 0..m-1 */
5416 160 : M = FlxqX_halfgcd(polxn_FlxX(m, vS, vT), c, T, p);
5417 160 : g_prime = gmael(M, 2, 2);
5418 160 : if (degpol(g_prime) < 1) continue;
5419 160 : g = FlxqX_mul(g, g_prime, T, p);
5420 160 : tau = FlxqXQ_mul(tau, FlxqX_FlxqXQV_eval(g_prime, v_x, S, T, p), S, T, p);
5421 : }
5422 139 : g = FlxqX_normalize(g,T, p);
5423 139 : return gerepilecopy(ltop,g);
5424 : }
5425 :
5426 : GEN
5427 0 : FlxqXQ_matrix_pow(GEN y, long n, long m, GEN S, GEN T, ulong p)
5428 : {
5429 0 : return FlxXV_to_FlxM(FlxqXQ_powers(y,m-1,S,T,p), n, T[1]);
5430 : }
5431 :
5432 : GEN
5433 56003 : FlxqX_FlxqXQV_eval(GEN P, GEN V, GEN S, GEN T, ulong p)
5434 : {
5435 : struct _FlxqXQ D;
5436 56003 : T = Flx_get_red(T, p);
5437 56003 : S = FlxqX_get_red(S, T, p);
5438 56003 : D.S=S; D.T=T; D.p=p;
5439 56003 : return gen_bkeval_powers(P, degpol(P), V, (void*)&D, &FlxqXQ_algebra,
5440 : _FlxqXQ_cmul);
5441 : }
5442 :
5443 : GEN
5444 62439 : FlxqX_FlxqXQ_eval(GEN Q, GEN x, GEN S, GEN T, ulong p)
5445 : {
5446 : struct _FlxqXQ D;
5447 62439 : int use_sqr = 2*degpol(x) >= degpol(S);
5448 62439 : T = Flx_get_red(T, p);
5449 62439 : S = FlxqX_get_red(S, T, p);
5450 62439 : D.S=S; D.T=T; D.p=p;
5451 62439 : return gen_bkeval(Q, degpol(Q), x, use_sqr, (void*)&D, &FlxqXQ_algebra,
5452 : _FlxqXQ_cmul);
5453 : }
5454 :
5455 : static GEN
5456 61357 : FlxqXQ_autpow_sqr(void * E, GEN x)
5457 : {
5458 61357 : struct _FlxqXQ *D = (struct _FlxqXQ *)E;
5459 61357 : GEN S = D->S, T = D->T;
5460 61357 : ulong p = D->p;
5461 61357 : GEN phi = gel(x,1), S1 = gel(x,2);
5462 61357 : long n = brent_kung_optpow(get_Flx_degree(T)-1,lgpol(S1)+1,1);
5463 61357 : GEN V = Flxq_powers(phi, n, T, p);
5464 61357 : GEN phi2 = Flx_FlxqV_eval(phi, V, T, p);
5465 61357 : GEN Sphi = FlxY_FlxqV_evalx(S1, V, T, p);
5466 61357 : GEN S2 = FlxqX_FlxqXQ_eval(Sphi, S1, S, T, p);
5467 61357 : return mkvec2(phi2, S2);
5468 : }
5469 :
5470 : static GEN
5471 853 : FlxqXQ_autpow_mul(void * E, GEN x, GEN y)
5472 : {
5473 853 : struct _FlxqXQ *D = (struct _FlxqXQ *)E;
5474 853 : GEN S = D->S, T = D->T;
5475 853 : ulong p = D->p;
5476 853 : GEN phi1 = gel(x,1), S1 = gel(x,2);
5477 853 : GEN phi2 = gel(y,1), S2 = gel(y,2);
5478 853 : long n = brent_kung_optpow(get_Flx_degree(T)-1,lgpol(S1)+1,1);
5479 853 : GEN V = Flxq_powers(phi2, n, T, p);
5480 853 : GEN phi3 = Flx_FlxqV_eval(phi1, V, T, p);
5481 853 : GEN Sphi = FlxY_FlxqV_evalx(S1, V, T, p);
5482 853 : GEN S3 = FlxqX_FlxqXQ_eval(Sphi, S2, S, T, p);
5483 853 : return mkvec2(phi3, S3);
5484 : }
5485 :
5486 : GEN
5487 60566 : FlxqXQ_autpow(GEN aut, long n, GEN S, GEN T, ulong p)
5488 : {
5489 : struct _FlxqXQ D;
5490 60566 : T = Flx_get_red(T, p);
5491 60566 : S = FlxqX_get_red(S, T, p);
5492 60566 : D.S=S; D.T=T; D.p=p;
5493 60566 : return gen_powu(aut,n,&D,FlxqXQ_autpow_sqr,FlxqXQ_autpow_mul);
5494 : }
5495 :
5496 : static GEN
5497 27615 : FlxqXQ_autsum_mul(void *E, GEN x, GEN y)
5498 : {
5499 27615 : struct _FlxqXQ *D = (struct _FlxqXQ *)E;
5500 27615 : GEN S = D->S, T = D->T;
5501 27615 : ulong p = D->p;
5502 27615 : GEN phi1 = gel(x,1), S1 = gel(x,2), a1 = gel(x,3);
5503 27615 : GEN phi2 = gel(y,1), S2 = gel(y,2), a2 = gel(y,3);
5504 27615 : long n2 = brent_kung_optpow(get_Flx_degree(T)-1, lgpol(S1)+lgpol(a1)+1,1);
5505 27615 : GEN V2 = Flxq_powers(phi2, n2, T, p);
5506 27615 : GEN phi3 = Flx_FlxqV_eval(phi1, V2, T, p);
5507 27615 : GEN Sphi = FlxY_FlxqV_evalx(S1, V2, T, p);
5508 27615 : GEN aphi = FlxY_FlxqV_evalx(a1, V2, T, p);
5509 27615 : long n = brent_kung_optpow(maxss(degpol(Sphi),degpol(aphi)),2,1);
5510 27615 : GEN V = FlxqXQ_powers(S2, n, S, T, p);
5511 27615 : GEN S3 = FlxqX_FlxqXQV_eval(Sphi, V, S, T, p);
5512 27615 : GEN aS = FlxqX_FlxqXQV_eval(aphi, V, S, T, p);
5513 27615 : GEN a3 = FlxqXQ_mul(aS, a2, S, T, p);
5514 27615 : return mkvec3(phi3, S3, a3);
5515 : }
5516 :
5517 : static GEN
5518 16674 : FlxqXQ_autsum_sqr(void * T, GEN x)
5519 16674 : { return FlxqXQ_autsum_mul(T, x, x); }
5520 :
5521 : GEN
5522 10509 : FlxqXQ_autsum(GEN aut, long n, GEN S, GEN T, ulong p)
5523 : {
5524 : struct _FlxqXQ D;
5525 10509 : T = Flx_get_red(T, p);
5526 10509 : S = FlxqX_get_red(S, T, p);
5527 10509 : D.S=S; D.T=T; D.p=p;
5528 10509 : return gen_powu(aut,n,&D,FlxqXQ_autsum_sqr,FlxqXQ_autsum_mul);
5529 : }
5530 :
5531 : static GEN
5532 20 : FlxqXQ_auttrace_mul(void *E, GEN x, GEN y)
5533 : {
5534 20 : struct _FlxqXQ *D = (struct _FlxqXQ *)E;
5535 20 : GEN S = D->S, T = D->T;
5536 20 : ulong p = D->p;
5537 20 : GEN S1 = gel(x,1), a1 = gel(x,2);
5538 20 : GEN S2 = gel(y,1), a2 = gel(y,2);
5539 20 : long n = brent_kung_optpow(maxss(degpol(S1),degpol(a1)),2,1);
5540 20 : GEN V = FlxqXQ_powers(S2, n, S, T, p);
5541 20 : GEN S3 = FlxqX_FlxqXQV_eval(S1, V, S, T, p);
5542 20 : GEN aS = FlxqX_FlxqXQV_eval(a1, V, S, T, p);
5543 20 : GEN a3 = FlxX_add(aS, a2, p);
5544 20 : return mkvec2(S3, a3);
5545 : }
5546 :
5547 : static GEN
5548 20 : FlxqXQ_auttrace_sqr(void *E, GEN x)
5549 20 : { return FlxqXQ_auttrace_mul(E, x, x); }
5550 :
5551 : GEN
5552 139 : FlxqXQ_auttrace(GEN x, ulong n, GEN S, GEN T, ulong p)
5553 : {
5554 : struct _FlxqXQ D;
5555 139 : T = Flx_get_red(T, p);
5556 139 : S = FlxqX_get_red(S, T, p);
5557 139 : D.S=S; D.T=T; D.p=p;
5558 139 : return gen_powu(x,n,(void*)&D,FlxqXQ_auttrace_sqr,FlxqXQ_auttrace_mul);
5559 : }
5560 :
5561 : /*******************************************************************/
5562 : /* */
5563 : /* FlxYqQ */
5564 : /* */
5565 : /*******************************************************************/
5566 :
5567 : /*Preliminary implementation to speed up FpX_ffisom*/
5568 : typedef struct {
5569 : GEN S, T;
5570 : ulong p;
5571 : } FlxYqq_muldata;
5572 :
5573 : /* reduce x in Fl[X, Y] in the algebra Fl[X, Y]/ (P(X),Q(Y)) */
5574 : static GEN
5575 6454 : FlxYqq_redswap(GEN x, GEN S, GEN T, ulong p)
5576 : {
5577 6454 : pari_sp ltop=avma;
5578 6454 : long n = get_Flx_degree(S);
5579 6454 : long m = get_Flx_degree(T);
5580 6454 : long w = get_Flx_var(T);
5581 6454 : GEN V = FlxX_swap(x,m,w);
5582 6454 : V = FlxqX_red(V,S,p);
5583 6454 : V = FlxX_swap(V,n,w);
5584 6454 : return gerepilecopy(ltop,V);
5585 : }
5586 : static GEN
5587 4298 : FlxYqq_sqr(void *data, GEN x)
5588 : {
5589 4298 : FlxYqq_muldata *D = (FlxYqq_muldata*)data;
5590 4298 : return FlxYqq_redswap(FlxqX_sqr(x, D->T, D->p),D->S,D->T,D->p);
5591 : }
5592 :
5593 : static GEN
5594 2156 : FlxYqq_mul(void *data, GEN x, GEN y)
5595 : {
5596 2156 : FlxYqq_muldata *D = (FlxYqq_muldata*)data;
5597 2156 : return FlxYqq_redswap(FlxqX_mul(x,y, D->T, D->p),D->S,D->T,D->p);
5598 : }
5599 :
5600 : /* x in Z[X,Y], S in Z[X] over Fq = Z[Y]/(p,T); compute lift(x^n mod (S,T,p)) */
5601 : GEN
5602 2632 : FlxYqq_pow(GEN x, GEN n, GEN S, GEN T, ulong p)
5603 : {
5604 2632 : pari_sp av = avma;
5605 : FlxYqq_muldata D;
5606 : GEN y;
5607 2632 : D.S = S;
5608 2632 : D.T = T;
5609 2632 : D.p = p;
5610 2632 : y = gen_pow(x, n, (void*)&D, &FlxYqq_sqr, &FlxYqq_mul);
5611 2632 : return gerepileupto(av, y);
5612 : }
|
