Branch data Line data Source code
1 : : /* Copyright (C) 2000-2010 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 : : /*******************************************************************/
15 : : /* */
16 : : /* CONSTRUCTORS */
17 : : /* */
18 : : /*******************************************************************/
19 : : #define retmkfrac(x,y)\
20 : : do { GEN _v = cgetg(3, t_FRAC);\
21 : : gel(_v,1) = (x);\
22 : : gel(_v,2) = (y); return _v; } while(0)
23 : : #define retmkintmod(x,y)\
24 : : do { GEN _v = cgetg(3, t_INTMOD);\
25 : : gel(_v,1) = (y);\
26 : : gel(_v,2) = (x); return _v; } while(0)
27 : : #define retmkcomplex(x,y)\
28 : : do { GEN _v = cgetg(3, t_COMPLEX);\
29 : : gel(_v,1) = (x);\
30 : : gel(_v,2) = (y); return _v; } while(0)
31 : : #define retmkpolmod(x,y)\
32 : : do { GEN _v = cgetg(3, t_POLMOD);\
33 : : gel(_v,1) = (y);\
34 : : gel(_v,2) = (x); return _v; } while(0)
35 : : #define retmkvec(x)\
36 : : do { GEN _v = cgetg(2, t_VEC);\
37 : : gel(_v,1) = (x); return _v; } while(0)
38 : : #define retmkvec2(x,y)\
39 : : do { GEN _v = cgetg(3, t_VEC);\
40 : : gel(_v,1) = (x);\
41 : : gel(_v,2) = (y); return _v; } while(0)
42 : : #define retmkvec3(x,y,z)\
43 : : do { GEN _v = cgetg(4, t_VEC);\
44 : : gel(_v,1) = (x);\
45 : : gel(_v,2) = (y);\
46 : : gel(_v,3) = (z); return _v; } while(0)
47 : : #define retmkqfi(x,y,z)\
48 : : do { GEN _v = cgetg(4, t_QFI);\
49 : : gel(_v,1) = (x);\
50 : : gel(_v,2) = (y);\
51 : : gel(_v,3) = (z); return _v; } while(0)
52 : : #define retmkqfr(x,y,z,d)\
53 : : do { GEN _v = cgetg(5, t_QFR);\
54 : : gel(_v,1) = (x);\
55 : : gel(_v,2) = (y);\
56 : : gel(_v,3) = (z);\
57 : : gel(_v,4) = (d); return _v; } while(0)
58 : : #define retmkquad(x,y,z)\
59 : : do { GEN _v = cgetg(4, t_QUAD);\
60 : : gel(_v,1) = (x);\
61 : : gel(_v,2) = (y);\
62 : : gel(_v,3) = (z); return _v; } while(0)
63 : : #define retmkvec4(x,y,z,t)\
64 : : do { GEN _v = cgetg(5, t_VEC);\
65 : : gel(_v,1) = (x);\
66 : : gel(_v,2) = (y);\
67 : : gel(_v,3) = (z);\
68 : : gel(_v,4) = (t); return _v; } while(0)
69 : : #define retmkvec5(x,y,z,t,u)\
70 : : do { GEN _v = cgetg(6, t_VEC);\
71 : : gel(_v,1) = (x);\
72 : : gel(_v,2) = (y);\
73 : : gel(_v,3) = (z);\
74 : : gel(_v,4) = (t);\
75 : : gel(_v,5) = (u); return _v; } while(0)
76 : : #define retmkcol(x)\
77 : : do { GEN _v = cgetg(2, t_COL);\
78 : : gel(_v,1) = (x); return _v; } while(0)
79 : : #define retmkcol2(x,y)\
80 : : do { GEN _v = cgetg(3, t_COL);\
81 : : gel(_v,1) = (x);\
82 : : gel(_v,2) = (y); return _v; } while(0)
83 : : #define retmkcol3(x,y,z)\
84 : : do { GEN _v = cgetg(4, t_COL);\
85 : : gel(_v,1) = (x);\
86 : : gel(_v,2) = (y);\
87 : : gel(_v,3) = (z); return _v; } while(0)
88 : : #define retmkcol4(x,y,z,t)\
89 : : do { GEN _v = cgetg(5, t_COL);\
90 : : gel(_v,1) = (x);\
91 : : gel(_v,2) = (y);\
92 : : gel(_v,3) = (z);\
93 : : gel(_v,4) = (t); return _v; } while(0)
94 : : #define retmkcol5(x,y,z,t,u)\
95 : : do { GEN _v = cgetg(6, t_COL);\
96 : : gel(_v,1) = (x);\
97 : : gel(_v,2) = (y);\
98 : : gel(_v,3) = (z);\
99 : : gel(_v,4) = (t);\
100 : : gel(_v,5) = (u); return _v; } while(0)
101 : : #define retmkmat(x)\
102 : : do { GEN _v = cgetg(2, t_MAT);\
103 : : gel(_v,1) = (x); return _v; } while(0)
104 : : #define retmkmat2(x,y)\
105 : : do { GEN _v = cgetg(3, t_MAT);\
106 : : gel(_v,1) = (x);\
107 : : gel(_v,2) = (y); return _v; } while(0)
108 : : #define retmkmat3(x,y,z)\
109 : : do { GEN _v = cgetg(4, t_MAT);\
110 : : gel(_v,1) = (x);\
111 : : gel(_v,2) = (y);\
112 : : gel(_v,3) = (z); return _v; } while(0)
113 : : #define retmkmat4(x,y,z,t)\
114 : : do { GEN _v = cgetg(5, t_MAT);\
115 : : gel(_v,1) = (x);\
116 : : gel(_v,2) = (y);\
117 : : gel(_v,3) = (z);\
118 : : gel(_v,4) = (t); return _v; } while(0)
119 : : #define retmkmat5(x,y,z,t,u)\
120 : : do { GEN _v = cgetg(6, t_MAT);\
121 : : gel(_v,1) = (x);\
122 : : gel(_v,2) = (y);\
123 : : gel(_v,3) = (z);\
124 : : gel(_v,4) = (t);\
125 : : gel(_v,5) = (u); return _v; } while(0)
126 : :
127 : : INLINE GEN
128 : 212061 : mkintmod(GEN x, GEN y) { retmkintmod(x,y); }
129 : : INLINE GEN
130 : 2040 : mkintmodu(ulong x, ulong y) {
131 : 2040 : GEN v = cgetg(3,t_INTMOD);
132 : 2040 : gel(v,1) = utoipos(y);
133 : 2040 : gel(v,2) = utoi(x); return v;
134 : : }
135 : : INLINE GEN
136 : 36107 : mkpolmod(GEN x, GEN y) { retmkpolmod(x,y); }
137 : : INLINE GEN
138 : 21619 : mkfrac(GEN x, GEN y) { retmkfrac(x,y); }
139 : : INLINE GEN
140 : 780514 : mkfraccopy(GEN x, GEN y) { retmkfrac(icopy(x), icopy(y)); }
141 : : INLINE GEN
142 : 2712 : mkrfrac(GEN x, GEN y) { GEN v = cgetg(3, t_RFRAC);
143 : 2712 : gel(v,1) = x; gel(v,2) = y; return v; }
144 : : INLINE GEN
145 : 8 : mkrfraccopy(GEN x, GEN y) { GEN v = cgetg(3, t_RFRAC);
146 : 8 : gel(v,1) = gcopy(x); gel(v,2) = gcopy(y); return v; }
147 : : INLINE GEN
148 : 1782435 : mkcomplex(GEN x, GEN y) { retmkcomplex(x,y); }
149 : : INLINE GEN
150 : 95010 : gen_I(void) { return mkcomplex(gen_0, gen_1); }
151 : : INLINE GEN
152 : 32619 : cgetc(long l) { retmkcomplex(cgetr(l), cgetr(l)); }
153 : : INLINE GEN
154 : 36 : mkquad(GEN n, GEN x, GEN y) { GEN v = cgetg(4, t_QUAD);
155 : 36 : gel(v,1) = n; gel(v,2) = x; gel(v,3) = y; return v; }
156 : : /* vecsmall */
157 : : INLINE GEN
158 : 12529932 : mkvecsmall(long x) { GEN v = cgetg(2, t_VECSMALL); v[1] = x; return v; }
159 : : INLINE GEN
160 : 43051812 : mkvecsmall2(long x,long y) { GEN v = cgetg(3, t_VECSMALL);
161 : 43051812 : v[1]=x; v[2]=y; return v; }
162 : : INLINE GEN
163 : 16062595 : mkvecsmall3(long x,long y,long z) { GEN v = cgetg(4, t_VECSMALL);
164 : 16062595 : v[1]=x; v[2]=y; v[3]=z; return v; }
165 : : INLINE GEN
166 : 201861 : mkvecsmall4(long x,long y,long z,long t) { GEN v = cgetg(5, t_VECSMALL);
167 : 201861 : v[1]=x; v[2]=y; v[3]=z; v[4]=t; return v; }
168 : :
169 : : INLINE GEN
170 : 86416 : mkqfi(GEN x, GEN y, GEN z) { retmkqfi(x,y,z); }
171 : : /* vec */
172 : : INLINE GEN
173 : 907745 : mkvec(GEN x) { retmkvec(x); }
174 : : INLINE GEN
175 : 7588923 : mkvec2(GEN x, GEN y) { retmkvec2(x,y); }
176 : : INLINE GEN
177 : 11673694 : mkvec3(GEN x, GEN y, GEN z) { retmkvec3(x,y,z); }
178 : : INLINE GEN
179 : 1995473 : mkvec4(GEN x, GEN y, GEN z, GEN t) { retmkvec4(x,y,z,t); }
180 : : INLINE GEN
181 : 6632783 : mkvec5(GEN x, GEN y, GEN z, GEN t, GEN u) { retmkvec5(x,y,z,t,u); }
182 : : INLINE GEN
183 : 4 : mkvecs(long x) { retmkvec(stoi(x)); }
184 : : INLINE GEN
185 : 2612 : mkvec2s(long x, long y) { retmkvec2(stoi(x),stoi(y)); }
186 : : INLINE GEN
187 : 260972 : mkvec3s(long x, long y, long z) { retmkvec3(stoi(x),stoi(y),stoi(z)); }
188 : : INLINE GEN
189 : 4 : mkvec4s(long x, long y, long z, long t) { retmkvec4(stoi(x),stoi(y),stoi(z),stoi(t)); }
190 : : INLINE GEN
191 : 18376 : mkveccopy(GEN x) { GEN v = cgetg(2, t_VEC); gel(v,1) = gcopy(x); return v; }
192 : : INLINE GEN
193 : 91239 : mkvec2copy(GEN x, GEN y) {
194 : 91239 : GEN v = cgetg(3,t_VEC); gel(v,1) = gcopy(x); gel(v,2) = gcopy(y); return v; }
195 : : /* col */
196 : : INLINE GEN
197 : 306336 : mkcol(GEN x) { retmkcol(x); }
198 : : INLINE GEN
199 : 6158404 : mkcol2(GEN x, GEN y) { retmkcol2(x,y); }
200 : : INLINE GEN
201 : 0 : mkcol3(GEN x, GEN y, GEN z) { retmkcol3(x,y,z); }
202 : : INLINE GEN
203 : 0 : mkcol4(GEN x, GEN y, GEN z, GEN t) { retmkcol4(x,y,z,t); }
204 : : INLINE GEN
205 : 0 : mkcol5(GEN x, GEN y, GEN z, GEN t, GEN u) { retmkcol5(x,y,z,t,u); }
206 : : INLINE GEN
207 : 0 : mkcols(long x) { retmkcol(stoi(x)); }
208 : : INLINE GEN
209 : 0 : mkcol2s(long x, long y) { retmkcol2(stoi(x),stoi(y)); }
210 : : INLINE GEN
211 : 0 : mkcol3s(long x, long y, long z) { retmkcol3(stoi(x),stoi(y),stoi(z)); }
212 : : INLINE GEN
213 : 0 : mkcol4s(long x, long y, long z, long t) { retmkcol4(stoi(x),stoi(y),stoi(z),stoi(t)); }
214 : : INLINE GEN
215 : 14163 : mkcolcopy(GEN x) { GEN v = cgetg(2, t_COL); gel(v,1) = gcopy(x); return v; }
216 : : /* mat */
217 : : INLINE GEN
218 : 104507 : mkmat(GEN x) { retmkmat(x); }
219 : : INLINE GEN
220 : 4641689 : mkmat2(GEN x, GEN y) { retmkmat2(x,y); }
221 : : INLINE GEN
222 : 0 : mkmat3(GEN x, GEN y, GEN z) { retmkmat3(x,y,z); }
223 : : INLINE GEN
224 : 0 : mkmat4(GEN x, GEN y, GEN z, GEN t) { retmkmat4(x,y,z,t); }
225 : : INLINE GEN
226 : 0 : mkmat5(GEN x, GEN y, GEN z, GEN t, GEN u) { retmkmat5(x,y,z,t,u); }
227 : : INLINE GEN
228 : 2808 : mkmatcopy(GEN x) { GEN v = cgetg(2, t_MAT); gel(v,1) = gcopy(x); return v; }
229 : : INLINE GEN
230 : 0 : mkerr(long x) { GEN v = cgetg(2, t_ERROR); v[1] = x; return v; }
231 : : /* pol */
232 : : INLINE GEN
233 : 94658 : pol_x(long v) {
234 : 94658 : GEN p = cgetg(4, t_POL);
235 : 94658 : p[1] = evalsigne(1)|evalvarn(v);
236 : 94658 : gel(p,2) = gen_0;
237 : 94658 : gel(p,3) = gen_1; return p;
238 : : }
239 : : INLINE GEN
240 : 316261 : pol_1(long v) {
241 : 316261 : GEN p = cgetg(3, t_POL);
242 : 316261 : p[1] = evalsigne(1)|evalvarn(v);
243 : 316261 : gel(p,2) = gen_1; return p;
244 : : }
245 : : INLINE GEN
246 : 7013994 : pol_0(long v)
247 : : {
248 : 7013994 : GEN x = cgetg(2,t_POL);
249 : 7013994 : x[1] = evalvarn(v); return x;
250 : : }
251 : : #define retconst_vec(n,x)\
252 : : do { long _i, _n = (n);\
253 : : GEN _v = cgetg(n+1, t_VEC), _x = (x);\
254 : : for (_i = 1; _i <= _n; _i++) gel(_v,_i) = _x;\
255 : : return _v; } while(0)
256 : : INLINE GEN
257 [ + + ]: 17899537 : const_vec(long n, GEN x) { retconst_vec(n, x); }
258 : : #define retconst_col(n,x)\
259 : : do { long _i, _n = (n);\
260 : : GEN _v = cgetg(n+1, t_COL), _x = (x);\
261 : : for (_i = 1; _i <= _n; _i++) gel(_v,_i) = _x;\
262 : : return _v; } while(0)
263 : : INLINE GEN
264 [ + + ]: 20073 : const_col(long n, GEN x) { retconst_col(n, x); }
265 : : INLINE GEN
266 : 1999235 : const_vecsmall(long n, long c)
267 : : {
268 : : long i;
269 : 1999235 : GEN V = cgetg(n+1,t_VECSMALL);
270 [ + + ]: 8787206 : for(i=1;i<=n;i++) V[i] = c;
271 : 1999235 : return V;
272 : : }
273 : :
274 : : /*** ZERO ***/
275 : : /* O(p^e) */
276 : : INLINE GEN
277 : 3864 : zeropadic(GEN p, long e)
278 : : {
279 : 3864 : GEN y = cgetg(5,t_PADIC);
280 : 3864 : gel(y,4) = gen_0;
281 : 3864 : gel(y,3) = gen_1;
282 : 3864 : gel(y,2) = icopy(p);
283 : 3864 : y[1] = evalvalp(e) | _evalprecp(0);
284 : 3864 : return y;
285 : : }
286 : : INLINE GEN
287 : 160 : zeropadic_shallow(GEN p, long e)
288 : : {
289 : 160 : GEN y = cgetg(5,t_PADIC);
290 : 160 : gel(y,4) = gen_0;
291 : 160 : gel(y,3) = gen_1;
292 : 160 : gel(y,2) = p;
293 : 160 : y[1] = evalvalp(e) | _evalprecp(0);
294 : 160 : return y;
295 : : }
296 : : /* O(pol_x(v)^e) */
297 : : INLINE GEN
298 : 2528 : zeroser(long v, long e)
299 : : {
300 : 2528 : GEN x = cgetg(2, t_SER);
301 : 2528 : x[1] = evalvalp(e) | evalvarn(v); return x;
302 : : }
303 : : /* 0 * pol_x(v) */
304 : : INLINE GEN
305 : 2436621 : zeropol(long v) { return pol_0(v); }
306 : : /* vector(n) */
307 : : INLINE GEN
308 : 11078284 : zerocol(long n)
309 : : {
310 : 11078284 : GEN y = cgetg(n+1,t_COL);
311 [ + + ]: 81896151 : long i; for (i=1; i<=n; i++) gel(y,i) = gen_0;
312 : 11078284 : return y;
313 : : }
314 : : /* vectorv(n) */
315 : : INLINE GEN
316 : 3091753 : zerovec(long n)
317 : : {
318 : 3091753 : GEN y = cgetg(n+1,t_VEC);
319 [ + + ]: 28597030 : long i; for (i=1; i<=n; i++) gel(y,i) = gen_0;
320 : 3091753 : return y;
321 : : }
322 : : /* matrix(m, n) */
323 : : INLINE GEN
324 : 2942 : zeromat(long m, long n)
325 : : {
326 : 2942 : GEN y = cgetg(n+1,t_MAT);
327 : 2942 : GEN v = zerocol(m);
328 [ + + ]: 9926 : long i; for (i=1; i<=n; i++) gel(y,i) = v;
329 : 2942 : return y;
330 : : }
331 : : /* = zero_zx, sv is a evalvarn()*/
332 : : INLINE GEN
333 : 22630 : zero_Flx(long sv) { return pol0_Flx(sv); }
334 : : INLINE GEN
335 : 6753545 : zero_Flv(long n)
336 : : {
337 : 6753545 : GEN y = cgetg(n+1,t_VECSMALL);
338 [ + + ]: 239632873 : long i; for (i=1; i<=n; i++) y[i] = 0;
339 : 6753545 : return y;
340 : : }
341 : : /* matrix(m, n) */
342 : : INLINE GEN
343 : 80 : zero_Flm(long m, long n)
344 : : {
345 : 80 : GEN y = cgetg(n+1,t_MAT);
346 : 80 : GEN v = zero_Flv(m);
347 [ + + ]: 304 : long i; for (i=1; i<=n; i++) gel(y,i) = v;
348 : 80 : return y;
349 : : }
350 : : /* matrix(m, n) */
351 : : INLINE GEN
352 : 6476 : zero_Flm_copy(long m, long n)
353 : : {
354 : 6476 : GEN y = cgetg(n+1,t_MAT);
355 [ + + ]: 67224 : long i; for (i=1; i<=n; i++) gel(y,i) = zero_Flv(m);
356 : 6476 : return y;
357 : : }
358 : :
359 : : INLINE GEN
360 : 300252 : zero_F2v(long m)
361 : : {
362 : 300252 : long l = nbits2nlong(m);
363 : 300252 : GEN v = zero_Flv(l+1);
364 : 300252 : v[1] = m;
365 : 300252 : return v;
366 : : }
367 : :
368 : : INLINE GEN
369 : 0 : zero_F2m(long m, long n)
370 : : {
371 : : long i;
372 : 0 : GEN M = cgetg(n+1, t_MAT);
373 : 0 : GEN v = zero_F2v(m);
374 [ # # ]: 0 : for (i = 1; i <= n; i++)
375 : 0 : gel(M,i) = v;
376 : 0 : return M;
377 : : }
378 : :
379 : :
380 : : INLINE GEN
381 : 42736 : zero_F2m_copy(long m, long n)
382 : : {
383 : : long i;
384 : 42736 : GEN M = cgetg(n+1, t_MAT);
385 [ + + ]: 159924 : for (i = 1; i <= n; i++)
386 : 117188 : gel(M,i)= zero_F2v(m);
387 : 42736 : return M;
388 : : }
389 : :
390 : : /* matrix(m, n) */
391 : : INLINE GEN
392 : 1182214 : zeromatcopy(long m, long n)
393 : : {
394 : 1182214 : GEN y = cgetg(n+1,t_MAT);
395 [ + + ]: 5061667 : long i; for (i=1; i<=n; i++) gel(y,i) = zerocol(m);
396 : 1182214 : return y;
397 : : }
398 : :
399 : : /* i-th vector in the standard basis */
400 : : INLINE GEN
401 : 650734 : col_ei(long n, long i) { GEN e = zerocol(n); gel(e,i) = gen_1; return e; }
402 : : INLINE GEN
403 : 169012 : vec_ei(long n, long i) { GEN e = zerovec(n); gel(e,i) = gen_1; return e; }
404 : : INLINE GEN
405 : 4 : F2v_ei(long n, long i) { GEN e = zero_F2v(n); F2v_set(e,i); return e; }
406 : : INLINE GEN
407 : 4036 : vecsmall_ei(long n, long i) { GEN e = zero_zv(n); e[i] = 1; return e; }
408 : : INLINE GEN
409 : 1999665 : Rg_col_ei(GEN x, long n, long i) { GEN e = zerocol(n); gel(e,i) = x; return e; }
410 : :
411 : : INLINE GEN
412 : 84758 : shallowcopy(GEN x)
413 [ + + ]: 84758 : { return typ(x) == t_MAT ? RgM_shallowcopy(x): leafcopy(x); }
414 : :
415 : : /* routines for naive growarrays */
416 : : INLINE GEN
417 : 335628 : vectrunc_init(long l)
418 : : {
419 : 335628 : GEN z = new_chunk(l);
420 : 335628 : z[0] = evaltyp(t_VEC) | _evallg(1); return z;
421 : : }
422 : : INLINE void
423 : 512806 : vectrunc_append(GEN x, GEN t)
424 : 512806 : { long l = lg(x); gel(x,l) = t; setlg(x, l+1); }
425 : : INLINE void
426 : 0 : vectrunc_append_batch(GEN x, GEN y)
427 : : {
428 : 0 : long i, l = lg(x), ly = lg(y);
429 : 0 : GEN z = x + l-1;
430 [ # # ]: 0 : for (i = 1; i < ly; i++) gel(z,i) = gel(y,i);
431 : 0 : setlg(x, l+ly-1);
432 : 0 : }
433 : : INLINE GEN
434 : 742499 : vecsmalltrunc_init(long l)
435 : : {
436 : 742499 : GEN z = new_chunk(l);
437 : 742499 : z[0] = evaltyp(t_VECSMALL) | _evallg(1); return z;
438 : : }
439 : : INLINE void
440 : 1351632 : vecsmalltrunc_append(GEN x, long t)
441 : 1351632 : { long l = lg(x); x[l] = t; setlg(x, l+1); }
442 : :
443 : : /*******************************************************************/
444 : : /* */
445 : : /* VEC / COL / VECSMALL */
446 : : /* */
447 : : /*******************************************************************/
448 : : /* shallow*/
449 : : INLINE GEN
450 : 0 : vec_shorten(GEN v, long n)
451 : : {
452 : : long i;
453 : 0 : GEN V = cgetg(n+1,t_VEC);
454 [ # # ]: 0 : for(i=1;i<=n;i++) gel(V,i) = gel(v,i);
455 : 0 : return V;
456 : : }
457 : : /* shallow*/
458 : : INLINE GEN
459 : 4212 : vec_lengthen(GEN v, long n)
460 : : {
461 : : long i;
462 : 4212 : long l=lg(v);
463 : 4212 : GEN V = cgetg(n+1,t_VEC);
464 [ + + ]: 54693 : for(i=1;i<l;i++) gel(V,i) = gel(v,i);
465 : 4212 : return V;
466 : : }
467 : : /* shallow*/
468 : : INLINE GEN
469 : 960 : vec_setconst(GEN v, GEN x)
470 : : {
471 : 960 : long i, l = lg(v);
472 [ + + ]: 3784 : for (i = 1; i < l; i++) gel(v,i) = x;
473 : 960 : return v;
474 : : }
475 : : INLINE GEN
476 : 2392 : vecsmall_shorten(GEN v, long n)
477 : : {
478 : : long i;
479 : 2392 : GEN V = cgetg(n+1,t_VECSMALL);
480 [ + + ]: 11288 : for(i=1;i<=n;i++) V[i] = v[i];
481 : 2392 : return V;
482 : : }
483 : : INLINE GEN
484 : 272 : vecsmall_lengthen(GEN v, long n)
485 : : {
486 : 272 : long i, l = lg(v);
487 : 272 : GEN V = cgetg(n+1,t_VECSMALL);
488 [ + + ]: 24816 : for(i=1;i<l;i++) V[i] = v[i];
489 : 272 : return V;
490 : : }
491 : :
492 : : INLINE GEN
493 : 110137 : vec_to_vecsmall(GEN z)
494 : : {
495 : 110137 : long i, l = lg(z);
496 : 110137 : GEN x = cgetg(l, t_VECSMALL);
497 [ + + ]: 1800234 : for (i=1; i<l; i++) x[i] = itos(gel(z,i));
498 : 110137 : return x;
499 : : }
500 : : INLINE GEN
501 : 2513 : vecsmall_to_vec(GEN z)
502 : : {
503 : 2513 : long i, l = lg(z);
504 : 2513 : GEN x = cgetg(l,t_VEC);
505 [ + + ]: 9257 : for (i=1; i<l; i++) gel(x,i) = stoi(z[i]);
506 : 2513 : return x;
507 : : }
508 : : INLINE GEN
509 : 217534 : vecsmall_to_col(GEN z)
510 : : {
511 : 217534 : long i, l = lg(z);
512 : 217534 : GEN x = cgetg(l,t_COL);
513 [ + + ]: 1296384 : for (i=1; i<l; i++) gel(x,i) = stoi(z[i]);
514 : 217534 : return x;
515 : : }
516 : :
517 : : INLINE int
518 : 1477924 : vecsmall_lexcmp(GEN x, GEN y)
519 : : {
520 : : long lx,ly,l,i;
521 : 1477924 : lx = lg(x);
522 : 1477924 : ly = lg(y); l = minss(lx,ly);
523 [ + + ]: 8114420 : for (i=1; i<l; i++)
524 [ + + ][ + + ]: 7723728 : if (x[i] != y[i]) return x[i]<y[i]? -1: 1;
525 [ + - ]: 390692 : if (lx == ly) return 0;
526 [ # # ]: 1477924 : return (lx < ly)? -1 : 1;
527 : : }
528 : :
529 : : INLINE int
530 : 19987261 : vecsmall_prefixcmp(GEN x, GEN y)
531 : : {
532 : 19987261 : long i, lx = lg(x), ly = lg(y), l = minss(lx,ly);
533 [ + + ]: 63208790 : for (i=1; i<l; i++)
534 [ + + ][ + + ]: 57143769 : if (x[i] != y[i]) return x[i]<y[i]? -1: 1;
535 : 19987261 : return 0;
536 : : }
537 : :
538 : : /*Can be used on t_VEC, but coeffs not gcopy-ed*/
539 : : INLINE GEN
540 : 424 : vecsmall_prepend(GEN V, long s)
541 : : {
542 : 424 : long i, l2 = lg(V);
543 : 424 : GEN res = cgetg(l2+1, typ(V));
544 : 424 : res[1] = s;
545 [ + + ]: 988 : for (i = 2; i <= l2; ++i) res[i] = V[i - 1];
546 : 424 : return res;
547 : : }
548 : :
549 : : /*Can be used on t_VEC, but coeffs not gcopy-ed*/
550 : : INLINE GEN
551 : 233026 : vecsmall_append(GEN V, long s)
552 : : {
553 : 233026 : long i, l2 = lg(V);
554 : 233026 : GEN res = cgetg(l2+1, typ(V));
555 [ + + ]: 557594 : for (i = 1; i < l2; ++i) res[i] = V[i];
556 : 233026 : res[l2] = s; return res;
557 : : }
558 : :
559 : : INLINE GEN
560 : 89562 : vecsmall_concat(GEN u, GEN v)
561 : : {
562 : 89562 : long i, l1 = lg(u)-1, l2 = lg(v)-1;
563 : 89562 : GEN res = cgetg(l1+l2+1, t_VECSMALL);
564 [ + + ]: 562852 : for (i = 1; i <= l1; ++i) res[i] = u[i];
565 [ + + ]: 281874 : for (i = 1; i <= l2; ++i) res[i+l1] = v[i];
566 : 89562 : return res;
567 : : }
568 : :
569 : : /* return the number of indices where u and v are equal */
570 : : INLINE long
571 : 0 : vecsmall_coincidence(GEN u, GEN v)
572 : : {
573 : 0 : long i, s = 0, l = minss(lg(u),lg(v));
574 [ # # ]: 0 : for(i=1; i<l; i++)
575 [ # # ]: 0 : if(u[i] == v[i]) s++;
576 : 0 : return s;
577 : : }
578 : :
579 : : /* returns the first index i<=n such that x=v[i] if it exists, 0 otherwise */
580 : : INLINE long
581 : 0 : vecsmall_isin(GEN v, long x)
582 : : {
583 : 0 : long i, l = lg(v);
584 [ # # ]: 0 : for (i = 1; i < l; i++)
585 [ # # ]: 0 : if (v[i] == x) return i;
586 : 0 : return 0;
587 : : }
588 : :
589 : : INLINE long
590 : 48 : vecsmall_pack(GEN V, long base, long mod)
591 : : {
592 : 48 : long i, s = 0;
593 [ + + ]: 156 : for(i=1; i<lg(V); i++) s = (base*s + V[i]) % mod;
594 : 48 : return s;
595 : : }
596 : :
597 : : INLINE long
598 : 8 : vecsmall_indexmax(GEN x)
599 : : {
600 : 8 : long i, i0 = 1, t = x[1], lx = lg(x);
601 [ + + ]: 32 : for (i=2; i<lx; i++)
602 [ + + ]: 24 : if (x[i] > t) t = x[i0=i];
603 : 8 : return i0;
604 : : }
605 : :
606 : : INLINE long
607 : 1100 : vecsmall_max(GEN x)
608 : : {
609 : 1100 : long i, t = x[1], lx = lg(x);
610 [ + + ]: 3956 : for (i=2; i<lx; i++)
611 [ + + ]: 2856 : if (x[i] > t) t = x[i];
612 : 1100 : return t;
613 : : }
614 : :
615 : : INLINE long
616 : 8 : vecsmall_indexmin(GEN x)
617 : : {
618 : 8 : long i, i0 = 1, t = x[1], lx =lg(x);
619 [ + + ]: 32 : for (i=2; i<lx; i++)
620 [ - + ]: 24 : if (x[i] < t) t = x[i0=i];
621 : 8 : return i0;
622 : : }
623 : :
624 : : INLINE long
625 : 0 : vecsmall_min(GEN x)
626 : : {
627 : 0 : long i, t = x[1], lx =lg(x);
628 [ # # ]: 0 : for (i=2; i<lx; i++)
629 [ # # ]: 0 : if (x[i] < t) t = x[i];
630 : 0 : return t;
631 : : }
632 : :
633 : : INLINE int
634 : 1355990 : ZV_isscalar(GEN x)
635 : : {
636 : 1355990 : long l = lg(x);
637 [ + + ]: 4823171 : while (--l > 1)
638 [ + + ]: 4625507 : if (signe(gel(x, l))) return 0;
639 : 1355990 : return 1;
640 : : }
641 : : INLINE int
642 : 3398347 : QV_isscalar(GEN x)
643 : : {
644 : 3398347 : long lx = lg(x),i;
645 [ + + ]: 4715542 : for (i=2; i<lx; i++)
646 [ + + ]: 4554440 : if (!isintzero(gel(x, i))) return 0;
647 : 3398347 : return 1;
648 : : }
649 : : INLINE int
650 : 3032 : RgV_isscalar(GEN x)
651 : : {
652 : 3032 : long lx = lg(x),i;
653 [ + + ]: 6663 : for (i=2; i<lx; i++)
654 [ + + ]: 4339 : if (!gequal0(gel(x, i))) return 0;
655 : 3032 : return 1;
656 : : }
657 : : INLINE int
658 : 0 : RgX_isscalar(GEN x)
659 : : {
660 : : long i;
661 [ # # ]: 0 : for (i=lg(x)-1; i>2; i--)
662 [ # # ]: 0 : if (!gequal0(gel(x, i))) return 0;
663 : 0 : return 1;
664 : : }
665 : : INLINE long
666 [ + + ][ + + ]: 349562 : RgX_equal_var(GEN x, GEN y) { return varn(x) == varn(y) && RgX_equal(x,y); }
667 : :
668 : : INLINE int
669 : 372 : RgX_is_rational(GEN x)
670 : : {
671 : : long i;
672 [ + + ]: 5256 : for (i = lg(x)-1; i > 1; i--)
673 [ + + ]: 5036 : if (!is_rational_t(typ(gel(x,i)))) return 0;
674 : 372 : return 1;
675 : : }
676 : : INLINE int
677 : 32018912 : RgX_is_ZX(GEN x)
678 : : {
679 : : long i;
680 [ + + ]: 136237285 : for (i = lg(x)-1; i > 1; i--)
681 [ + + ]: 107190723 : if (typ(gel(x,i)) != t_INT) return 0;
682 : 32018912 : return 1;
683 : : }
684 : : INLINE int
685 : 3176 : RgX_is_QX(GEN x)
686 : : {
687 : 3176 : long k = lg(x)-1;
688 [ + + ]: 14171 : for ( ; k>1; k--)
689 [ + + ]: 11083 : if (!is_rational_t(typ(gel(x,k)))) return 0;
690 : 3176 : return 1;
691 : : }
692 : : INLINE int
693 : 8643510 : RgX_is_monomial(GEN x)
694 : : {
695 : : long i;
696 [ + + ]: 8643510 : if (!signe(x)) return 0;
697 [ + + ]: 14011041 : for (i=lg(x)-2; i>1; i--)
698 [ + + ]: 9601674 : if (!isexactzero(gel(x,i))) return 0;
699 : 8643510 : return 1;
700 : : }
701 : : INLINE int
702 : 726164 : RgV_is_ZV(GEN x)
703 : : {
704 : : long i;
705 [ + + ]: 2666375 : for (i = lg(x)-1; i > 0; i--)
706 [ + + ]: 1940295 : if (typ(gel(x,i)) != t_INT) return 0;
707 : 726164 : return 1;
708 : : }
709 : : INLINE int
710 : 0 : RgV_is_QV(GEN x)
711 : : {
712 : : long i;
713 [ # # ]: 0 : for (i = lg(x)-1; i > 0; i--)
714 [ # # ]: 0 : if (!is_rational_t(typ(gel(x,i)))) return 0;
715 : 0 : return 1;
716 : : }
717 : :
718 : : /********************************************************************/
719 : : /** **/
720 : : /** Dynamic arrays implementation **/
721 : : /** **/
722 : : /********************************************************************/
723 : : INLINE void **
724 : 131436209 : pari_stack_base(pari_stack *s) { return s->data; }
725 : :
726 : : INLINE void
727 : 13540 : pari_stack_init(pari_stack *s, size_t size, void **data)
728 : : {
729 : 13540 : s->data = data;
730 : 13540 : *data = NULL;
731 : 13540 : s->n = 0;
732 : 13540 : s->alloc = 0;
733 : 13540 : s->size = size;
734 : 13540 : }
735 : :
736 : : INLINE void
737 : 131422245 : pari_stack_alloc(pari_stack *s, long nb)
738 : : {
739 : 131422245 : void **sdat = pari_stack_base(s);
740 [ + + ]: 131453653 : if (s->n+nb <= s->alloc) return;
741 [ + + ]: 31408 : if (!s->alloc)
742 : 10812 : s->alloc = nb;
743 : : else
744 : : {
745 [ + + ]: 41248 : while (s->n+nb > s->alloc) s->alloc <<= 1;
746 : : }
747 : 31408 : *sdat = pari_realloc(*sdat,s->alloc*s->size);
748 : : }
749 : :
750 : : INLINE long
751 : 116439221 : pari_stack_new(pari_stack *s) { pari_stack_alloc(s, 1); return s->n++; }
752 : :
753 : : INLINE void
754 : 9596 : pari_stack_delete(pari_stack *s)
755 : : {
756 : 9596 : void **sdat = pari_stack_base(s);
757 [ + + ]: 9596 : if (*sdat) free(*sdat);
758 : 9596 : }
759 : :
760 : : INLINE void
761 : 4364 : pari_stack_pushp(pari_stack *s, void *u)
762 : : {
763 : 4364 : long n = pari_stack_new(s);
764 : 4364 : void **sdat =(void**) *pari_stack_base(s);
765 : 4364 : sdat[n] = u;
766 : 4364 : }
767 : :
768 : : /*******************************************************************/
769 : : /* */
770 : : /* EXTRACT */
771 : : /* */
772 : : /*******************************************************************/
773 : : INLINE GEN
774 : 889373 : vecslice(GEN A, long y1, long y2)
775 : : {
776 : 889373 : long i,lB = y2 - y1 + 2;
777 : 889373 : GEN B = cgetg(lB, typ(A));
778 [ + + ]: 4699902 : for (i=1; i<lB; i++) B[i] = A[y1-1+i];
779 : 889373 : return B;
780 : : }
781 : : INLINE GEN
782 : 48473 : vecslicepermute(GEN A, GEN p, long y1, long y2)
783 : : {
784 : 48473 : long i,lB = y2 - y1 + 2;
785 : 48473 : GEN B = cgetg(lB, typ(A));
786 [ + + ]: 2645107 : for (i=1; i<lB; i++) B[i] = A[p[y1-1+i]];
787 : 48473 : return B;
788 : : }
789 : : /* rowslice(rowpermute(A,p), x1, x2) */
790 : : INLINE GEN
791 : 10837 : rowslicepermute(GEN A, GEN p, long x1, long x2)
792 : : {
793 : 10837 : long i, lB = lg(A);
794 : 10837 : GEN B = cgetg(lB, typ(A));
795 [ + + ]: 59310 : for (i=1; i<lB; i++) gel(B,i) = vecslicepermute(gel(A,i),p,x1,x2);
796 : 10837 : return B;
797 : : }
798 : : INLINE GEN
799 : 26558 : rowslice(GEN A, long x1, long x2)
800 : : {
801 : 26558 : long i, lB = lg(A);
802 : 26558 : GEN B = cgetg(lB, typ(A));
803 [ + + ]: 233283 : for (i=1; i<lB; i++) gel(B,i) = vecslice(gel(A,i),x1,x2);
804 : 26558 : return B;
805 : : }
806 : :
807 : : /* shallow, remove coeff of index j */
808 : : INLINE GEN
809 : 704 : vecsplice(GEN a, long j)
810 : : {
811 : 704 : long i, k, l = lg(a);
812 : : GEN b;
813 [ - + ]: 704 : if (l == 1) pari_err(e_MISC, "incorrect component in vecsplice");
814 : 704 : b = cgetg(l-1, typ(a));
815 [ + + ]: 3392 : for (i = k = 1; i < l; i++)
816 [ + + ]: 2688 : if (i != j) gel(b, k++) = gel(a,i);
817 : 704 : return b;
818 : : }
819 : : /* shallow */
820 : : INLINE GEN
821 : 192 : RgM_minor(GEN a, long i, long j)
822 : : {
823 : 192 : GEN b = vecsplice(a, j);
824 : 192 : long k, l = lg(b);
825 [ + + ]: 704 : for (k = 1; k < l; k++) gel(b,k) = vecsplice(gel(b,k), i);
826 : 192 : return b;
827 : : }
828 : :
829 : : /* A[x0,] */
830 : : INLINE GEN
831 : 4542 : row(GEN A, long x0)
832 : : {
833 : 4542 : long i, lB = lg(A);
834 : 4542 : GEN B = cgetg(lB, t_VEC);
835 [ + + ]: 46402 : for (i=1; i<lB; i++) gel(B, i) = gcoeff(A, x0, i);
836 : 4542 : return B;
837 : : }
838 : : INLINE GEN
839 : 13680 : row_Flm(GEN A, long x0)
840 : : {
841 : 13680 : long i, lB = lg(A);
842 : 13680 : GEN B = cgetg(lB, t_VECSMALL);
843 [ + + ]: 144508 : for (i=1; i<lB; i++) B[i] = coeff(A, x0, i);
844 : 13680 : return B;
845 : : }
846 : : /* A[x0,] */
847 : : INLINE GEN
848 : 12 : rowcopy(GEN A, long x0)
849 : : {
850 : 12 : long i, lB = lg(A);
851 : 12 : GEN B = cgetg(lB, t_VEC);
852 [ + + ]: 36 : for (i=1; i<lB; i++) gel(B, i) = gcopy(gcoeff(A, x0, i));
853 : 12 : return B;
854 : : }
855 : : /* A[x0, x1..x2] */
856 : : INLINE GEN
857 : 1140 : row_i(GEN A, long x0, long x1, long x2)
858 : : {
859 : 1140 : long i, lB = x2 - x1 + 2;
860 : 1140 : GEN B = cgetg(lB, t_VEC);
861 [ + + ]: 3256 : for (i=x1; i<=x2; i++) gel(B, i) = gcoeff(A, x0, i);
862 : 1140 : return B;
863 : : }
864 : :
865 : : INLINE GEN
866 : 28 : vecreverse(GEN A)
867 : : {
868 : 28 : long i,l = lg(A);
869 : 28 : GEN B = cgetg(l, typ(A));
870 [ + + ]: 128 : for (i=1; i<l; i++) gel(B, i) = gel(A, l-i);
871 : 28 : return B;
872 : : }
873 : :
874 : : INLINE GEN
875 : 12365514 : vecpermute(GEN A, GEN p)
876 : : {
877 : 12365514 : long i,lB = lg(p);
878 : 12365514 : GEN B = cgetg(lB, typ(A));
879 [ + + ]: 79034132 : for (i=1; i<lB; i++) gel(B, i) = gel(A, p[i]);
880 : 12365514 : return B;
881 : : }
882 : : INLINE GEN
883 : 67520 : rowpermute(GEN A, GEN p)
884 : : {
885 : 67520 : long i, lB = lg(A);
886 : 67520 : GEN B = cgetg(lB, typ(A));
887 [ + + ]: 875641 : for (i=1; i<lB; i++) gel(B, i) = vecpermute(gel(A, i), p);
888 : 67520 : return B;
889 : : }
890 : : /*******************************************************************/
891 : : /* */
892 : : /* PERMUTATIONS */
893 : : /* */
894 : : /*******************************************************************/
895 : : /* identity permutation */
896 : : INLINE GEN
897 : 36292 : identity_perm(long n)
898 : : {
899 : 36292 : GEN perm = cgetg(n+1, t_VECSMALL);
900 : : long i;
901 [ + + ]: 1500864 : for (i = 1; i <= n; i++) perm[i] = i;
902 : 36292 : return perm;
903 : : }
904 : :
905 : : /* assume d <= n */
906 : : INLINE GEN
907 : 0 : cyclic_perm(long n, long d)
908 : : {
909 : 0 : GEN perm = cgetg(n+1, t_VECSMALL);
910 : : long i;
911 [ # # ]: 0 : for (i = 1; i <= n-d; i++) perm[i] = i+d;
912 [ # # ]: 0 : for ( ; i <= n; i++) perm[i] = i-n+d;
913 : 0 : return perm;
914 : : }
915 : :
916 : : /* Multiply (compose) two permutations */
917 : : INLINE GEN
918 : 203063 : perm_mul(GEN s, GEN t)
919 : : {
920 : : GEN u;
921 : 203063 : long i, l = lg(t);
922 : 203063 : u = cgetg(l, t_VECSMALL);
923 [ + + ]: 9143988 : for (i = 1; i < l; i++) u[i] = s[ t[i] ];
924 : 203063 : return u;
925 : : }
926 : : /* Compute the inverse (reciprocal) of a permutation. */
927 : : INLINE GEN
928 : 32 : perm_inv(GEN x)
929 : : {
930 : : long i, lx;
931 : 32 : GEN y = cgetg_copy(x, &lx);
932 [ + + ]: 540 : for (i=1; i<lx; i++) y[ x[i] ] = i;
933 : 32 : return y;
934 : : }
935 : : /* Return s*t*s^-1 */
936 : : INLINE GEN
937 : 20 : perm_conj(GEN s, GEN t)
938 : : {
939 : : long i, l;
940 : 20 : GEN v = cgetg_copy(s, &l);
941 [ + + ]: 500 : for (i = 1; i < l; i++) v[ s[i] ] = s[ t[i] ];
942 : 20 : return v;
943 : : }
944 : :
945 : : /*********************************************************************/
946 : : /* MALLOC/FREE WRAPPERS */
947 : : /*********************************************************************/
948 : : #define BLOCK_SIGALRM_START \
949 : : { \
950 : : int block=PARI_SIGINT_block; \
951 : : PARI_SIGINT_block = 2; \
952 : : MT_SIGINT_BLOCK(block);
953 : :
954 : : #define BLOCK_SIGINT_START \
955 : : { \
956 : : int block=PARI_SIGINT_block; \
957 : : PARI_SIGINT_block = 1; \
958 : : MT_SIGINT_BLOCK(block);
959 : :
960 : : #define BLOCK_SIGINT_END \
961 : : PARI_SIGINT_block = block; \
962 : : MT_SIGINT_UNBLOCK(block); \
963 : : if (!block && PARI_SIGINT_pending) \
964 : : { \
965 : : int sig = PARI_SIGINT_pending; \
966 : : PARI_SIGINT_pending = 0; \
967 : : raise(sig); \
968 : : } \
969 : : }
970 : :
971 : : INLINE void
972 : 20250831 : pari_free(void *pointer)
973 : : {
974 : 20250831 : BLOCK_SIGINT_START;
975 : 20250831 : free(pointer);
976 [ + + ][ - + ]: 20250831 : BLOCK_SIGINT_END;
977 : 20250831 : }
978 : : INLINE void*
979 : 58193741 : pari_malloc(size_t size)
980 : : {
981 [ + - ]: 58193741 : if (size)
982 : : {
983 : : char *tmp;
984 : 58193741 : BLOCK_SIGINT_START;
985 : 58193741 : tmp = (char*)malloc(size);
986 [ + - ][ - + ]: 58193741 : BLOCK_SIGINT_END;
987 [ - + ]: 58193741 : if (!tmp) pari_err(e_MEM);
988 : 58193741 : return tmp;
989 : : }
990 [ # # ]: 0 : if (DEBUGMEM) pari_warn(warner,"mallocing NULL object");
991 : 58193741 : return NULL;
992 : : }
993 : : INLINE void*
994 : 34359 : pari_realloc(void *pointer, size_t size)
995 : : {
996 : : char *tmp;
997 : :
998 : 34359 : BLOCK_SIGINT_START;
999 [ + + ]: 34359 : if (!pointer) tmp = (char *) malloc(size);
1000 : 22719 : else tmp = (char *) realloc(pointer,size);
1001 [ + + ][ - + ]: 34359 : BLOCK_SIGINT_END;
1002 [ - + ]: 34359 : if (!tmp) pari_err(e_MEM);
1003 : 34359 : return tmp;
1004 : : }
1005 : : INLINE void*
1006 : 9818 : pari_calloc(size_t size)
1007 : : {
1008 : 9818 : void *t = pari_malloc(size);
1009 : 9818 : memset(t, 0, size); return t;
1010 : : }
1011 : : INLINE GEN
1012 : 1536 : cgetalloc(long t, size_t l)
1013 : : {
1014 : 1536 : GEN x = (GEN)pari_malloc(l * sizeof(long));
1015 : 1536 : x[0] = evaltyp(t) | evallg(l); return x;
1016 : : }
1017 : :
1018 : : /*******************************************************************/
1019 : : /* */
1020 : : /* GARBAGE COLLECTION */
1021 : : /* */
1022 : : /*******************************************************************/
1023 : : /* copy integer x as if we had avma = av */
1024 : : INLINE GEN
1025 : 454626622 : icopy_avma(GEN x, pari_sp av)
1026 : : {
1027 : 454626622 : long i = lgefint(x), lx = i;
1028 : 454626622 : GEN y = ((GEN)av) - i;
1029 [ + + ]: 4152753442 : while (--i > 0) y[i] = x[i];
1030 : 454626622 : y[0] = evaltyp(t_INT)|evallg(lx);
1031 : 454626622 : return y;
1032 : : }
1033 : : /* copy leaf x as if we had avma = av */
1034 : : INLINE GEN
1035 : 26654938 : leafcopy_avma(GEN x, pari_sp av)
1036 : : {
1037 : 26654938 : long i = lg(x);
1038 : 26654938 : GEN y = ((GEN)av) - i;
1039 [ + + ]: 181191968 : while (--i > 0) y[i] = x[i];
1040 : 26654938 : y[0] = x[0] & (~CLONEBIT);
1041 : 26654938 : return y;
1042 : : }
1043 : : INLINE GEN
1044 : 106187035 : gerepileuptoleaf(pari_sp av, GEN x)
1045 : : {
1046 : : long lx;
1047 : : GEN q;
1048 : :
1049 [ + + ][ + + ]: 106187035 : if (!isonstack(x) || (GEN)av<=x) { avma = av; return x; }
1050 : 106177216 : lx = lg(x);
1051 : 106177216 : q = ((GEN)av) - lx;
1052 : 106177216 : avma = (pari_sp)q;
1053 [ + + ]: 1028262450 : while (--lx >= 0) q[lx] = x[lx];
1054 : 106187035 : return q;
1055 : : }
1056 : : INLINE GEN
1057 : 321893810 : gerepileuptoint(pari_sp av, GEN x)
1058 : : {
1059 [ + + ][ + + ]: 321893810 : if (!isonstack(x) || (GEN)av<=x) { avma = av; return x; }
1060 : 293792028 : avma = (pari_sp)icopy_avma(x, av);
1061 : 321893810 : return (GEN)avma;
1062 : : }
1063 : : INLINE GEN
1064 : 214097740 : gerepileupto(pari_sp av, GEN x)
1065 : : {
1066 [ + + ][ + + ]: 214097740 : if (!isonstack(x) || (GEN)av<=x) { avma = av; return x; }
1067 [ + + + ]: 195438659 : switch(typ(x))
1068 : : { /* non-default = !is_recursive_t(tq) */
1069 : 34288865 : case t_INT: return gerepileuptoint(av, x);
1070 : : case t_REAL:
1071 : : case t_STR:
1072 : 30891044 : case t_VECSMALL: return gerepileuptoleaf(av,x);
1073 : : default:
1074 : : /* NB: x+i --> ((long)x) + i*sizeof(long) */
1075 : 214097740 : return gerepile(av, (pari_sp) (x+lg(x)), x);
1076 : : }
1077 : : }
1078 : :
1079 : : /* gerepileupto(av, gcopy(x)) */
1080 : : INLINE GEN
1081 : 11486366 : gerepilecopy(pari_sp av, GEN x)
1082 : : {
1083 [ + + ]: 11486366 : if (is_recursive_t(typ(x)))
1084 : : {
1085 : 10414990 : GENbin *p = copy_bin(x);
1086 : 10414990 : avma = av; return bin_copy(p);
1087 : : }
1088 : : else
1089 : : {
1090 : 1071376 : avma = av;
1091 [ + + ]: 1071376 : if (x < (GEN)av) {
1092 [ + + ]: 1019393 : if (x < (GEN)bot) new_chunk(lg(x));
1093 : 1019393 : x = leafcopy_avma(x, av);
1094 : 1019393 : avma = (pari_sp)x;
1095 : : } else
1096 : 51983 : x = leafcopy(x);
1097 : 11486366 : return x;
1098 : : }
1099 : : }
1100 : :
1101 : : /* Takes an array of pointers to GENs, of length n. Copies all
1102 : : * objects to contiguous locations and cleans up the stack between
1103 : : * av and avma. */
1104 : : INLINE void
1105 : 20510 : gerepilemany(pari_sp av, GEN* gptr[], int n)
1106 : : {
1107 : : int i;
1108 [ + + ]: 73442 : for (i=0; i<n; i++) *gptr[i] = (GEN)copy_bin(*gptr[i]);
1109 : 20510 : avma = av;
1110 [ + + ]: 73442 : for (i=0; i<n; i++) *gptr[i] = bin_copy((GENbin*)*gptr[i]);
1111 : 20510 : }
1112 : :
1113 : : INLINE void
1114 : 1931989 : gerepileall(pari_sp av, int n, ...)
1115 : : {
1116 : : int i;
1117 : 1931989 : va_list a; va_start(a, n);
1118 [ + - ]: 1931989 : if (n < 10)
1119 : : {
1120 : : GEN *gptr[10];
1121 [ + + ]: 5951280 : for (i=0; i<n; i++)
1122 [ + + ]: 4019291 : { gptr[i] = va_arg(a,GEN*); *gptr[i] = (GEN)copy_bin(*gptr[i]); }
1123 : 1931989 : avma = av;
1124 [ + + ]: 5951280 : for (--i; i>=0; i--) *gptr[i] = bin_copy((GENbin*)*gptr[i]);
1125 : :
1126 : : }
1127 : : else
1128 : : {
1129 : 0 : GEN **gptr = (GEN**) pari_malloc(n*sizeof(GEN*));
1130 [ # # ]: 0 : for (i=0; i<n; i++)
1131 [ # # ]: 0 : { gptr[i] = va_arg(a,GEN*); *gptr[i] = (GEN)copy_bin(*gptr[i]); }
1132 : 0 : avma = av;
1133 [ # # ]: 0 : for (--i; i>=0; i--) *gptr[i] = bin_copy((GENbin*)*gptr[i]);
1134 : 0 : pari_free(gptr);
1135 : : }
1136 : 1931989 : }
1137 : :
1138 : : INLINE void
1139 : 5 : gerepilecoeffs(pari_sp av, GEN x, int n)
1140 : : {
1141 : : int i;
1142 [ + + ]: 833 : for (i=0; i<n; i++) gel(x,i) = (GEN)copy_bin(gel(x,i));
1143 : 5 : avma = av;
1144 [ + + ]: 833 : for (i=0; i<n; i++) gel(x,i) = bin_copy((GENbin*)x[i]);
1145 : 5 : }
1146 : :
1147 : : /* p from copy_bin. Copy p->x back to stack, then destroy p */
1148 : : INLINE GEN
1149 : 14488061 : bin_copy(GENbin *p)
1150 : : {
1151 : : GEN x, y, base;
1152 : : long dx, len;
1153 : :
1154 [ + + ]: 14488061 : x = p->x; if (!x) { pari_free(p); return gen_0; }
1155 : 14482912 : len = p->len;
1156 : 14482912 : base= p->base; dx = x - base;
1157 : 14482912 : y = (GEN)memcpy((void*)new_chunk(len), (void*)GENbinbase(p), len*sizeof(long));
1158 : 14482912 : y += dx;
1159 [ + + ]: 14482912 : if (p->canon)
1160 : 20 : shiftaddress_canon(y, (y-x)*sizeof(long));
1161 : : else
1162 : 14482892 : shiftaddress(y, (y-x)*sizeof(long));
1163 : 14488061 : pari_free(p); return y;
1164 : : }
1165 : :
1166 : : INLINE GEN
1167 : 28971013 : GENbinbase(GENbin *p) { return (GEN)(p + 1); }
1168 : :
1169 : : INLINE void
1170 : 4646106 : cgiv(GEN x)
1171 : : {
1172 : 4646106 : pari_sp av = (pari_sp)(x+lg(x));
1173 [ + + ]: 4646106 : if (isonstack((GEN)av)) avma = av;
1174 : 4646106 : }
1175 : :
1176 : : INLINE void
1177 : 549160 : killblock(GEN x) { gunclone(x); }
1178 : :
1179 : : INLINE int
1180 [ + + ][ + + ]: 8284751 : is_universal_constant(GEN x) { return (x >= gen_0 && x <= ghalf); }
1181 : :
1182 : : /*******************************************************************/
1183 : : /* */
1184 : : /* CONVERSION / ASSIGNMENT */
1185 : : /* */
1186 : : /*******************************************************************/
1187 : : /* z is a type which may be a t_COMPLEX component (not a t_QUAD) */
1188 : : INLINE GEN
1189 : 691632 : cxcompotor(GEN z, long prec)
1190 : : {
1191 [ + + + - ]: 691632 : switch(typ(z))
1192 : : {
1193 : 439800 : case t_INT: return itor(z, prec);
1194 : 15948 : case t_FRAC: return fractor(z, prec);
1195 : 235884 : case t_REAL: return rtor(z, prec);
1196 : 691632 : default: pari_err_TYPE("cxcompotor",z); return NULL; /* not reached */
1197 : : }
1198 : : }
1199 : : INLINE GEN
1200 : 345284 : cxtofp(GEN x, long prec)
1201 : 345284 : { retmkcomplex(cxcompotor(gel(x,1),prec), cxcompotor(gel(x,2),prec)); }
1202 : :
1203 : : INLINE double
1204 : 4753084 : gtodouble(GEN x)
1205 : : {
1206 [ + + ]: 4753084 : if (typ(x)!=t_REAL) {
1207 : 269779 : pari_sp av = avma;
1208 : 269779 : x = gtofp(x, DEFAULTPREC);
1209 [ - + ]: 269779 : if (typ(x)!=t_REAL) pari_err_TYPE("gtodouble [t_REAL expected]", x);
1210 : 269779 : avma = av;
1211 : : }
1212 : 4753084 : return rtodbl(x);
1213 : : }
1214 : : INLINE long
1215 : 15989483 : gtos(GEN x) {
1216 [ + + ]: 15989483 : if (typ(x) != t_INT) pari_err_TYPE("gtos [integer expected]",x);
1217 : 15989479 : return itos(x);
1218 : : }
1219 : :
1220 : : INLINE GEN
1221 : 557701 : absfrac(GEN x)
1222 : : {
1223 : 557701 : GEN y = cgetg(3, t_FRAC);
1224 : 557701 : gel(y,1) = absi(gel(x,1));
1225 : 557701 : gel(y,2) = icopy(gel(x,2)); return y;
1226 : : }
1227 : : INLINE GEN
1228 : 0 : absfrac_shallow(GEN x)
1229 [ # # ]: 0 : { return signe(gel(x,1))>0? x: mkfrac(negi(gel(x,1)), gel(x,2)); }
1230 : : INLINE GEN
1231 [ + + ]: 142641 : Q_abs(GEN x) { return (typ(x) == t_INT)? absi(x): absfrac(x); }
1232 : : INLINE GEN
1233 : 0 : Q_abs_shallow(GEN x)
1234 [ # # ]: 0 : { return (typ(x) == t_INT)? absi_shallow(x): absfrac_shallow(x); }
1235 : :
1236 : : /* Force z to be of type real/complex with floating point components */
1237 : : INLINE GEN
1238 : 3283172 : gtofp(GEN z, long prec)
1239 : : {
1240 [ + + + + : 3283172 : switch(typ(z))
- - ]
1241 : : {
1242 : 2033253 : case t_INT: return itor(z, prec);
1243 : 36315 : case t_FRAC: return fractor(z, prec);
1244 : 881640 : case t_REAL: return rtor(z, prec);
1245 : : case t_COMPLEX: {
1246 : 331964 : GEN a = gel(z,1), b = gel(z,2);
1247 [ + + ]: 331964 : if (isintzero(b)) return cxcompotor(a, prec);
1248 [ + + ]: 331330 : if (isintzero(a)) {
1249 : 406 : GEN y = cgetg(3, t_COMPLEX);
1250 : 406 : b = cxcompotor(b, prec);
1251 : 406 : gel(y,1) = real_0_bit(expo(b) - prec2nbits(prec));
1252 : 406 : gel(y,2) = b; return y;
1253 : : }
1254 : 330924 : return cxtofp(z, prec);
1255 : : }
1256 : 0 : case t_QUAD: return quadtofp(z, prec);
1257 : 3283172 : default: pari_err_TYPE("gtofp",z); return NULL; /* not reached */
1258 : : }
1259 : : }
1260 : : /* Force z to be of type real / int */
1261 : : INLINE GEN
1262 : 12800 : gtomp(GEN z, long prec)
1263 : : {
1264 [ + + - - : 12800 : switch(typ(z))
- ]
1265 : : {
1266 : 8 : case t_INT: return z;
1267 : 12792 : case t_FRAC: return fractor(z, prec);
1268 : 0 : case t_REAL: return rtor(z, prec);
1269 : 0 : case t_QUAD: z = quadtofp(z, prec);
1270 [ # # ]: 0 : if (typ(z) == t_REAL) return z;
1271 : 12800 : default: pari_err_TYPE("gtomp",z); return NULL; /* not reached */
1272 : : }
1273 : : }
1274 : :
1275 : : INLINE GEN
1276 : 239616 : RgX_gtofp(GEN x, long prec)
1277 : : {
1278 : : long l;
1279 : 239616 : GEN y = cgetg_copy(x, &l);
1280 [ + + ]: 1537557 : while (--l > 1) gel(y,l) = gtofp(gel(x,l), prec);
1281 : 239616 : y[1] = x[1]; return y;
1282 : : }
1283 : : INLINE GEN
1284 : 71195 : RgC_gtofp(GEN x, long prec)
1285 : : {
1286 : 71195 : long l = lg(x);
1287 : 71195 : GEN y = cgetg(l, t_COL);
1288 [ + + ]: 997152 : while (--l > 0) gel(y,l) = gtofp(gel(x,l), prec);
1289 : 71195 : return y;
1290 : : }
1291 : : INLINE GEN
1292 : 492 : RgM_gtofp(GEN x, long prec)
1293 : : {
1294 : : long l;
1295 : 492 : GEN y = cgetg_copy(x, &l);
1296 [ + + ]: 5219 : while (--l > 0) gel(y,l) = RgC_gtofp(gel(x,l), prec);
1297 : 492 : return y;
1298 : : }
1299 : : INLINE GEN
1300 : 320 : RgC_gtomp(GEN x, long prec)
1301 : : {
1302 : 320 : long l = lg(x);
1303 : 320 : GEN y = cgetg(l, t_COL);
1304 [ + + ]: 13120 : while (--l > 0) gel(y,l) = gtomp(gel(x,l), prec);
1305 : 320 : return y;
1306 : : }
1307 : : INLINE GEN
1308 : 8 : RgM_gtomp(GEN x, long prec)
1309 : : {
1310 : : long l;
1311 : 8 : GEN y = cgetg_copy(x, &l);
1312 [ + + ]: 328 : while (--l > 0) gel(y,l) = RgC_gtomp(gel(x,l), prec);
1313 : 8 : return y;
1314 : : }
1315 : :
1316 : : INLINE GEN
1317 : 4791 : RgX_fpnorml2(GEN x, long prec)
1318 : : {
1319 : 4791 : pari_sp av = avma;
1320 : 4791 : return gerepileupto(av, gnorml2(RgX_gtofp(x, prec)));
1321 : : }
1322 : : INLINE GEN
1323 : 66432 : RgC_fpnorml2(GEN x, long prec)
1324 : : {
1325 : 66432 : pari_sp av = avma;
1326 : 66432 : return gerepileupto(av, gnorml2(RgC_gtofp(x, prec)));
1327 : : }
1328 : : INLINE GEN
1329 : 324 : RgM_fpnorml2(GEN x, long prec)
1330 : : {
1331 : 324 : pari_sp av = avma;
1332 : 324 : return gerepileupto(av, gnorml2(RgM_gtofp(x, prec)));
1333 : : }
1334 : :
1335 : : /* y a t_REAL */
1336 : : INLINE void
1337 : 1833222 : affgr(GEN x, GEN y)
1338 : : {
1339 : : pari_sp av;
1340 [ + + + - : 1833222 : switch(typ(x)) {
- ]
1341 : 44 : case t_INT: affir(x,y); break;
1342 : 103566 : case t_REAL: affrr(x,y); break;
1343 : 1729612 : case t_FRAC: rdiviiz(gel(x,1),gel(x,2), y); break;
1344 : 0 : case t_QUAD: av = avma; affgr(quadtofp(x,realprec(y)), y); avma = av; break;
1345 : 0 : default: pari_err_TYPE2("=",x,y);
1346 : : }
1347 : 1833222 : }
1348 : :
1349 : : INLINE GEN
1350 : 15268 : affc_fixlg(GEN x, GEN res)
1351 : : {
1352 [ + + ]: 15268 : if (typ(x) == t_COMPLEX)
1353 : : {
1354 : 14400 : affrr_fixlg(gel(x,1), gel(res,1));
1355 : 14400 : affrr_fixlg(gel(x,2), gel(res,2));
1356 : : }
1357 : : else
1358 : : {
1359 : 868 : avma = (pari_sp)(res+3);
1360 : 868 : res = cgetr(realprec(gel(res,1)));
1361 : 868 : affrr_fixlg(x, res);
1362 : : }
1363 : 15268 : return res;
1364 : : }
1365 : :
1366 : : INLINE GEN
1367 : 0 : trunc_safe(GEN x) { long e; return gcvtoi(x,&e); }
1368 : :
1369 : : /*******************************************************************/
1370 : : /* */
1371 : : /* LENGTH CONVERSIONS */
1372 : : /* */
1373 : : /*******************************************************************/
1374 : : INLINE long
1375 : 10037 : ndec2nlong(long x) { return 1 + (long)((x)*(LOG2_10/BITS_IN_LONG)); }
1376 : : INLINE long
1377 : 10037 : ndec2prec(long x) { return 2 + ndec2nlong(x); }
1378 : : /* Fast implementation of ceil(x / (8*sizeof(long))); typecast to (ulong)
1379 : : * to avoid overflow. Faster than 1 + ((x-1)>>TWOPOTBITS_IN_LONG)) :
1380 : : * addl, shrl instead of subl, sarl, addl */
1381 : : INLINE long
1382 : 303443 : nbits2nlong(long x) {
1383 : 303443 : return (long)(((ulong)x+BITS_IN_LONG-1) >> TWOPOTBITS_IN_LONG);
1384 : : }
1385 : :
1386 : : INLINE long
1387 : 142749138 : nbits2extraprec(long x) {
1388 : 142749138 : return (long)(((ulong)x+BITS_IN_LONG-1) >> TWOPOTBITS_IN_LONG);
1389 : : }
1390 : :
1391 : : /* Fast implementation of 2 + nbits2nlong(x) */
1392 : : INLINE long
1393 : 49191613 : nbits2prec(long x) {
1394 : 49191613 : return (long)(((ulong)x+3*BITS_IN_LONG-1) >> TWOPOTBITS_IN_LONG);
1395 : : }
1396 : : INLINE long
1397 : 1255533 : nbits2lg(long x) {
1398 : 1255533 : return (long)(((ulong)x+3*BITS_IN_LONG-1) >> TWOPOTBITS_IN_LONG);
1399 : : }
1400 : : /* ceil(x / sizeof(long)) */
1401 : : INLINE long
1402 : 4539607 : nchar2nlong(long x) {
1403 : 4539607 : return (long)(((ulong)x+sizeof(long)-1) >> (TWOPOTBITS_IN_LONG-3L));
1404 : : }
1405 : : INLINE long
1406 : 509435211 : bit_accuracy(long x) { return (x-2) * BITS_IN_LONG; }
1407 : : INLINE double
1408 : 84175 : bit_accuracy_mul(long x, double y) { return (x-2) * (BITS_IN_LONG*y); }
1409 : : INLINE double
1410 : 273257 : prec2nbits_mul(long x, double y) { return (x-2) * (BITS_IN_LONG*y); }
1411 : : INLINE long
1412 : 13915320 : bit_prec(GEN x) { return bit_accuracy(realprec(x)); }
1413 : : INLINE long
1414 : 28092606 : prec2nbits(long x) { return bit_accuracy(x); }
1415 : : INLINE long
1416 : 2238 : prec2ndec(long x) { return (long)prec2nbits_mul(x, LOG10_2); }
1417 : : INLINE long
1418 : 901 : precdbl(long x) {return (x - 1) << 1;}
1419 : : INLINE long
1420 : 1923783855 : divsBIL(long n) { return n >> TWOPOTBITS_IN_LONG; }
1421 : : INLINE long
1422 : 1884554429 : remsBIL(long n) { return n & (BITS_IN_LONG-1); }
1423 : :
1424 : : /*********************************************************************/
1425 : : /** **/
1426 : : /** OPERATIONS MODULO m **/
1427 : : /** **/
1428 : : /*********************************************************************/
1429 : : /* Assume m > 0, more efficient if 0 <= a, b < m */
1430 : :
1431 : : INLINE GEN
1432 : 5106162 : Fp_red(GEN a, GEN m) { return modii(a, m); }
1433 : :
1434 : : INLINE GEN
1435 : 7815414 : Fp_add(GEN a, GEN b, GEN m)
1436 : : {
1437 : 7815414 : pari_sp av=avma;
1438 : 7815414 : GEN p = addii(a,b);
1439 : 7815414 : long s = signe(p);
1440 [ + + ]: 7815414 : if (!s) return p; /* = gen_0 */
1441 [ + + ]: 7529227 : if (s > 0) /* general case */
1442 : : {
1443 : 7422708 : GEN t = subii(p, m);
1444 : 7422708 : s = signe(t);
1445 [ + + ]: 7422708 : if (!s) { avma = av; return gen_0; }
1446 [ + + ]: 7259485 : if (s < 0) { avma = (pari_sp)p; return p; }
1447 [ + + ]: 2022181 : if (cmpii(t, m) < 0) return gerepileuptoint(av, t); /* general case ! */
1448 : 581321 : p = remii(t, m);
1449 : : }
1450 : : else
1451 : 106519 : p = modii(p, m);
1452 : 7815414 : return gerepileuptoint(av, p);
1453 : : }
1454 : : INLINE GEN
1455 : 24530442 : Fp_sub(GEN a, GEN b, GEN m)
1456 : : {
1457 : 24530442 : pari_sp av=avma;
1458 : 24530442 : GEN p = subii(a,b);
1459 : 24530442 : long s = signe(p);
1460 [ + + ]: 24530442 : if (!s) return p; /* = gen_0 */
1461 [ + + ]: 24124194 : if (s > 0)
1462 : : {
1463 [ + + ]: 11981583 : if (cmpii(p, m) < 0) return p; /* general case ! */
1464 : 591943 : p = remii(p, m);
1465 : : }
1466 : : else
1467 : : {
1468 : 12142611 : GEN t = addii(p, m);
1469 [ - + ]: 12142611 : if (!s) { avma = av; return gen_0; }
1470 [ - + ]: 12142611 : if (s > 0) return gerepileuptoint(av, t); /* general case ! */
1471 : 12142611 : p = modii(t, m);
1472 : : }
1473 : 24530442 : return gerepileuptoint(av, p);
1474 : : }
1475 : : INLINE GEN
1476 : 5081532 : Fp_neg(GEN b, GEN m)
1477 : : {
1478 : 5081532 : pari_sp av = avma;
1479 : 5081532 : long s = signe(b);
1480 : : GEN p;
1481 [ + + ]: 5081532 : if (!s) return gen_0;
1482 [ + - ]: 3566675 : if (s > 0)
1483 : : {
1484 : 3566675 : p = subii(m, b);
1485 [ + + ]: 3566675 : if (signe(p) >= 0) return p; /* general case ! */
1486 : 13473 : p = modii(p, m);
1487 : : } else
1488 : 0 : p = remii(negi(b), m);
1489 : 5081532 : return gerepileuptoint(av, p);
1490 : : }
1491 : : /* assume 0 <= u < p and ps2 = p>>1 */
1492 : : INLINE GEN
1493 : 937632 : Fp_center(GEN u, GEN p, GEN ps2)
1494 [ + + ]: 937632 : { return absi_cmp(u,ps2)<=0? icopy(u): subii(u,p); }
1495 : :
1496 : : /* x + y*z mod p */
1497 : : INLINE GEN
1498 : 2916396 : Fp_addmul(GEN x, GEN y, GEN z, GEN p)
1499 : : {
1500 : : pari_sp av;
1501 [ + + ][ + + ]: 2916396 : if (!signe(y) || !signe(z)) return Fp_red(x, p);
1502 [ + + ]: 2910898 : if (!signe(x)) return Fp_mul(z,y, p);
1503 : 2748602 : av = avma;
1504 : 2916396 : return gerepileuptoint(av, modii(addii(x, mulii(y,z)), p));
1505 : : }
1506 : :
1507 : : INLINE GEN
1508 : 10337179 : Fp_mul(GEN a, GEN b, GEN m)
1509 : : {
1510 : 10337179 : pari_sp av=avma;
1511 : : GEN p; /*HACK: assume modii use <=lg(p)+(lg(m)<<1) space*/
1512 : 10337179 : (void)new_chunk(lg(a)+lg(b)+(lg(m)<<1));
1513 : 10337179 : p = mulii(a,b);
1514 : 10337179 : avma = av; return modii(p,m);
1515 : : }
1516 : : INLINE GEN
1517 : 3676361 : Fp_sqr(GEN a, GEN m)
1518 : : {
1519 : 3676361 : pari_sp av=avma;
1520 : : GEN p; /*HACK: assume modii use <=lg(p)+(lg(m)<<1) space*/
1521 : 3676361 : (void)new_chunk((lg(a)+lg(m))<<1);
1522 : 3676361 : p = sqri(a);
1523 : 3676361 : avma = av; return modii(p,m);
1524 : : }
1525 : : INLINE GEN
1526 : 14196896 : Fp_mulu(GEN a, ulong b, GEN m)
1527 : : {
1528 : 14196896 : long l = lgefint(m);
1529 [ + + ]: 14196896 : if (l == 3)
1530 : : {
1531 : 10765661 : ulong mm = m[2];
1532 : 10765661 : return utoi( Fl_mul(umodiu(a, mm), b, mm) );
1533 : : } else {
1534 : 3431235 : pari_sp av = avma;
1535 : : GEN p; /*HACK: assume modii use <=lg(p)+(lg(m)<<1) space*/
1536 : 3431235 : (void)new_chunk(lg(a)+1+(l<<1));
1537 : 3431235 : p = muliu(a,b);
1538 : 14196896 : avma = av; return modii(p,m);
1539 : : }
1540 : : }
1541 : : INLINE GEN
1542 : 132 : Fp_muls(GEN a, long b, GEN m)
1543 : : {
1544 : 132 : long l = lgefint(m);
1545 [ + - ]: 132 : if (l == 3)
1546 : : {
1547 : 132 : ulong mm = m[2];
1548 [ + - ]: 132 : if (b < 0)
1549 : : {
1550 : 132 : ulong t = Fl_mul(umodiu(a, mm), -b, mm);
1551 [ + - ]: 132 : return t? utoipos(mm - t): gen_0;
1552 : : }
1553 : : else
1554 : 0 : return utoi( Fl_mul(umodiu(a, mm), b, mm) );
1555 : : } else {
1556 : 0 : pari_sp av = avma;
1557 : : GEN p; /*HACK: assume modii use <=lg(p)+(lg(m)<<1) space*/
1558 : 0 : (void)new_chunk(lg(a)+1+(l<<1));
1559 : 0 : p = mulis(a,b);
1560 : 132 : avma = av; return modii(p,m);
1561 : : }
1562 : : }
1563 : :
1564 : : INLINE GEN
1565 : 1912960 : Fp_inv(GEN a, GEN m)
1566 : : {
1567 : : GEN res;
1568 [ + + ]: 1912960 : if (! invmod(a,m,&res)) pari_err_INV("Fp_inv", mkintmod(res,m));
1569 : 1912907 : return res;
1570 : : }
1571 : : INLINE GEN
1572 : 154942 : Fp_invsafe(GEN a, GEN m)
1573 : : {
1574 : : GEN res;
1575 [ - + ]: 154942 : if (! invmod(a,m,&res)) return NULL;
1576 : 154942 : return res;
1577 : : }
1578 : : INLINE GEN
1579 : 812594 : Fp_div(GEN a, GEN b, GEN m)
1580 : : {
1581 : 812594 : pari_sp av=avma;
1582 : : GEN p; /*HACK: assume modii use <=lg(p)+(lg(m)<<1) space*/
1583 : 812594 : (void)new_chunk(lg(a)+(lg(m)<<1));
1584 : 812594 : p = mulii(a, Fp_inv(b,m));
1585 : 812586 : avma = av; return modii(p,m);
1586 : : }
1587 : :
1588 : : INLINE GEN
1589 : 94727 : Flx_mulu(GEN x, ulong a, ulong p) { return Flx_Fl_mul(x,a%p,p); }
1590 : :
1591 : : /*******************************************************************/
1592 : : /* */
1593 : : /* ADDMULII / SUBMULII */
1594 : : /* */
1595 : : /*******************************************************************/
1596 : : /* x - y*z */
1597 : : INLINE GEN
1598 : 23057258 : submulii(GEN x, GEN y, GEN z)
1599 : : {
1600 : 23057258 : long lx = lgefint(x), ly, lz;
1601 : : pari_sp av;
1602 : : GEN t;
1603 [ + + ]: 23057258 : if (lx == 2) { t = mulii(z,y); togglesign(t); return t; }
1604 : 19657538 : ly = lgefint(y);
1605 [ + + ]: 19657538 : if (ly == 2) return icopy(x);
1606 : 19087442 : lz = lgefint(z);
1607 : 19087442 : av = avma; (void)new_chunk(lx+ly+lz); /* HACK */
1608 : 19087442 : t = mulii(z, y);
1609 : 23057258 : avma = av; return subii(x,t);
1610 : : }
1611 : : /* y*z - x */
1612 : : INLINE GEN
1613 : 1438344 : mulsubii(GEN y, GEN z, GEN x)
1614 : : {
1615 : 1438344 : long lx = lgefint(x), ly, lz;
1616 : : pari_sp av;
1617 : : GEN t;
1618 [ + + ]: 1438344 : if (lx == 2) return mulii(z,y);
1619 : 912362 : ly = lgefint(y);
1620 [ + + ]: 912362 : if (ly == 2) return negi(x);
1621 : 865004 : lz = lgefint(z);
1622 : 865004 : av = avma; (void)new_chunk(lx+ly+lz); /* HACK */
1623 : 865004 : t = mulii(z, y);
1624 : 1438344 : avma = av; return subii(t,x);
1625 : : }
1626 : :
1627 : : /* x - u*y */
1628 : : INLINE GEN
1629 : 4000 : submuliu(GEN x, GEN y, ulong u)
1630 : : {
1631 : : pari_sp av;
1632 : 4000 : long ly = lgefint(y);
1633 [ - + ]: 4000 : if (ly == 2) return icopy(x);
1634 : 4000 : av = avma;
1635 : 4000 : (void)new_chunk(3+ly+lgefint(x)); /* HACK */
1636 : 4000 : y = mului(u,y);
1637 : 4000 : avma = av; return subii(x, y);
1638 : : }
1639 : : /* x + u*y */
1640 : : INLINE GEN
1641 : 4000 : addmuliu(GEN x, GEN y, ulong u)
1642 : : {
1643 : : pari_sp av;
1644 : 4000 : long ly = lgefint(y);
1645 [ - + ]: 4000 : if (ly == 2) return icopy(x);
1646 : 4000 : av = avma;
1647 : 4000 : (void)new_chunk(3+ly+lgefint(x)); /* HACK */
1648 : 4000 : y = mului(u,y);
1649 : 4000 : avma = av; return addii(x, y);
1650 : : }
1651 : : /* x - u*y */
1652 : : INLINE GEN
1653 : 144317994 : submuliu_inplace(GEN x, GEN y, ulong u)
1654 : : {
1655 : : pari_sp av;
1656 : 144317994 : long ly = lgefint(y);
1657 [ + + ]: 144317994 : if (ly == 2) return x;
1658 : 123847534 : av = avma;
1659 : 123847534 : (void)new_chunk(3+ly+lgefint(x)); /* HACK */
1660 : 123847534 : y = mului(u,y);
1661 : 144317994 : avma = av; return subii(x, y);
1662 : : }
1663 : : /* x + u*y */
1664 : : INLINE GEN
1665 : 144225950 : addmuliu_inplace(GEN x, GEN y, ulong u)
1666 : : {
1667 : : pari_sp av;
1668 : 144225950 : long ly = lgefint(y);
1669 [ + + ]: 144225950 : if (ly == 2) return x;
1670 : 124124112 : av = avma;
1671 : 124124112 : (void)new_chunk(3+ly+lgefint(x)); /* HACK */
1672 : 124124112 : y = mului(u,y);
1673 : 144225950 : avma = av; return addii(x, y);
1674 : : }
1675 : : /* ux + vy */
1676 : : INLINE GEN
1677 : 13413834 : lincombii(GEN u, GEN v, GEN x, GEN y)
1678 : : {
1679 : 13413834 : long lx = lgefint(x), ly;
1680 : : GEN p1, p2;
1681 : : pari_sp av;
1682 [ + + ]: 13413834 : if (lx == 2) return mulii(v,y);
1683 : 7667982 : ly = lgefint(y);
1684 [ + + ]: 7667982 : if (ly == 2) return mulii(u,x);
1685 : 7168802 : av = avma; (void)new_chunk(lx+ly+lgefint(u)+lgefint(v)); /* HACK */
1686 : 7168802 : p1 = mulii(u,x);
1687 : 7168802 : p2 = mulii(v,y);
1688 : 13413834 : avma = av; return addii(p1,p2);
1689 : : }
1690 : :
1691 : : /*******************************************************************/
1692 : : /* */
1693 : : /* GEN SUBTYPES */
1694 : : /* */
1695 : : /*******************************************************************/
1696 : :
1697 : : INLINE int
1698 : 463711934 : is_const_t(long t) { return (t < t_POLMOD); }
1699 : : INLINE int
1700 : 320359 : is_extscalar_t(long t) { return (t <= t_POL); }
1701 : : INLINE int
1702 : 168703 : is_intreal_t(long t) { return (t <= t_REAL); }
1703 : : INLINE int
1704 [ + + ][ + + ]: 172185290 : is_matvec_t(long t) { return (t >= t_VEC && t <= t_MAT); }
1705 : : INLINE int
1706 : 29731346 : is_noncalc_t(long tx) { return (tx) >= t_LIST; }
1707 : : INLINE int
1708 [ + + ][ + + ]: 43676 : is_rational_t(long t) { return (t == t_INT || t == t_FRAC); }
1709 : : INLINE int
1710 : 954942150 : is_recursive_t(long t) { return lontyp[t]; }
1711 : : INLINE int
1712 : 86167845 : is_scalar_t(long t) { return (t < t_POL); }
1713 : : INLINE int
1714 [ + + ][ + + ]: 436395 : is_vec_t(long t) { return (t == t_VEC || t == t_COL); }
1715 : :
1716 : : /*******************************************************************/
1717 : : /* */
1718 : : /* TRANSCENDENTAL */
1719 : : /* */
1720 : : /*******************************************************************/
1721 : : INLINE GEN
1722 : 3372115 : sqrtr(GEN x) {
1723 : 3372115 : long s = signe(x);
1724 [ + + ]: 3372115 : if (s == 0) return real_0_bit(expo(x) >> 1);
1725 [ + + ]: 3353561 : if (s >= 0) return sqrtr_abs(x);
1726 : 3372115 : retmkcomplex(gen_0, sqrtr_abs(x));
1727 : : }
1728 : : /* x^(1/n) */
1729 : : INLINE GEN
1730 : 16611 : sqrtnr(GEN x, long n) { return mpexp(divrs(mplog(x), n)); }
1731 : :
1732 : : /*******************************************************************/
1733 : : /* */
1734 : : /* MISCELLANEOUS */
1735 : : /* */
1736 : : /*******************************************************************/
1737 [ + + ][ + + ]: 168647 : INLINE int ismpzero(GEN x) { return is_intreal_t(typ(x)) && !signe(x); }
1738 [ + + ][ + + ]: 162311388 : INLINE int isintzero(GEN x) { return typ(x) == t_INT && !signe(x); }
1739 [ + + ][ + + ]: 2272519 : INLINE int isint1(GEN x) { return typ(x)==t_INT && equali1(x); }
1740 [ # # ][ # # ]: 0 : INLINE int isintm1(GEN x){ return typ(x)==t_INT && equalim1(x);}
1741 : 92313440 : INLINE int equali1(GEN n)
1742 [ + + ][ + + ]: 92313440 : { return (ulong) n[1] == (evallgefint(3UL) | evalsigne(1)) && n[2] == 1; }
1743 : 28972 : INLINE int equalim1(GEN n)
1744 [ + + ][ + + ]: 28972 : { return (ulong) n[1] == (evallgefint(3UL) | evalsigne(-1)) && n[2] == 1; }
1745 : : /* works only for POSITIVE integers */
1746 : 461914706 : INLINE int is_pm1(GEN n)
1747 [ + + ][ + + ]: 461914706 : { return lgefint(n) == 3 && n[2] == 1; }
1748 : 57762519 : INLINE int is_bigint(GEN n)
1749 [ + + ][ + + ]: 57762519 : { long l = lgefint(n); return l > 3 || (l == 3 && (n[2] & HIGHBIT)); }
[ + + ]
1750 : :
1751 : 103576393 : INLINE int odd(long x) { return x & 1; }
1752 : 22729454 : INLINE int both_odd(long x, long y) { return x & y & 1; }
1753 : :
1754 : : INLINE int
1755 [ + + ][ + + ]: 646827602 : isonstack(GEN x) { return ((pari_sp)x >= bot && (pari_sp)x < top); }
1756 : :
1757 : : /* assume 0 <= k <= BITS_IN_LONG. Return uniform random 0 <= x < (1<<k) */
1758 : : INLINE long
1759 : 4983156 : random_bits(long k) { return pari_rand() >> (BITS_IN_LONG - k); }
1760 : :
1761 : : /* assume x != 0 and x t_REAL, return an approximation to log2(|x|) */
1762 : : INLINE double
1763 : 9928442 : dbllog2r(GEN x)
1764 : 9928442 : { return log2((double)(ulong)x[2]) + (double)(expo(x) - (BITS_IN_LONG-1)); }
1765 : :
1766 : : INLINE GEN
1767 : 97008 : mul_content(GEN cx, GEN cy)
1768 : : {
1769 [ + + ]: 97008 : if (!cx) return cy;
1770 [ + + ]: 60342 : if (!cy) return cx;
1771 : 97008 : return gmul(cx,cy);
1772 : : }
1773 : : INLINE GEN
1774 : 89890 : mul_denom(GEN dx, GEN dy)
1775 : : {
1776 [ + + ]: 89890 : if (!dx) return dy;
1777 [ + + ]: 51973 : if (!dy) return dx;
1778 : 89890 : return mulii(dx,dy);
1779 : : }
1780 : :
1781 : : /* POLYNOMIALS */
1782 : : INLINE GEN
1783 [ + + ]: 9941245 : constant_term(GEN x) { return signe(x)? gel(x,2): gen_0; }
1784 : : INLINE GEN
1785 [ + - ]: 31108510 : leading_term(GEN x) { return lg(x) == 2? gen_0: gel(x,lg(x)-1); }
1786 : : INLINE ulong
1787 [ + - ]: 35688 : Flx_lead(GEN x) { return lg(x) == 2? 0: x[lg(x)-1]; }
1788 : : INLINE long
1789 : 689101692 : degpol(GEN x) { return lg(x)-3; }
1790 : : INLINE long
1791 : 268592975 : lgpol(GEN x) { return lg(x)-2; }
1792 : : INLINE long
1793 : 13136344 : lgcols(GEN x) { return lg(gel(x,1)); }
1794 : : INLINE long
1795 : 7340151 : nbrows(GEN x) { return lg(gel(x,1))-1; }
1796 : : INLINE GEN
1797 : 2196 : truecoeff(GEN x, long n) { return polcoeff0(x,n,-1); }
1798 : :
1799 : : INLINE GEN
1800 : 160397 : RgXQ_mul(GEN y, GEN x, GEN T) { return RgX_rem(RgX_mul(y, x), T); }
1801 : : INLINE GEN
1802 : 91513 : RgXQ_sqr(GEN x, GEN T) { return RgX_rem(RgX_sqr(x), T); }
1803 : :
1804 : : INLINE GEN
1805 : 49592 : ZXQ_mul(GEN y, GEN x, GEN T) { return ZX_rem(ZX_mul(y, x), T); }
1806 : : INLINE GEN
1807 : 7568 : ZXQ_sqr(GEN x, GEN T) { return ZX_rem(ZX_sqr(x), T); }
1808 : :
1809 : : INLINE GEN
1810 : 32859041 : RgX_copy(GEN x)
1811 : : {
1812 : : long lx, i;
1813 : 32859041 : GEN y = cgetg_copy(x, &lx); y[1] = x[1];
1814 [ + + ]: 116842016 : for (i = 2; i<lx; i++) gel(y,i) = gcopy(gel(x,i));
1815 : 32859041 : return y;
1816 : : }
1817 : : INLINE GEN
1818 : 100940 : RgX_renormalize(GEN x) { return RgX_renormalize_lg(x, lg(x)); }
1819 : : INLINE GEN
1820 : 3720339 : RgX_div(GEN x, GEN y) { return RgX_divrem(x,y,NULL); }
1821 : : INLINE GEN
1822 : 924138 : RgX_rem(GEN x, GEN y) { return RgX_divrem(x,y,ONLY_REM); }
1823 : : INLINE GEN
1824 : 0 : RgXQX_div(GEN x, GEN y, GEN T) { return RgXQX_divrem(x,y,T,NULL); }
1825 : : INLINE GEN
1826 : 5952 : RgXQX_rem(GEN x, GEN y, GEN T) { return RgXQX_divrem(x,y,T,ONLY_REM); }
1827 : : INLINE GEN
1828 : 353334 : FpX_div(GEN x, GEN y, GEN p) { return FpX_divrem(x,y,p, NULL); }
1829 : : INLINE GEN
1830 : 771793 : Flx_div(GEN x, GEN y, ulong p) { return Flx_divrem(x,y,p, NULL); }
1831 : : INLINE GEN
1832 : 586049 : F2x_div(GEN x, GEN y) { return F2x_divrem(x,y, NULL); }
1833 : : INLINE GEN
1834 : 0 : FpV_FpC_mul(GEN x, GEN y, GEN p) { return FpV_dotproduct(x,y,p); }
1835 : : INLINE GEN
1836 : 11209831 : pol0_Flx(long sv) { return mkvecsmall(sv); }
1837 : : INLINE GEN
1838 : 5321555 : pol1_Flx(long sv) { return mkvecsmall2(sv, 1); }
1839 : : INLINE GEN
1840 : 1800227 : polx_Flx(long sv) { return mkvecsmall3(sv, 0, 1); }
1841 : : INLINE GEN
1842 : 0 : zero_zx(long sv) { return zero_Flx(sv); }
1843 : : INLINE GEN
1844 : 0 : polx_zx(long sv) { return polx_Flx(sv); }
1845 : : INLINE GEN
1846 : 0 : zx_shift(GEN x, long n) { return Flx_shift(x,n); }
1847 : : INLINE GEN
1848 : 0 : zx_renormalize(GEN x, long l) { return Flx_renormalize(x,l); }
1849 : : INLINE GEN
1850 : 36 : zero_F2x(long sv) { return zero_Flx(sv); }
1851 : : INLINE GEN
1852 : 956829 : pol0_F2x(long sv) { return pol0_Flx(sv); }
1853 : : INLINE GEN
1854 : 260886 : pol1_F2x(long sv) { return pol1_Flx(sv); }
1855 : : INLINE GEN
1856 : 101535 : polx_F2x(long sv) { return mkvecsmall2(sv, 2); }
1857 : : INLINE int
1858 : 830 : F2x_equal1(GEN x) { return Flx_equal1(x); }
1859 : : INLINE int
1860 : 566826 : F2x_equal(GEN V, GEN W) { return Flx_equal(V,W); }
1861 : : INLINE GEN
1862 : 0 : F2v_copy(GEN x) { return leafcopy(x); }
1863 : : INLINE GEN
1864 : 565832 : Flv_copy(GEN x) { return leafcopy(x); }
1865 : : INLINE GEN
1866 : 19051235 : Flx_copy(GEN x) { return leafcopy(x); }
1867 : : INLINE GEN
1868 : 9392424 : vecsmall_copy(GEN x) { return leafcopy(x); }
1869 : : INLINE int
1870 [ + + ][ + + ]: 1517925 : Flx_equal1(GEN x) { return degpol(x)==0 && x[2] == 1; }
1871 : : INLINE int
1872 [ + + ][ + + ]: 7749 : ZX_equal1(GEN x) { return degpol(x)==0 && equali1(gel(x,2)); }
1873 : :
1874 : : INLINE GEN
1875 : 35832304 : ZX_renormalize(GEN x, long lx) { return ZXX_renormalize(x,lx); }
1876 : : INLINE GEN
1877 : 42235128 : FpX_renormalize(GEN x, long lx) { return ZXX_renormalize(x,lx); }
1878 : : INLINE GEN
1879 : 108111 : FpXX_renormalize(GEN x, long lx) { return ZXX_renormalize(x,lx); }
1880 : : INLINE GEN
1881 : 229864 : FpXQX_renormalize(GEN x, long lx) { return ZXX_renormalize(x,lx); }
1882 : : INLINE GEN
1883 : 14490023 : F2x_renormalize(GEN x, long lx) { return Flx_renormalize(x,lx); }
1884 : : INLINE GEN
1885 : 3443 : F2v_to_F2x(GEN x, long sv) {
1886 : 3443 : GEN y = leafcopy(x);
1887 : 3443 : y[1] = sv; F2x_renormalize(y, lg(y)); return y;
1888 : : }
1889 : :
1890 : : INLINE GEN
1891 : 0 : ZX_ZXY_resultant(GEN a, GEN b) { return ZX_ZXY_rnfequation(a,b,NULL); }
1892 : : INLINE long
1893 : 1896 : sturm(GEN x) { return sturmpart(x, NULL, NULL); }
1894 : : INLINE GEN
1895 : 14032 : resultant(GEN x, GEN y) { return resultant_all(x,y,NULL); }
1896 : :
1897 : : INLINE long
1898 : 1208 : gval(GEN x, long v) {
1899 : 1208 : pari_sp av = avma;
1900 : 1208 : long n = gvaluation(x, pol_x(v));
1901 : 1208 : avma = av; return n;
1902 : : }
1903 : :
1904 : : INLINE void
1905 : 290230 : RgX_shift_inplace_init(long v)
1906 [ + + ]: 290230 : { if (v) (void)cgetg(v, t_VECSMALL); }
1907 : : /* shift polynomial in place. assume v free cells have been left before x */
1908 : : INLINE GEN
1909 : 290230 : RgX_shift_inplace(GEN x, long v)
1910 : : {
1911 : : long i, lx;
1912 : : GEN y, z;
1913 [ + + ]: 290230 : if (!v) return x;
1914 : 170924 : lx = lg(x);
1915 [ - + ]: 170924 : if (lx == 2) return x;
1916 : 170924 : y = x + v;
1917 : 170924 : z = x + lx;
1918 : : /* stackdummy from normalizepol: move it up */
1919 [ - + ]: 170924 : if (lg(z) != v) x[lx + v] = z[0];
1920 [ + + ]: 3113058 : for (i = lx-1; i >= 2; i--) gel(y,i) = gel(x,i);
1921 [ + + ]: 494061 : for (i = v+1; i >= 2; i--) gel(x,i) = gen_0;
1922 : : /* leave x[1] alone: it is correct */
1923 : 290230 : x[0] = evaltyp(t_POL) | evallg(lx+v); return x;
1924 : : }
1925 : :
1926 : :
1927 : : /* LINEAR ALGEBRA */
1928 : : INLINE GEN
1929 : 1830 : zv_to_ZV(GEN x) { return vecsmall_to_vec(x); }
1930 : : INLINE GEN
1931 : 207374 : zc_to_ZC(GEN x) { return vecsmall_to_col(x); }
1932 : : INLINE GEN
1933 : 105398 : ZV_to_zv(GEN x) { return vec_to_vecsmall(x); }
1934 : : INLINE GEN
1935 : 0 : zx_to_zv(GEN x, long N) { return Flx_to_Flv(x,N); }
1936 : : INLINE GEN
1937 : 0 : zv_to_zx(GEN x, long sv) { return Flv_to_Flx(x,sv); }
1938 : : INLINE GEN
1939 : 0 : zm_to_zxV(GEN x, long sv) { return Flm_to_FlxV(x,sv); }
1940 : : INLINE GEN
1941 : 0 : zero_zm(long x, long y) { return zero_Flm(x,y); }
1942 : : INLINE GEN
1943 : 3183850 : zero_zv(long x) { return zero_Flv(x); }
1944 : : INLINE GEN
1945 : 52 : zm_transpose(GEN x) { return Flm_transpose(x); }
1946 : : INLINE GEN
1947 : 0 : zm_copy(GEN x) { return Flm_copy(x); }
1948 : : INLINE GEN
1949 : 453167 : zv_copy(GEN x) { return Flv_copy(x); }
1950 : : INLINE GEN
1951 : 0 : row_zm(GEN x, long i) { return row_Flm(x,i); }
1952 : :
1953 : : INLINE GEN
1954 : 337742 : ZC_hnfrem(GEN x, GEN y) { return ZC_hnfremdiv(x,y,NULL); }
1955 : : INLINE GEN
1956 : 14280 : ZM_hnfrem(GEN x, GEN y) { return ZM_hnfdivrem(x,y,NULL); }
1957 : : INLINE GEN
1958 : 695202 : ZM_lll(GEN x, double D, long f) { return ZM_lll_norms(x,D,f,NULL); }
1959 : : INLINE void
1960 [ + + ]: 17488 : RgM_dimensions(GEN x, long *m, long *n) { *n = lg(x)-1; *m = *n? nbrows(x): 0; }
1961 : : INLINE GEN
1962 : 9285 : RgM_inv(GEN a) { return RgM_solve(a, NULL); }
1963 : : INLINE GEN
1964 : 2794279 : RgM_shallowcopy(GEN x)
1965 : : {
1966 : : long l;
1967 : 2794279 : GEN y = cgetg_copy(x, &l);
1968 [ + + ]: 14597003 : while (--l > 0) gel(y,l) = leafcopy(gel(x,l));
1969 : 2794279 : return y;
1970 : : }
1971 : : INLINE GEN
1972 : 822 : F2m_copy(GEN x) { return RgM_shallowcopy(x); }
1973 : :
1974 : : INLINE GEN
1975 : 123185 : Flm_copy(GEN x) { return RgM_shallowcopy(x); }
1976 : :
1977 : : /* divisibility: return 1 if y[i] | x[i] for all i, 0 otherwise. Assume
1978 : : * x,y are ZV of the same length */
1979 : : INLINE int
1980 : 13248 : ZV_dvd(GEN x, GEN y)
1981 : : {
1982 : 13248 : long i, l = lg(x);
1983 [ + + ]: 20924 : for (i=1; i < l; i++)
1984 [ + + ]: 16856 : if ( ! dvdii( gel(x,i), gel(y,i) ) ) return 0;
1985 : 13248 : return 1;
1986 : : }
1987 : :
1988 : : /* Fq */
1989 : : INLINE GEN
1990 : 953275 : Fq_red(GEN x, GEN T, GEN p)
1991 [ + + ]: 953275 : { return typ(x)==t_INT? Fp_red(x,p): FpXQ_red(x,T,p); }
1992 : :
1993 : : /* FpXQX */
1994 : : INLINE GEN
1995 : 0 : FpXQX_div(GEN x, GEN y, GEN T, GEN p) { return FpXQX_divrem(x, y, T, p, NULL); }
1996 : : INLINE GEN
1997 : 28170 : FlxqX_rem(GEN x, GEN y, GEN T, ulong p) { return FlxqX_divrem(x, y, T, p, ONLY_REM); }
1998 : : INLINE GEN
1999 : 2764 : FlxqX_div(GEN x, GEN y, GEN T, ulong p) { return FlxqX_divrem(x, y, T, p, NULL); }
2000 : :
2001 : : /* FqX */
2002 : : INLINE GEN
2003 [ + - ]: 1596 : FqX_red(GEN z, GEN T, GEN p) { return T? FpXQX_red(z, T, p): FpX_red(z, p); }
2004 : : INLINE GEN
2005 [ + + ]: 393660 : FqX_add(GEN x,GEN y,GEN T,GEN p) { return T? FpXX_add(x,y,p): FpX_add(x,y,p); }
2006 : : INLINE GEN
2007 [ + + ]: 2136 : FqX_neg(GEN x,GEN T,GEN p) { return T? FpXX_neg(x,p): FpX_neg(x,p); }
2008 : : INLINE GEN
2009 [ + + ]: 43292 : FqX_sub(GEN x,GEN y,GEN T,GEN p) { return T? FpXX_sub(x,y,p): FpX_sub(x,y,p); }
2010 : : INLINE GEN
2011 : 276008 : FqX_Fp_mul(GEN P, GEN u, GEN T, GEN p)
2012 [ + + ]: 276008 : { return T? FpXX_Fp_mul(P, u, p): FpX_Fp_mul(P, u, p); }
2013 : : INLINE GEN
2014 : 256718 : FqX_Fq_mul(GEN P, GEN U, GEN T, GEN p)
2015 [ + + ]: 256718 : { return typ(U)==t_INT ? FqX_Fp_mul(P, U, T, p): FpXQX_FpXQ_mul(P, U, T, p); }
2016 : : INLINE GEN
2017 : 16748 : FqX_mul(GEN x, GEN y, GEN T, GEN p)
2018 [ + + ]: 16748 : { return T? FpXQX_mul(x, y, T, p): FpX_mul(x, y, p); }
2019 : : INLINE GEN
2020 : 200344 : FqX_mulu(GEN x, ulong y, GEN T, GEN p)
2021 [ + + ]: 200344 : { return T? FpXX_mulu(x, y, p): FpX_mulu(x, y, p); }
2022 : : INLINE GEN
2023 : 986 : FqX_sqr(GEN x, GEN T, GEN p)
2024 [ + + ]: 986 : { return T? FpXQX_sqr(x, T, p): FpX_sqr(x, p); }
2025 : : INLINE GEN
2026 : 1847 : FqX_div(GEN x, GEN y, GEN T, GEN p)
2027 [ + + ]: 1847 : { return T? FpXQX_divrem(x,y,T,p,NULL): FpX_divrem(x,y,p,NULL); }
2028 : : INLINE GEN
2029 : 6747 : FqX_rem(GEN x, GEN y, GEN T, GEN p)
2030 [ + + ]: 6747 : { return T? FpXQX_rem(x,y,T,p): FpX_rem(x,y,p); }
2031 : : INLINE GEN
2032 : 0 : FqX_divrem(GEN x, GEN y, GEN T, GEN p, GEN *z)
2033 [ # # ]: 0 : { return T? FpXQX_divrem(x,y,T,p,z): FpX_divrem(x,y,p,z); }
2034 : : INLINE GEN
2035 : 5828 : FqX_gcd(GEN P,GEN Q,GEN T,GEN p)
2036 [ + + ]: 5828 : {return T? FpXQX_gcd(P,Q,T,p): FpX_gcd(P,Q,p);}
2037 : : INLINE GEN
2038 : 30131 : FqX_extgcd(GEN P,GEN Q,GEN T,GEN p, GEN *U, GEN *V)
2039 [ + + ]: 30131 : { return T? FpXQX_extgcd(P,Q,T,p,U,V): FpX_extgcd(P,Q,p,U,V); }
2040 : :
2041 : : /*FqXQ*/
2042 : : INLINE GEN
2043 : 0 : FqXQ_add(GEN x, GEN y, GEN S/*unused*/, GEN T, GEN p)
2044 [ # # ]: 0 : { (void)S; return T? FpXX_add(x,y,p): FpX_add(x,y,p); }
2045 : : INLINE GEN
2046 : 0 : FqXQ_sub(GEN x, GEN y, GEN S/*unused*/, GEN T, GEN p)
2047 [ # # ]: 0 : { (void)S; return T? FpXX_sub(x,y,p): FpX_sub(x,y,p); }
2048 : : INLINE GEN
2049 : 8928 : FqXQ_div(GEN x, GEN y, GEN S, GEN T, GEN p)
2050 [ + + ]: 8928 : { return T? FpXQXQ_div(x,y,S,T,p): FpXQ_div(x,y,S,p); }
2051 : : INLINE GEN
2052 : 0 : FqXQ_inv(GEN x, GEN S, GEN T, GEN p)
2053 [ # # ]: 0 : { return T? FpXQXQ_inv(x,S,T,p): FpXQ_inv(x,S,p); }
2054 : : INLINE GEN
2055 : 0 : FqXQ_invsafe(GEN x, GEN S, GEN T, GEN p)
2056 [ # # ]: 0 : { return T? FpXQXQ_invsafe(x,S,T,p): FpXQ_inv(x,S,p); }
2057 : : INLINE GEN
2058 : 21192 : FqXQ_mul(GEN x, GEN y, GEN S, GEN T, GEN p)
2059 [ + + ]: 21192 : { return T? FpXQXQ_mul(x,y,S,T,p): FpXQ_mul(x,y,S,p); }
2060 : : INLINE GEN
2061 : 9248 : FqXQ_sqr(GEN x, GEN S, GEN T, GEN p)
2062 [ + + ]: 9248 : { return T? FpXQXQ_sqr(x,S,T,p): FpXQ_sqr(x,S,p); }
2063 : : INLINE GEN
2064 : 0 : FqXQ_pow(GEN x, GEN n, GEN S, GEN T, GEN p)
2065 [ # # ]: 0 : { return T? FpXQXQ_pow(x,n,S,T,p): FpXQ_pow(x,n,S,p); }
2066 : :
2067 : : /*FpXQ*/
2068 : : INLINE GEN
2069 : 0 : FpXQ_add(GEN x,GEN y,GEN T/*unused*/,GEN p)
2070 : 0 : { (void)T; return FpX_add(x,y,p); }
2071 : : INLINE GEN
2072 : 0 : FpXQ_sub(GEN x,GEN y,GEN T/*unused*/,GEN p)
2073 : 0 : { (void)T; return FpX_sub(x,y,p); }
2074 : :
2075 : : /*Flxq*/
2076 : : INLINE GEN
2077 : 0 : Flxq_add(GEN x,GEN y,GEN T/*unused*/,ulong p)
2078 : 0 : { (void)T; return Flx_add(x,y,p); }
2079 : : INLINE GEN
2080 : 0 : Flxq_sub(GEN x,GEN y,GEN T/*unused*/,ulong p)
2081 : 0 : { (void)T; return Flx_sub(x,y,p); }
2082 : :
2083 : : /* F2x */
2084 : :
2085 : : INLINE ulong
2086 : 33833976 : F2x_coeff(GEN x,long v)
2087 : : {
2088 : 33833976 : ulong u=(ulong)x[2+divsBIL(v)];
2089 : 33833976 : return (u>>remsBIL(v))&1UL;
2090 : : }
2091 : :
2092 : : INLINE void
2093 : 878682 : F2x_clear(GEN x,long v)
2094 : : {
2095 : 878682 : ulong* u=(ulong*)&x[2+divsBIL(v)];
2096 : 878682 : *u&=~(1UL<<remsBIL(v));
2097 : 878682 : }
2098 : :
2099 : : INLINE void
2100 : 9781563 : F2x_set(GEN x,long v)
2101 : : {
2102 : 9781563 : ulong* u=(ulong*)&x[2+divsBIL(v)];
2103 : 9781563 : *u|=1UL<<remsBIL(v);
2104 : 9781563 : }
2105 : :
2106 : : INLINE void
2107 : 183381 : F2x_flip(GEN x,long v)
2108 : : {
2109 : 183381 : ulong* u=(ulong*)&x[2+divsBIL(v)];
2110 : 183381 : *u^=1UL<<remsBIL(v);
2111 : 183381 : }
2112 : :
2113 : : /* F2v */
2114 : :
2115 : : INLINE ulong
2116 : 33633310 : F2v_coeff(GEN x,long v) { return F2x_coeff(x,v-1); }
2117 : :
2118 : : INLINE void
2119 : 878682 : F2v_clear(GEN x,long v) { F2x_clear(x,v-1); }
2120 : :
2121 : : INLINE void
2122 : 6169135 : F2v_set(GEN x,long v) { F2x_set(x,v-1); }
2123 : :
2124 : : INLINE void
2125 : 183381 : F2v_flip(GEN x,long v) { F2x_flip(x,v-1); }
2126 : :
2127 : : /* F2m */
2128 : :
2129 : : INLINE ulong
2130 : 4592398 : F2m_coeff(GEN x, long a, long b) { return F2v_coeff(gel(x,b), a); }
2131 : :
2132 : : INLINE void
2133 : 0 : F2m_clear(GEN x, long a, long b) { F2v_clear(gel(x,b), a); }
2134 : :
2135 : : INLINE void
2136 : 587057 : F2m_set(GEN x, long a, long b) { F2v_set(gel(x,b), a); }
2137 : :
2138 : : INLINE void
2139 : 183381 : F2m_flip(GEN x, long a, long b) { F2v_flip(gel(x,b), a); }
2140 : :
2141 : : /* ARITHMETIC */
2142 : : INLINE GEN
2143 : 156 : matpascal(long n) { return matqpascal(n, NULL); }
2144 : : INLINE long
2145 : 131732 : Z_issquare(GEN x) { return Z_issquareall(x, NULL); }
2146 : : INLINE long
2147 : 8 : Z_ispower(GEN x, ulong k) { return Z_ispowerall(x, k, NULL); }
2148 : : INLINE GEN
2149 : 1315363 : sqrti(GEN x) { return sqrtremi(x,NULL); }
2150 : : INLINE GEN
2151 : 801675 : gaddgs(GEN y, long s) { return gaddsg(s,y); }
2152 : : INLINE int
2153 : 5580 : gcmpgs(GEN y, long s) { return -gcmpsg(s,y); }
2154 : : INLINE int
2155 : 3188 : gequalgs(GEN y, long s) { return gequalsg(s,y); }
2156 : : INLINE GEN
2157 : 0 : gmaxsg(long s, GEN y) { return gmaxgs(y,s); }
2158 : : INLINE GEN
2159 : 0 : gminsg(long s, GEN y) { return gmings(y,s); }
2160 : : INLINE GEN
2161 : 1139672 : gmulgs(GEN y, long s) { return gmulsg(s,y); }
2162 : : INLINE GEN
2163 : 208418 : gsubgs(GEN y, long s) { return gaddgs(y, -s); }
2164 : : INLINE GEN
2165 : 61672 : gdivsg(long s, GEN y) { return gdiv(stoi(s), y); }
2166 : :
2167 : : /* x t_COMPLEX */
2168 : : INLINE GEN
2169 : 5701952 : cxnorm(GEN x) { return gadd(gsqr(gel(x,1)), gsqr(gel(x,2))); }
2170 : : /* q t_QUAD */
2171 : : INLINE GEN
2172 : 576 : quadnorm(GEN q)
2173 : : {
2174 : 576 : GEN X = gel(q,1), b = gel(X,3), c = gel(X,2);
2175 : 576 : GEN z, u = gel(q,3), v = gel(q,2);
2176 [ + + ][ + - ]: 576 : if (typ(u) == t_INT && typ(v) == t_INT) /* generic case */
2177 : : {
2178 [ + + ]: 228 : z = signe(b)? mulii(v, addii(u,v)): sqri(v);
2179 : 228 : return addii(z, mulii(c, sqri(u)));
2180 : : }
2181 : : else
2182 : : {
2183 [ + - ]: 348 : z = signe(b)? gmul(v, gadd(u,v)): gsqr(v);
2184 : 576 : return gadd(z, gmul(c, gsqr(u)));
2185 : : }
2186 : : }
2187 : : /* x a t_QUAD, return the associated discriminant */
2188 : : INLINE GEN
2189 : 104 : quad_disc(GEN x)
2190 : : {
2191 : 104 : GEN Q = gel(x,1), b = gel(Q,3), c = gel(Q,2), c4;
2192 [ + + ]: 104 : if (is_pm1(b))
2193 : : {
2194 : 88 : pari_sp av = avma; (void)new_chunk(lgefint(c) + 1);
2195 : 88 : c4 = shifti(c,2); avma = av; return subsi(1, c4);
2196 : : }
2197 : 104 : c4 = shifti(c,2); togglesign_safe(&c4); return c4;
2198 : : }
2199 : : INLINE GEN
2200 : 1999822 : qfb_disc3(GEN x, GEN y, GEN z) { return subii(sqri(y), shifti(mulii(x,z),2)); }
2201 : : INLINE GEN
2202 : 1959658 : qfb_disc(GEN x) { return qfb_disc3(gel(x,1), gel(x,2), gel(x,3)); }
2203 : :
2204 : : INLINE GEN
2205 : 54766 : sqrfrac(GEN x)
2206 : : {
2207 : 54766 : GEN z = cgetg(3,t_FRAC);
2208 : 54766 : gel(z,1) = sqri(gel(x,1));
2209 : 54766 : gel(z,2) = sqri(gel(x,2)); return z;
2210 : : }
2211 : :
2212 : : INLINE void
2213 : 1981744 : normalize_frac(GEN z) {
2214 [ + + ]: 1981744 : if (signe(gel(z,2)) < 0) { togglesign(gel(z,1)); setabssign(gel(z,2)); }
2215 : 1981744 : }
2216 : :
2217 : : INLINE GEN
2218 : 194863 : powii(GEN x, GEN n)
2219 : : {
2220 : 194863 : long ln = lgefint(n);
2221 [ + + ]: 194863 : if (ln == 3) {
2222 : : GEN z;
2223 [ + + ]: 194185 : if (signe(n) > 0) return powiu(x, n[2]);
2224 : 176 : z = cgetg(3, t_FRAC);
2225 : 176 : gel(z,1) = gen_1;
2226 : 176 : gel(z,2) = powiu(x, n[2]);
2227 : 176 : return z;
2228 : : }
2229 [ + - ]: 678 : if (ln == 2) return gen_1; /* rare */
2230 : : /* should never happen */
2231 : 194863 : return powgi(x, n); /* overflow unless x = 0, 1, -1 */
2232 : : }
2233 : : INLINE GEN
2234 : 420 : powIs(long n) {
2235 [ + + + + ]: 420 : switch(n & 3)
2236 : : {
2237 : 4 : case 1: return mkcomplex(gen_0,gen_1);
2238 : 176 : case 2: return gen_m1;
2239 : 216 : case 3: return mkcomplex(gen_0,gen_m1);
2240 : : }
2241 : 420 : return gen_1;
2242 : : }
2243 : :
2244 : : /*******************************************************************/
2245 : : /* */
2246 : : /* ASSIGNMENTS */
2247 : : /* */
2248 : : /*******************************************************************/
2249 : 0 : INLINE void mpexpz(GEN x, GEN z)
2250 : 0 : { pari_sp av = avma; gaffect(mpexp(x), z); avma = av; }
2251 : 0 : INLINE void mplogz(GEN x, GEN z)
2252 : 0 : { pari_sp av = avma; gaffect(mplog(x), z); avma = av; }
2253 : 0 : INLINE void mpcosz(GEN x, GEN z)
2254 : 0 : { pari_sp av = avma; gaffect(mpcos(x), z); avma = av; }
2255 : 0 : INLINE void mpsinz(GEN x, GEN z)
2256 : 0 : { pari_sp av = avma; gaffect(mpsin(x), z); avma = av; }
2257 : 0 : INLINE void gnegz(GEN x, GEN z)
2258 : 0 : { pari_sp av = avma; gaffect(gneg(x), z); avma = av; }
2259 : 0 : INLINE void gabsz(GEN x, long prec, GEN z)
2260 : 0 : { pari_sp av = avma; gaffect(gabs(x,prec), z); avma = av; }
2261 : 26164 : INLINE void gaddz(GEN x, GEN y, GEN z)
2262 : 26164 : { pari_sp av = avma; gaffect(gadd(x,y), z); avma = av; }
2263 : 0 : INLINE void gsubz(GEN x, GEN y, GEN z)
2264 : 0 : { pari_sp av = avma; gaffect(gsub(x,y), z); avma = av; }
2265 : 13098 : INLINE void gmulz(GEN x, GEN y, GEN z)
2266 : 13098 : { pari_sp av = avma; gaffect(gmul(x,y), z); avma = av; }
2267 : 0 : INLINE void gdivz(GEN x, GEN y, GEN z)
2268 : 0 : { pari_sp av = avma; gaffect(gdiv(x,y), z); avma = av; }
2269 : 0 : INLINE void gdiventz(GEN x, GEN y, GEN z)
2270 : 0 : { pari_sp av = avma; gaffect(gdivent(x,y), z); avma = av; }
2271 : 0 : INLINE void gmodz(GEN x, GEN y, GEN z)
2272 : 0 : { pari_sp av = avma; gaffect(gmod(x,y), z); avma = av; }
2273 : 0 : INLINE void gmul2nz(GEN x, long s, GEN z)
2274 : 0 : { pari_sp av = avma; gaffect(gmul2n(x,s), z); avma = av; }
2275 : 0 : INLINE void gshiftz(GEN x, long s, GEN z)
2276 : 0 : { pari_sp av = avma; gaffect(gshift(x,s), z); avma = av; }
2277 : :
2278 : : /*******************************************************************/
2279 : : /* */
2280 : : /* ELLIPTIC CURVES */
2281 : : /* */
2282 : : /*******************************************************************/
2283 : 1109997 : INLINE GEN ell_get_a1(GEN e) { return gel(e,1); }
2284 : 800937 : INLINE GEN ell_get_a2(GEN e) { return gel(e,2); }
2285 : 1121289 : INLINE GEN ell_get_a3(GEN e) { return gel(e,3); }
2286 : 1152189 : INLINE GEN ell_get_a4(GEN e) { return gel(e,4); }
2287 : 1387397 : INLINE GEN ell_get_a6(GEN e) { return gel(e,5); }
2288 : 1137298 : INLINE GEN ell_get_b2(GEN e) { return gel(e,6); }
2289 : 246470 : INLINE GEN ell_get_b4(GEN e) { return gel(e,7); }
2290 : 470490 : INLINE GEN ell_get_b6(GEN e) { return gel(e,8); }
2291 : 392616 : INLINE GEN ell_get_b8(GEN e) { return gel(e,9); }
2292 : 2594556 : INLINE GEN ell_get_c4(GEN e) { return gel(e,10); }
2293 : 2799868 : INLINE GEN ell_get_c6(GEN e) { return gel(e,11); }
2294 : 3519304 : INLINE GEN ell_get_disc(GEN e) { return gel(e,12); }
2295 : 473824 : INLINE GEN ell_get_j(GEN e) { return gel(e,13); }
2296 : 3580812 : INLINE long ell_get_type(GEN e) { return mael(e,14,1); }
2297 : 328092 : INLINE GEN ellff_get_field(GEN x) { return gmael(x, 15, 1); }
2298 : 145728 : INLINE GEN ellff_get_a4a6(GEN x) { return gmael(x, 15, 2); }
2299 : 192 : INLINE GEN ellQp_get_zero(GEN x) { return gmael(x, 15, 1); }
2300 : 48 : INLINE long ellQp_get_prec(GEN E) { GEN z = ellQp_get_zero(E); return valp(z); }
2301 : 140 : INLINE GEN ellQp_get_p(GEN E) { GEN z = ellQp_get_zero(E); return gel(z,2); }
2302 : 88 : INLINE long ellR_get_prec(GEN x) { return nbits2prec(mael3(x, 15, 1, 1)); }
2303 : 304 : INLINE long ellR_get_sign(GEN x) { return mael3(x, 15, 1, 2); }
2304 : :
2305 : 17003612 : INLINE int ell_is_inf(GEN z) { return lg(z) == 2; }
2306 : 265628 : INLINE GEN ellinf(void) { return mkvec(gen_0); }
2307 : :
2308 : : /*******************************************************************/
2309 : : /* */
2310 : : /* ALGEBRAIC NUMBER THEORY */
2311 : : /* */
2312 : : /*******************************************************************/
2313 : 8665437 : INLINE GEN pr_get_p(GEN pr) { return gel(pr,1); }
2314 : 1057988 : INLINE GEN pr_get_gen(GEN pr){ return gel(pr,2); }
2315 : : /* .[2] instead of itos works: e and f are small positive integers */
2316 : 583992 : INLINE long pr_get_e(GEN pr) { return gel(pr,3)[2]; }
2317 : 4525569 : INLINE long pr_get_f(GEN pr) { return gel(pr,4)[2]; }
2318 : 7061031 : INLINE GEN pr_get_tau(GEN pr){ return gel(pr,5); }
2319 : : INLINE int
2320 : 309067 : pr_is_inert(GEN P) { return pr_get_f(P) == lg(pr_get_gen(P))-1; }
2321 : : INLINE GEN
2322 : 41126 : pr_norm(GEN pr) { return powiu(pr_get_p(pr), pr_get_f(pr)); }
2323 : :
2324 : : /* assume nf a genuine nf */
2325 : : INLINE long
2326 : 1161 : nf_get_varn(GEN nf) { return varn(gel(nf,1)); }
2327 : : INLINE GEN
2328 : 3223995 : nf_get_pol(GEN nf) { return gel(nf,1); }
2329 : : INLINE long
2330 : 1456384 : nf_get_degree(GEN nf) { return degpol( nf_get_pol(nf) ); }
2331 : : INLINE long
2332 : 695469 : nf_get_r1(GEN nf) { GEN x = gel(nf,2); return itou(gel(x,1)); }
2333 : : INLINE long
2334 : 156 : nf_get_r2(GEN nf) { GEN x = gel(nf,2); return itou(gel(x,2)); }
2335 : : INLINE GEN
2336 : 9520 : nf_get_disc(GEN nf) { return gel(nf,3); }
2337 : : INLINE GEN
2338 : 240898 : nf_get_index(GEN nf) { return gel(nf,4); }
2339 : : INLINE GEN
2340 : 651795 : nf_get_M(GEN nf) { return gmael(nf,5,1); }
2341 : : INLINE GEN
2342 : 21082 : nf_get_G(GEN nf) { return gmael(nf,5,2); }
2343 : : INLINE GEN
2344 : 203745 : nf_get_roundG(GEN nf) { return gmael(nf,5,3); }
2345 : : INLINE GEN
2346 : 412 : nf_get_Tr(GEN nf) { return gmael(nf,5,4); }
2347 : : INLINE GEN
2348 : 408 : nf_get_diff(GEN nf) { return gmael(nf,5,5); }
2349 : : INLINE GEN
2350 : 22854 : nf_get_roots(GEN nf) { return gel(nf,6); }
2351 : : INLINE GEN
2352 : 3412790 : nf_get_zk(GEN nf) { return gel(nf,7); }
2353 : : INLINE GEN
2354 : 688307 : nf_get_invzk(GEN nf) { return gel(nf,8); }
2355 : : INLINE void
2356 : 1924 : nf_get_sign(GEN nf, long *r1, long *r2)
2357 : : {
2358 : 1924 : GEN x = gel(nf,2);
2359 : 1924 : *r1 = itou(gel(x,1));
2360 : 1924 : *r2 = itou(gel(x,2));
2361 : 1924 : }
2362 : :
2363 : : INLINE GEN
2364 : 4491 : abgrp_get_no(GEN x) { return gel(x,1); }
2365 : : INLINE GEN
2366 : 622831 : abgrp_get_cyc(GEN x) { return gel(x,2); }
2367 : : INLINE GEN
2368 : 154948 : abgrp_get_gen(GEN x) { return gel(x,3); }
2369 : : INLINE GEN
2370 : 617073 : bnf_get_nf(GEN bnf) { return gel(bnf,7); }
2371 : : INLINE GEN
2372 : 314276 : bnf_get_clgp(GEN bnf) { return gmael(bnf,8,1); }
2373 : : INLINE GEN
2374 : 348 : bnf_get_no(GEN bnf) { return abgrp_get_no(bnf_get_clgp(bnf)); }
2375 : : INLINE GEN
2376 : 162214 : bnf_get_cyc(GEN bnf) { return abgrp_get_cyc(bnf_get_clgp(bnf)); }
2377 : : INLINE GEN
2378 : 151630 : bnf_get_gen(GEN bnf) { return abgrp_get_gen(bnf_get_clgp(bnf)); }
2379 : : INLINE GEN
2380 : 208 : bnf_get_reg(GEN bnf) { return gmael(bnf,8,2); }
2381 : : INLINE GEN
2382 : 247927 : bnf_get_logfu(GEN bnf) { return gel(bnf,3); }
2383 : : INLINE GEN
2384 : 3182 : bnf_get_tuU(GEN bnf) { return gmael3(bnf,8,4,2); }
2385 : : INLINE long
2386 : 4058 : bnf_get_tuN(GEN bnf) { return gmael3(bnf,8,4,1)[2]; }
2387 : : INLINE GEN
2388 : 3470 : bnf_get_fu(GEN bnf) {
2389 : 3470 : GEN fu = bnf_get_fu_nocheck(bnf);
2390 [ - + ]: 3470 : if (typ(fu) == t_MAT) pari_err(e_MISC,"missing units in bnf");
2391 : 3470 : return fu;
2392 : : }
2393 : : INLINE GEN
2394 : 6543 : bnf_get_fu_nocheck(GEN bnf) { return gmael(bnf,8,5); }
2395 : :
2396 : : INLINE GEN
2397 : 246921 : bnr_get_bnf(GEN bnr) { return gel(bnr,1); }
2398 : : INLINE GEN
2399 : 123277 : bnr_get_bid(GEN bnr) { return gel(bnr,2); }
2400 : : INLINE GEN
2401 : 4919 : bnr_get_mod(GEN bnr) { return gmael(bnr,2,1); }
2402 : : INLINE GEN
2403 : 716 : bnr_get_nf(GEN bnr) { return gmael(bnr,1,7); }
2404 : : INLINE GEN
2405 : 136127 : bnr_get_clgp(GEN bnr) { return gel(bnr,5); }
2406 : : INLINE GEN
2407 : 4143 : bnr_get_no(GEN bnr) { return abgrp_get_no(bnr_get_clgp(bnr)); }
2408 : : INLINE GEN
2409 : 131474 : bnr_get_cyc(GEN bnr) { return abgrp_get_cyc(bnr_get_clgp(bnr)); }
2410 : : INLINE GEN
2411 : 36 : bnr_get_gen_nocheck(GEN bnr) { return abgrp_get_gen(bnr_get_clgp(bnr)); }
2412 : : INLINE GEN
2413 : 474 : bnr_get_gen(GEN bnr) {
2414 : 474 : GEN G = bnr_get_clgp(bnr);
2415 [ - + ]: 474 : if (lg(G) != 4)
2416 : 0 : pari_err(e_MISC,"missing bnr generators: please use bnrinit(,,1)");
2417 : 474 : return gel(G,3);
2418 : : }
2419 : :
2420 : : INLINE GEN
2421 : 198797 : bid_get_mod(GEN bid) { return gel(bid,1); }
2422 : : INLINE GEN
2423 : 51756 : bid_get_ideal(GEN bid) { return gmael(bid,1,1); }
2424 : : INLINE GEN
2425 : 71336 : bid_get_arch(GEN bid) { return gmael(bid,1,2); }
2426 : : INLINE GEN
2427 : 331833 : bid_get_grp(GEN bid) { return gel(bid,2); }
2428 : : INLINE GEN
2429 : 0 : bid_get_no(GEN bid) { return abgrp_get_no(bid_get_grp(bid)); }
2430 : : INLINE GEN
2431 : 328551 : bid_get_cyc(GEN bid) { return abgrp_get_cyc(bid_get_grp(bid)); }
2432 : : INLINE GEN
2433 : 0 : bid_get_gen_nocheck(GEN bid) { return abgrp_get_gen(bid_get_grp(bid)); }
2434 : : INLINE GEN
2435 : 2690 : bid_get_gen(GEN bid) {
2436 : 2690 : GEN G = bid_get_grp(bid);
2437 [ - + ]: 2690 : if (lg(G) != 4) pari_err(e_MISC,"missing bid generators. Use idealstar(,,2)");
2438 : 2690 : return abgrp_get_gen(G);
2439 : : }
2440 : : INLINE GEN
2441 : 496 : gal_get_pol(GEN gal) { return gel(gal,1); }
2442 : : INLINE GEN
2443 : 528 : gal_get_p(GEN gal) { return gmael(gal,2,1); }
2444 : : INLINE GEN
2445 : 24 : gal_get_e(GEN gal) { return gmael(gal,2,2); }
2446 : : INLINE GEN
2447 : 739 : gal_get_mod(GEN gal) { return gmael(gal,2,3); }
2448 : : INLINE GEN
2449 : 811 : gal_get_roots(GEN gal) { return gel(gal,3); }
2450 : : INLINE GEN
2451 : 615 : gal_get_invvdm(GEN gal) { return gel(gal,4); }
2452 : : INLINE GEN
2453 : 615 : gal_get_den(GEN gal) { return gel(gal,5); }
2454 : : INLINE GEN
2455 : 452 : gal_get_group(GEN gal) { return gel(gal,6); }
2456 : : INLINE GEN
2457 : 236 : gal_get_gen(GEN gal) { return gel(gal,7); }
2458 : : INLINE GEN
2459 : 236 : gal_get_orders(GEN gal) { return gel(gal,8); }
2460 : :
2461 : : /* assume rnf a genuine rnf */
2462 : : INLINE long
2463 : 524 : rnf_get_degree(GEN rnf) { return degpol(rnf_get_pol(rnf)); }
2464 : : INLINE long
2465 : 308 : rnf_get_nfdegree(GEN rnf) { return degpol(nf_get_pol(rnf_get_nf(rnf))); }
2466 : : INLINE long
2467 : 104 : rnf_get_absdegree(GEN rnf) { return degpol(gmael(rnf,11,1)); }
2468 : : INLINE GEN
2469 : 2824 : rnf_get_nf(GEN rnf) { return gel(rnf,10); }
2470 : : INLINE void
2471 : 420 : rnf_get_nfzk(GEN rnf, GEN *b, GEN *cb) {*b=gmael(rnf,2,1); *cb=gmael(rnf,2,2);}
2472 : : INLINE GEN
2473 : 1040 : rnf_get_polabs(GEN rnf) { return gmael(rnf,11,1); }
2474 : : INLINE GEN
2475 : 4044 : rnf_get_pol(GEN rnf) { return gel(rnf,1); }
2476 : : INLINE GEN
2477 : 80 : rnf_get_disc(GEN rnf) { return gel(rnf,3); }
2478 : : INLINE GEN
2479 : 60 : rnf_get_index(GEN rnf) { return gel(rnf,4); }
2480 : : INLINE long
2481 : 0 : rnf_get_varn(GEN rnf) { return varn(gel(rnf,1)); }
2482 : : INLINE GEN
2483 : 2648 : rnf_get_nfpol(GEN rnf) { return gmael(rnf,10,1); }
2484 : : INLINE long
2485 : 32 : rnf_get_nfvarn(GEN rnf) { return varn(gmael(rnf,10,1)); }
2486 : : INLINE GEN
2487 : 1100 : rnf_get_zk(GEN rnf) { return gel(rnf,7); }
2488 : : INLINE GEN
2489 : 768 : rnf_get_map(GEN rnf) { return gel(rnf,11); }
2490 : : INLINE GEN
2491 : 604 : rnf_get_invzk(GEN rnf) { return gel(rnf,8); }
2492 : :
2493 : : /* I integral (not necessarily HNF), G ZM, rounded Cholesky form of a weighted
2494 : : * T2 matrix. Return m in I with T2(m) small */
2495 : : INLINE GEN
2496 : 72383 : idealpseudomin(GEN I, GEN G)
2497 : : {
2498 : 72383 : GEN u = ZM_lll(ZM_mul(G, I), 0.99, LLL_IM);
2499 : 72383 : return ZM_ZC_mul(I, gel(u,1));
2500 : : }
2501 : : /* I, G as in idealpseudomin. Return an irrational m in I with T2(m) small */
2502 : : INLINE GEN
2503 : 153818 : idealpseudomin_nonscalar(GEN I, GEN G)
2504 : : {
2505 : 153818 : GEN u = ZM_lll(ZM_mul(G, I), 0.99, LLL_IM);
2506 : 153818 : GEN m = ZM_ZC_mul(I, gel(u,1));
2507 [ + + ][ + - ]: 153818 : if (ZV_isscalar(m) && lg(u) > 2) m = ZM_ZC_mul(I, gel(u,2));
2508 : 153818 : return m;
2509 : : }
2510 : :
2511 : : INLINE GEN
2512 : 235 : idealred_elt(GEN nf, GEN I) {
2513 : 235 : pari_sp av = avma;
2514 : 235 : GEN u = idealpseudomin(I, nf_get_roundG(nf));
2515 : 235 : return gerepileupto(av, u);
2516 : : }
2517 : : INLINE GEN
2518 : 71846 : idealred(GEN nf, GEN I) { return idealred0(nf, I, NULL); }
2519 : :
2520 : : /*******************************************************************/
2521 : : /* */
2522 : : /* CLOSURES */
2523 : : /* */
2524 : : /*******************************************************************/
2525 : 65876620 : INLINE long closure_arity(GEN C) { return C[1]; }
2526 : 59645174 : INLINE const char *closure_codestr(GEN C) { return GSTR(gel(C,2))-1; }
2527 : 0 : INLINE GEN closure_get_code(GEN C) { return gel(C,2); }
2528 : 59645174 : INLINE GEN closure_get_oper(GEN C) { return gel(C,3); }
2529 : 59643724 : INLINE GEN closure_get_data(GEN C) { return gel(C,4); }
2530 : 1546 : INLINE GEN closure_get_dbg(GEN C) { return gel(C,5); }
2531 : 3424 : INLINE GEN closure_get_text(GEN C) { return gel(C,6); }
2532 : 584 : INLINE GEN closure_get_frame(GEN C) { return gel(C,7); }
2533 : :
2534 : : /*******************************************************************/
2535 : : /* */
2536 : : /* ERRORS */
2537 : : /* */
2538 : : /*******************************************************************/
2539 : : INLINE long
2540 : 11137 : err_get_num(GEN e) { return e[1]; }
2541 : : INLINE GEN
2542 : 44 : err_get_compo(GEN e, long i) { return gel(e, i+1); }
2543 : :
2544 : : INLINE void
2545 : 0 : pari_err_BUG(const char *f) { pari_err(e_BUG,f); }
2546 : : INLINE void
2547 : 4 : pari_err_CONSTPOL(const char *f) { pari_err(e_CONSTPOL, f); }
2548 : : INLINE void
2549 : 24 : pari_err_COPRIME(const char *f, GEN x, GEN y) { pari_err(e_COPRIME, f,x,y); }
2550 : : INLINE void
2551 : 96 : pari_err_DIM(const char *f) { pari_err(e_DIM, f); }
2552 : : INLINE void
2553 : 0 : pari_err_FILE(const char *f, const char *g) { pari_err(e_FILE, f,g); }
2554 : : INLINE void
2555 : 4 : pari_err_FLAG(const char *f) { pari_err(e_FLAG,f); }
2556 : : INLINE void
2557 : 64 : pari_err_IMPL(const char *f) { pari_err(e_IMPL,f); }
2558 : : INLINE void
2559 : 372 : pari_err_INV(const char *f, GEN x) { pari_err(e_INV,f,x); }
2560 : : INLINE void
2561 : 8 : pari_err_IRREDPOL(const char *f, GEN x) { pari_err(e_IRREDPOL, f,x); }
2562 : : INLINE void
2563 : 648 : pari_err_DOMAIN(const char *f, const char *v, const char *op, GEN l, GEN x) { pari_err(e_DOMAIN, f,v,op,l,x); }
2564 : : INLINE void
2565 : 116 : pari_err_COMPONENT(const char *f, const char *op, GEN l, GEN x) { pari_err(e_COMPONENT, f,op,l,x); }
2566 : : INLINE void
2567 : 0 : pari_err_MAXPRIME(ulong c) { pari_err(e_MAXPRIME, c); }
2568 : : INLINE void
2569 : 176 : pari_err_OP(const char *f, GEN x, GEN y) { pari_err(e_OP, f,x,y); }
2570 : : INLINE void
2571 : 26 : pari_err_OVERFLOW(const char *f) { pari_err(e_OVERFLOW, f); }
2572 : : INLINE void
2573 : 129 : pari_err_PREC(const char *f) { pari_err(e_PREC,f); }
2574 : : INLINE void
2575 : 0 : pari_err_PACKAGE(const char *f) { pari_err(e_PACKAGE,f); }
2576 : : INLINE void
2577 : 20 : pari_err_PRIME(const char *f, GEN x) { pari_err(e_PRIME, f,x); }
2578 : : INLINE void
2579 : 404 : pari_err_MODULUS(const char *f, GEN x, GEN y) { pari_err(e_MODULUS, f,x,y); }
2580 : : INLINE void
2581 : 8 : pari_err_ROOTS0(const char *f) { pari_err(e_ROOTS0, f); }
2582 : : INLINE void
2583 : 40 : pari_err_SQRTN(const char *f, GEN x) { pari_err(e_SQRTN, f,x); }
2584 : : INLINE void
2585 : 5680 : pari_err_TYPE(const char *f, GEN x) { pari_err(e_TYPE, f,x); }
2586 : : INLINE void
2587 : 1628 : pari_err_TYPE2(const char *f, GEN x, GEN y) { pari_err(e_TYPE2, f,x,y); }
2588 : : INLINE void
2589 : 280 : pari_err_VAR(const char *f, GEN x, GEN y) { pari_err(e_VAR, f,x,y); }
2590 : : INLINE void
2591 : 16 : pari_err_PRIORITY(const char *f, GEN x, const char *op, long v)
2592 : 16 : { pari_err(e_PRIORITY, f,x,op,v); }
|
