Annotation of OpenXM_contrib/pari-2.2/src/headers/paridecl.h, Revision 1.2
1.2 ! noro 1: /* $Id: paridecl.h,v 1.223 2002/09/10 01:01:23 karim Exp $
1.1 noro 2:
3: Copyright (C) 2000 The PARI group.
4:
5: This file is part of the PARI/GP package.
6:
7: PARI/GP is free software; you can redistribute it and/or modify it under the
8: terms of the GNU General Public License as published by the Free Software
9: Foundation. It is distributed in the hope that it will be useful, but WITHOUT
10: ANY WARRANTY WHATSOEVER.
11:
12: Check the License for details. You should have received a copy of it, along
13: with the package; see the file 'COPYING'. If not, write to the Free Software
14: Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
15:
16: /*******************************************************************/
17: /* */
18: /* DECLARATIONS of PUBLIC FUNCTIONS */
19: /* */
20: /*******************************************************************/
21: BEGINEXTERN
22: /* alglin1.c */
23: GEN FpM_FpV_mul(GEN x, GEN y, GEN p);
1.2 ! noro 24: GEN FpM_deplin(GEN x, GEN p);
1.1 noro 25: GEN FpM_image(GEN x, GEN p);
1.2 ! noro 26: GEN FpM_intersect(GEN x, GEN y, GEN p);
! 27: GEN FpM_inv(GEN x, GEN p);
1.1 noro 28: GEN FpM_invimage(GEN m, GEN v, GEN p);
29: GEN FpM_ker(GEN x, GEN p);
30: GEN FpM_mul(GEN x, GEN y, GEN p);
31: GEN FpM_sindexrank(GEN x, GEN p);
1.2 ! noro 32: GEN FpM_suppl(GEN x, GEN p);
! 33: GEN FqM_gauss(GEN a, GEN b, GEN T, GEN p);
1.1 noro 34: GEN FqM_ker(GEN x, GEN T, GEN p);
1.2 ! noro 35: GEN FqM_suppl(GEN x, GEN T, GEN p);
! 36: GEN Fq_mul(GEN x, GEN y, GEN T, GEN p);
1.1 noro 37: GEN QM_inv(GEN M, GEN dM);
38: GEN ZM_inv(GEN M, GEN dM);
1.2 ! noro 39: GEN _col(GEN x);
! 40: GEN _vec(GEN x);
! 41: GEN _veccopy(GEN x);
! 42: void appendL(GEN x, GEN t);
! 43: GEN cget1(long l, long t);
1.1 noro 44: GEN concat(GEN x, GEN y);
45: GEN concatsp(GEN x, GEN y);
1.2 ! noro 46: GEN concatsp3(GEN x, GEN y, GEN z);
1.1 noro 47: GEN deplin(GEN x);
48: GEN det(GEN a);
49: GEN det0(GEN a,long flag);
50: GEN det2(GEN a);
51: GEN dethnf(GEN x);
52: GEN dethnf_i(GEN mat);
53: GEN detint(GEN x);
54: GEN diagonal(GEN x);
55: GEN eigen(GEN x, long prec);
56: GEN extract(GEN x, GEN l);
57: GEN extract0(GEN x, GEN l1, GEN l2);
58: GEN gaddmat(GEN x, GEN y);
1.2 ! noro 59: GEN gaddmat_i(GEN x, GEN y);
1.1 noro 60: GEN gauss(GEN a, GEN b);
61: GEN gaussmodulo(GEN M, GEN D, GEN Y);
62: GEN gaussmodulo2(GEN M, GEN D, GEN Y);
63: GEN gscalcol(GEN x, long n);
64: GEN gscalcol_i(GEN x, long n);
65: GEN gscalcol_proto(GEN z, GEN myzero, long n);
66: GEN gscalmat(GEN x, long n);
67: GEN gscalsmat(long x, long n);
68: GEN gtomat(GEN x);
1.2 ! noro 69: GEN gtrans(GEN x);
1.1 noro 70: GEN gtrans_i(GEN x);
71: GEN hnfadd(GEN mit,GEN perm,GEN* ptdep,GEN* ptA,GEN* ptC,GEN extramat,GEN extraC);
72: GEN hnfspec(long** mat,GEN perm,GEN* ptdep,GEN* ptA,GEN* ptC,long k0);
73: GEN idmat(long n);
74: GEN idmat_intern(long n,GEN myun,GEN myzero);
75: GEN image(GEN x);
76: GEN image2(GEN x);
77: GEN imagecompl(GEN x);
78: GEN imagereel(GEN x, long prec);
79: GEN indexrank(GEN x);
80: GEN inverseimage(GEN mat, GEN y);
81: long isdiagonal(GEN x);
82: long isscalarmat(GEN x, GEN s);
83: GEN ker(GEN x);
84: GEN keri(GEN x);
85: GEN matextract(GEN x, GEN l1, GEN l2);
86: GEN matimage0(GEN x,long flag);
87: GEN matker0(GEN x, long flag);
88: GEN matmuldiagonal(GEN x, GEN d);
89: GEN matmultodiagonal(GEN x, GEN y);
90: GEN matsolvemod0(GEN M, GEN D, GEN Y,long flag);
91: GEN mattodiagonal(GEN m);
92: GEN mattodiagonal_i(GEN m);
93: long rank(GEN x);
1.2 ! noro 94: GEN row(GEN A, long x1);
! 95: GEN row_i(GEN A, long x0, long x1, long x2);
1.1 noro 96: GEN rowextract_i(GEN A, long x1, long x2);
97: GEN rowextract_p(GEN A, GEN p);
98: GEN sindexrank(GEN x);
1.2 ! noro 99: GEN sum(GEN v, long a, long b);
1.1 noro 100: GEN suppl(GEN x);
1.2 ! noro 101: GEN vconcat(GEN A, GEN B);
1.1 noro 102: GEN vecextract_i(GEN A, long y1, long y2);
103: GEN vecextract_p(GEN A, GEN p);
104: GEN zerocol(long n);
105: GEN zeromat(long m, long n);
106: GEN zerovec(long n);
107:
108: /* alglin2.c */
109:
110: GEN QuickNormL1(GEN x,long prec);
111: GEN QuickNormL2(GEN x,long prec);
112: GEN adj(GEN x);
113: GEN assmat(GEN x);
114: GEN caract(GEN x, int v);
115: GEN caract2(GEN p, GEN x, int v);
116: GEN caradj(GEN x, long v, GEN *py);
117: GEN caradj0(GEN x, long v);
118: GEN carhess(GEN x, long v);
119: GEN charpoly0(GEN x, int v,long flag);
120: GEN conjvec(GEN x,long prec);
121: GEN gconj(GEN x);
122: GEN gnorm(GEN x);
123: GEN gnorml1(GEN x,long prec);
124: GEN gnorml2(GEN x);
125: GEN gtrace(GEN x);
126: GEN hess(GEN x);
127: GEN hnf(GEN x);
128: GEN hnfall(GEN x);
129: GEN hnfhavas(GEN x);
130: GEN hnflll(GEN x);
1.2 ! noro 131: GEN hnflll_i(GEN A, GEN *ptB, int remove);
1.1 noro 132: GEN hnfmod(GEN x, GEN detmat);
133: GEN hnfmodid(GEN x,GEN p);
134: GEN hnfperm(GEN x);
135: GEN intersect(GEN x, GEN y);
136: GEN jacobi(GEN a, long prec);
137: GEN matrixqz(GEN x, GEN pp);
138: GEN matrixqz0(GEN x, GEN pp);
139: GEN matrixqz2(GEN x);
140: GEN matrixqz3(GEN x);
141: GEN signat(GEN a);
142: GEN smith(GEN x);
143: GEN smith2(GEN x);
1.2 ! noro 144: GEN smithall(GEN x, GEN *ptU, GEN *ptV);
1.1 noro 145: GEN smithclean(GEN z);
146: GEN sqred(GEN a);
147: GEN sqred1(GEN a);
148: GEN sqred1intern(GEN a, long flag);
149: GEN sqred3(GEN a);
150:
151: /* anal.c */
152:
153: entree *fetch_named_var(char *s, int doerr);
154: entree *gp_variable(char *s);
155: entree *is_entry(char *s);
156: void delete_named_var(entree *ep);
157: long delete_var(void);
158: long fetch_user_var(char *s);
159: long fetch_var(void);
160: GEN flisexpr(char *t);
161: GEN flisseq(char *t);
162: void freeep(entree *ep);
163: long hashvalue(char *s);
164: entree* install(void *f, char *name, char *code);
165: GEN lisexpr(char *t);
166: GEN lisseq(char *t);
167: long manage_var(long n, entree *ep);
168: void name_var(long n, char *s);
169: GEN readseq(char *c, int strict);
170: GEN strtoGENstr(char *s, long flag);
171:
172: /* arith1.c */
173:
174: GEN bestappr(GEN x, GEN k);
175: GEN bestappr0(GEN x, GEN a, GEN b);
176: long carrecomplet(GEN x, GEN *pt);
177: long cgcd(long a,long b);
178: GEN chinese(GEN x, GEN y);
179: GEN chinois(GEN x, GEN y);
180: GEN classno(GEN x);
181: GEN classno2(GEN x);
182: long clcm(long a,long b);
183: GEN contfrac0(GEN x, GEN b, long flag);
184: GEN fibo(long n);
185: GEN fundunit(GEN x);
186: GEN gboundcf(GEN x, long k);
187: GEN gcarrecomplet(GEN x, GEN *pt);
188: GEN gcarreparfait(GEN x);
189: GEN gcf(GEN x);
190: GEN gcf2(GEN b, GEN x);
191: GEN gener(GEN m);
192: GEN gfundunit(GEN x);
193: GEN ggener(GEN m);
194: GEN gisfundamental(GEN x);
195: GEN gisprime(GEN x, long flag);
1.2 ! noro 196: GEN gispseudoprime(GEN x, long flag);
1.1 noro 197: GEN gispsp(GEN x);
198: GEN gkrogs(GEN x, long y);
199: GEN gkronecker(GEN x, GEN y);
200: GEN gmillerrabin(GEN n, long k);
201: GEN gnextprime(GEN n);
202: GEN gprecprime(GEN n);
203: GEN gracine(GEN a);
204: GEN gregula(GEN x, long prec);
205: GEN hclassno(GEN x);
206: long hil(GEN x, GEN y, GEN p);
207: long hil0(GEN x, GEN y, GEN p);
208: long isfundamental(GEN x);
209: long isprime(GEN x);
1.2 ! noro 210: long isprimeAPRCL(GEN N);
! 211: long isprimeSelfridge(GEN x);
! 212: long ispseudoprime(GEN x, long flag);
1.1 noro 213: long ispsp(GEN x);
214: long krogs(GEN x, long y);
215: long kronecker(GEN x, GEN y);
216: long krosg(long s, GEN x);
217: long kross(long x, long y);
218: void lucas(long n, GEN *ln, GEN *ln1);
219: GEN mpfact(long n);
220: GEN mpfactr(long n, long prec);
221: GEN mpinvmod(GEN a, GEN m);
222: GEN mppgcd(GEN a, GEN b);
223: GEN mpppcm(GEN a, GEN b);
224: GEN mpsqrtmod(GEN a, GEN p);
225: GEN mpsqrtnmod(GEN a, GEN n, GEN p, GEN *zetan);
226: GEN order(GEN x);
227: GEN pnqn(GEN x);
228: GEN powmodulo(GEN a, GEN n, GEN m);
229: GEN qfbclassno0(GEN x,long flag);
230: GEN quaddisc(GEN x);
231: GEN racine(GEN a);
232: GEN regula(GEN x, long prec);
1.2 ! noro 233: ulong u_gener(ulong p);
1.1 noro 234: GEN znstar(GEN x);
235:
236: /* arith2.c */
237:
238: GEN Qfb0(GEN x, GEN y, GEN z, GEN d, long prec);
239: GEN addprimes(GEN primes);
240: GEN auxdecomp(GEN n, long all);
241: long bigomega(GEN n);
242: GEN binaire(GEN x);
243: long bittest(GEN x, long n);
244: GEN boundfact(GEN n, long lim);
245: GEN compimag(GEN x, GEN y);
246: GEN compimagraw(GEN x, GEN y);
247: GEN compraw(GEN x, GEN y);
248: GEN compreal(GEN x, GEN y);
249: GEN comprealraw(GEN x, GEN y);
250: GEN core(GEN n);
1.2 ! noro 251: GEN corepartial(GEN n);
1.1 noro 252: GEN core0(GEN n,long flag);
253: GEN core2(GEN n);
1.2 ! noro 254: GEN core2partial(GEN n);
1.1 noro 255: GEN coredisc(GEN n);
256: GEN coredisc0(GEN n,long flag);
257: GEN coredisc2(GEN n);
258: GEN decomp(GEN n);
1.2 ! noro 259: GEN decomp_primary_small(long n);
! 260: GEN decomp_small(long n);
1.1 noro 261: GEN divisors(GEN n);
262: GEN factorint(GEN n, long flag);
263: GEN gbigomega(GEN n);
264: GEN gbitand(GEN x, GEN y);
265: GEN gbitneg(GEN x, long n);
266: GEN gbitnegimply(GEN x, GEN y);
267: GEN gbitor(GEN x, GEN y);
268: GEN gbittest(GEN x, GEN n);
1.2 ! noro 269: GEN gbittest3(GEN x, GEN n, long c);
1.1 noro 270: GEN gbitxor(GEN x, GEN y);
271: GEN gboundfact(GEN n, long lim);
272: GEN gissquarefree(GEN x);
273: GEN gmu(GEN n);
274: GEN gnumbdiv(GEN n);
275: GEN gomega(GEN n);
276: GEN gphi(GEN n);
277: GEN gsumdiv(GEN n);
278: GEN gsumdivk(GEN n,long k);
1.2 ! noro 279: byteptr initprimes(ulong maxnum);
1.1 noro 280: long issquarefree(GEN x);
281: ulong maxprime(void);
282: long mu(GEN n);
283: GEN nucomp(GEN x, GEN y, GEN l);
284: GEN nudupl(GEN x, GEN l);
285: GEN numbdiv(GEN n);
286: GEN nupow(GEN x, GEN n);
287: long omega(GEN n);
288: GEN phi(GEN n);
289: GEN powraw(GEN x, long n);
290: GEN powrealraw(GEN x, long n);
291: GEN prime(long n);
292: GEN primeform(GEN x, GEN p, long prec);
293: GEN primes(long n);
294: GEN qfbred0(GEN x, long flag, GEN D, GEN isqrtD, GEN sqrtD);
295: GEN qfi(GEN x, GEN y, GEN z);
296: GEN qfr(GEN x, GEN y, GEN z, GEN d);
297: GEN redimag(GEN x);
298: GEN redreal(GEN x);
299: GEN redrealnod(GEN x, GEN isqrtD);
300: GEN removeprimes(GEN primes);
301: GEN rhoreal(GEN x);
302: GEN rhorealnod(GEN x, GEN isqrtD);
303: GEN smallfact(GEN n);
304: GEN sqcompimag(GEN x);
305: GEN sqcompreal(GEN x);
306: GEN sumdiv(GEN n);
307: GEN sumdivk(GEN n,long k);
308:
309: /* base1.c */
310:
311: GEN bnfnewprec(GEN nf, long prec);
312: GEN bnrnewprec(GEN bnr, long prec);
313: void check_pol_int(GEN x, char *s);
314: GEN check_units(GEN x, char *f);
315: void checkbid(GEN bid);
316: GEN checkbnf(GEN bnf);
317: GEN checkbnf_discard(GEN bnf);
318: void checkbnr(GEN bnr);
319: void checkbnrgen(GEN bnr);
320: void checkid(GEN x, long N);
321: GEN checknf(GEN nf);
322: GEN checknfelt_mod(GEN nf, GEN x, char *s);
323: void checkprimeid(GEN bid);
324: void checkrnf(GEN rnf);
325: GEN galois(GEN x, long prec);
326: GEN galoisapply(GEN nf, GEN aut, GEN x);
327: GEN get_bnf(GEN x,int *t);
1.2 ! noro 328: GEN get_bnfpol(GEN x, GEN *bnf, GEN *nf);
1.1 noro 329: GEN get_nf(GEN x,int *t);
1.2 ! noro 330: GEN get_nfpol(GEN x, GEN *nf);
1.1 noro 331: GEN get_primeid(GEN x);
332: GEN glambdak(GEN nfz, GEN s, long prec);
333: int gpolcomp(GEN p1, GEN p2);
334: GEN gsmith(GEN x);
335: GEN gsmith2(GEN x);
336: GEN gzetak(GEN nfz, GEN s, long prec);
337: GEN gzetakall(GEN nfz, GEN s, long flag, long prec);
338: GEN initalg(GEN x, long prec);
339: GEN initalgred(GEN x, long prec);
340: GEN initalgred2(GEN x, long prec);
341: GEN initzeta(GEN pol, long prec);
342: GEN mathnf0(GEN x,long flag);
343: GEN matsnf0(GEN x,long flag);
344: long nf_get_r1(GEN nf);
345: long nf_get_r2(GEN nf);
1.2 ! noro 346: void nf_get_sign(GEN nf, long *r1, long *r2);
! 347: long nfgetprec(GEN x);
1.1 noro 348: GEN nfinit0(GEN x,long flag, long prec);
349: GEN nfnewprec(GEN nf, long prec);
350: GEN rootsof1(GEN x);
351: GEN tschirnhaus(GEN x);
352:
353: /* base2.c */
354:
1.2 ! noro 355: GEN allbase(GEN f, int flag, GEN *dx, GEN *dK, GEN *index, GEN *ptw);
1.1 noro 356: GEN base(GEN x, GEN *y);
357: GEN base2(GEN x, GEN *y);
1.2 ! noro 358: void checkmodpr(GEN modpr);
1.1 noro 359: GEN compositum(GEN pol1, GEN pol2);
360: GEN compositum2(GEN pol1, GEN pol2);
361: GEN discf(GEN x);
362: GEN discf2(GEN x);
363: GEN factoredbase(GEN x, GEN p, GEN *y);
364: GEN factoreddiscf(GEN x, GEN p);
1.2 ! noro 365: GEN ff_to_nf(GEN x, GEN modpr);
1.1 noro 366: GEN fix_relative_pol(GEN nf, GEN x, int chk_lead);
367: GEN gcdpm(GEN f1,GEN f2,GEN pm);
368: long idealval(GEN nf,GEN ix,GEN vp);
1.2 ! noro 369: GEN idealprodprime(GEN nf, GEN L);
! 370: GEN modprX(GEN x, GEN nf,GEN modpr);
! 371: GEN modprX_lift(GEN x, GEN modpr);
! 372: GEN modprM(GEN z, GEN nf,GEN modpr);
! 373: GEN modprM_lift(GEN z, GEN modpr);
! 374: GEN nf_to_ff_init(GEN nf, GEN *pr, GEN *T, GEN *p);
! 375: GEN nf_to_ff(GEN nf, GEN x, GEN modpr);
1.1 noro 376: GEN nfbasis(GEN x, GEN *y,long flag,GEN p);
377: GEN nfbasis0(GEN x,long flag,GEN p);
378: GEN nfdiscf0(GEN x,long flag, GEN p);
379: GEN nfreducemodideal(GEN nf,GEN x,GEN ideal);
1.2 ! noro 380: GEN nfreducemodpr(GEN nf, GEN x, GEN modpr);
1.1 noro 381: GEN polcompositum0(GEN pol1, GEN pol2,long flag);
382: GEN primedec(GEN nf,GEN p);
383: GEN rnfbasis(GEN bnf, GEN order);
384: GEN rnfdet(GEN nf, GEN order);
385: GEN rnfdet0(GEN nf, GEN x, GEN y);
386: GEN rnfdet2(GEN nf, GEN A, GEN I);
387: GEN rnfdiscf(GEN nf, GEN pol);
388: GEN rnfequation(GEN nf, GEN pol2);
389: GEN rnfequation0(GEN nf, GEN pol2, long flall);
390: GEN rnfequation2(GEN nf, GEN pol);
391: GEN rnfhermitebasis(GEN bnf, GEN order);
392: long rnfisfree(GEN bnf, GEN order);
393: GEN rnflllgram(GEN nf, GEN pol, GEN order,long prec);
394: GEN rnfpolred(GEN nf, GEN pol, long prec);
1.2 ! noro 395: GEN rnfpolredabs(GEN nf, GEN pol, long flag);
1.1 noro 396: GEN rnfpseudobasis(GEN nf, GEN pol);
397: GEN rnfsimplifybasis(GEN bnf, GEN order);
398: GEN rnfsteinitz(GEN nf, GEN order);
399: GEN smallbase(GEN x, GEN *y);
400: GEN smalldiscf(GEN x);
1.2 ! noro 401: GEN zk_to_ff_init(GEN nf, GEN *pr, GEN *T, GEN *p);
! 402: GEN zk_to_ff(GEN x, GEN modpr);
! 403: GEN zkmodprinit(GEN nf, GEN pr);
1.1 noro 404:
405: /* base3.c */
406:
407: GEN algtobasis(GEN nf, GEN x);
1.2 ! noro 408: GEN algtobasis_i(GEN nf,GEN x);
1.1 noro 409: GEN basistoalg(GEN nf, GEN x);
410: GEN element_div(GEN nf, GEN x, GEN y);
411: GEN element_inv(GEN nf, GEN x);
412: GEN element_invmodideal(GEN nf, GEN x, GEN ideal);
413: GEN element_mul(GEN nf,GEN x,GEN y);
1.2 ! noro 414: GEN element_muli(GEN nf,GEN x,GEN y);
1.1 noro 415: GEN element_mulid(GEN nf, GEN x, long i);
416: GEN element_mulvec(GEN nf, GEN x, GEN v);
417: GEN element_pow(GEN nf,GEN x,GEN k);
418: GEN element_pow_mod_p(GEN nf, GEN x, GEN n, GEN p);
419: GEN element_powmodideal(GEN nf,GEN x,GEN k,GEN ideal);
420: GEN element_powmodidele(GEN nf,GEN x,GEN k,GEN idele,GEN structarch);
421: GEN element_sqr(GEN nf,GEN x);
1.2 ! noro 422: GEN element_sqri(GEN nf, GEN x);
1.1 noro 423: long element_val(GEN nf, GEN x, GEN vp);
1.2 ! noro 424: GEN eltmul_get_table(GEN nf, GEN x);
1.1 noro 425: GEN ideallist(GEN nf,long bound);
426: GEN ideallist0(GEN nf,long bound, long flag);
427: GEN ideallistarch(GEN nf, GEN list, GEN arch);
428: GEN ideallistarch0(GEN nf, GEN list, GEN arch,long flag);
429: GEN ideallistarchgen(GEN nf, GEN list, GEN arch);
430: GEN ideallistunit(GEN nf,long bound);
431: GEN ideallistunitarch(GEN bnf,GEN list,GEN arch);
432: GEN ideallistunitarchgen(GEN bnf,GEN list,GEN arch);
433: GEN ideallistunitgen(GEN nf,long bound);
434: GEN ideallistzstar(GEN nf,long bound);
435: GEN ideallistzstargen(GEN nf,long bound);
436: GEN idealstar0(GEN nf, GEN x,long flag);
437: int isnfscalar(GEN x);
438: GEN lllreducemodmatrix(GEN x,GEN y);
439: GEN nfdiveuc(GEN nf, GEN a, GEN b);
440: GEN nfdivres(GEN nf, GEN a, GEN b);
441: GEN nfmod(GEN nf, GEN a, GEN b);
442: GEN nfreducemodidele(GEN nf,GEN g,GEN idele,GEN structarch);
443: GEN reducemodinvertible(GEN x, GEN y);
444: GEN reducemodmatrix(GEN x, GEN y);
445: GEN reducemodHNF(GEN x, GEN y, GEN *Q);
1.2 ! noro 446: GEN set_sign_mod_idele(GEN nf, GEN x, GEN y, GEN idele, GEN sarch);
! 447: GEN smithrel(GEN H, GEN *newU, GEN *newUi);
1.1 noro 448: GEN zarchstar(GEN nf,GEN x,GEN arch,long nba);
449: GEN zideallog(GEN nf,GEN x,GEN bigideal);
450: GEN zidealstar(GEN nf, GEN x);
451: GEN zidealstarinit(GEN nf, GEN x);
452: GEN zidealstarinitall(GEN nf, GEN x,long flun);
453: GEN zidealstarinitgen(GEN nf, GEN x);
454: GEN zidealstarinitjoin(GEN nf, GEN bid1, GEN bid2, long flag);
455: GEN zidealstarinitjoinarch(GEN nf, GEN bid1, GEN arch, long nba, long flag);
456: GEN znlog(GEN x, GEN g);
457: GEN zsigne(GEN nf,GEN alpha,GEN arch);
1.2 ! noro 458: GEN zsigns(GEN nf,GEN alpha);
1.1 noro 459:
460: /* base4.c */
461:
1.2 ! noro 462: GEN element_divmodpr(GEN nf, GEN x, GEN y, GEN modpr);
! 463: GEN element_invmodpr(GEN nf, GEN y, GEN modpr);
! 464: GEN element_mulmodpr(GEN nf, GEN x, GEN y, GEN modpr);
! 465: GEN element_powmodpr(GEN nf, GEN x, GEN k, GEN modpr);
1.1 noro 466: GEN element_reduce(GEN nf, GEN x, GEN ideal);
467: GEN ideal_two_elt(GEN nf, GEN ix);
468: GEN ideal_two_elt0(GEN nf, GEN ix, GEN a);
469: GEN ideal_two_elt2(GEN nf, GEN x, GEN a);
470: GEN idealadd(GEN nf, GEN x, GEN y);
471: GEN idealaddmultoone(GEN nf, GEN list);
472: GEN idealaddtoone(GEN nf, GEN x, GEN y);
473: GEN idealaddtoone0(GEN nf, GEN x, GEN y);
474: GEN idealappr(GEN nf, GEN x);
475: GEN idealappr0(GEN nf, GEN x, long fl);
476: GEN idealapprfact(GEN nf, GEN x);
477: GEN idealchinese(GEN nf, GEN x, GEN y);
478: GEN idealcoprime(GEN nf, GEN x, GEN y);
479: GEN idealdiv(GEN nf, GEN x, GEN y);
480: GEN idealdiv0(GEN nf, GEN x, GEN y,long flag);
481: GEN idealdivexact(GEN nf, GEN x, GEN y);
1.2 ! noro 482: GEN idealdivpowprime(GEN nf, GEN x, GEN vp, GEN n);
! 483: GEN idealmulpowprime(GEN nf, GEN x, GEN vp, GEN n);
1.1 noro 484: GEN idealfactor(GEN nf, GEN x);
485: GEN idealhermite(GEN nf, GEN x);
486: GEN idealhermite2(GEN nf, GEN a, GEN b);
487: GEN idealhnf0(GEN nf, GEN a, GEN b);
488: GEN idealintersect(GEN nf, GEN x, GEN y);
489: GEN idealinv(GEN nf, GEN ix);
490: GEN ideallllred(GEN nf,GEN ix,GEN vdir,long prec);
1.2 ! noro 491: GEN idealred_elt(GEN nf, GEN I);
! 492: GEN ideallllred_elt(GEN nf, GEN I, GEN vdir);
1.1 noro 493: GEN idealmul(GEN nf, GEN ix, GEN iy);
494: GEN idealmul0(GEN nf, GEN ix, GEN iy, long flag, long prec);
495: GEN idealmulh(GEN nf, GEN ix, GEN iy);
496: GEN idealmulprime(GEN nf,GEN ix,GEN vp);
497: GEN idealmulred(GEN nf, GEN ix, GEN iy, long prec);
498: GEN idealnorm(GEN nf, GEN x);
499: GEN idealoplll(GEN op(GEN,GEN,GEN), GEN nf, GEN x, GEN y);
500: GEN idealpow(GEN nf, GEN ix, GEN n);
501: GEN idealpow0(GEN nf, GEN ix, GEN n, long flag, long prec);
502: GEN idealpowred(GEN nf, GEN ix, GEN n,long prec);
503: GEN idealpows(GEN nf, GEN ideal, long iexp);
504: GEN ideleaddone(GEN nf, GEN x, GEN idele);
505: int ishnfall(GEN x);
1.2 ! noro 506: GEN hnfall_i(GEN A, GEN *ptB, long remove);
1.1 noro 507: long isideal(GEN nf,GEN x);
508: long isinvector(GEN v, GEN x, long n);
509: GEN minideal(GEN nf,GEN ix,GEN vdir,long prec);
510: GEN nfdetint(GEN nf,GEN pseudo);
511: GEN nfhermite(GEN nf, GEN x);
512: GEN nfhermitemod(GEN nf, GEN x, GEN detmat);
1.2 ! noro 513: GEN nfkermodpr(GEN nf, GEN x, GEN modpr);
1.1 noro 514: GEN nfmodprinit(GEN nf, GEN pr);
515: GEN nfsmith(GEN nf, GEN x);
1.2 ! noro 516: GEN nfsolvemodpr(GEN nf, GEN a, GEN b, GEN modpr);
1.1 noro 517: GEN oldidealinv(GEN nf, GEN ix);
518: GEN prime_to_ideal(GEN nf, GEN vp);
519: GEN principalideal(GEN nf, GEN a);
520: GEN principalidele(GEN nf, GEN a, long prec);
1.2 ! noro 521: GEN vecdiv(GEN x, GEN y);
! 522: GEN vecinv(GEN x);
! 523: GEN vecmul(GEN x, GEN y);
! 524: GEN vecpow(GEN x, GEN n);
1.1 noro 525:
526: /* base5.c */
527:
528: GEN lift_to_pol(GEN x);
529: GEN matalgtobasis(GEN nf, GEN x);
530: GEN matbasistoalg(GEN nf, GEN x);
531: GEN rnfalgtobasis(GEN rnf, GEN x);
532: GEN rnfbasistoalg(GEN rnf, GEN x);
533: GEN rnfelementabstorel(GEN rnf, GEN x);
534: GEN rnfelementdown(GEN rnf, GEN x);
535: GEN rnfelementreltoabs(GEN rnf, GEN x);
536: GEN rnfelementup(GEN rnf, GEN x);
537: GEN rnfidealabstorel(GEN rnf, GEN x);
538: GEN rnfidealdown(GEN rnf, GEN x);
539: GEN rnfidealhermite(GEN rnf, GEN x);
540: GEN rnfidealmul(GEN rnf,GEN x,GEN y);
541: GEN rnfidealnormabs(GEN rnf, GEN x);
542: GEN rnfidealnormrel(GEN rnf, GEN x);
543: GEN rnfidealreltoabs(GEN rnf, GEN x);
544: GEN rnfidealtwoelement(GEN rnf,GEN x);
545: GEN rnfidealup(GEN rnf, GEN x);
546: GEN rnfinitalg(GEN nf,GEN pol,long prec);
547:
548: /* bibli1.c */
549:
1.2 ! noro 550: GEN T2_from_embed(GEN x, long r1);
1.1 noro 551: GEN algdep(GEN x, long n, long prec);
552: GEN algdep0(GEN x, long n, long bit,long prec);
553: GEN algdep2(GEN x, long n, long bit);
1.2 ! noro 554: GEN factoredpolred(GEN x, GEN p);
! 555: GEN factoredpolred2(GEN x, GEN p);
1.1 noro 556: GEN kerint(GEN x);
557: GEN kerint1(GEN x);
558: GEN lindep(GEN x, long prec);
559: GEN lindep0(GEN x, long flag,long prec);
560: GEN lindep2(GEN x, long bit);
561: GEN lll(GEN x, long prec);
562: GEN lllgen(GEN x);
563: GEN lllgram(GEN x, long prec);
564: GEN lllgramall(GEN x, long alpha, long flag);
565: GEN lllgramgen(GEN x);
566: GEN lllgramint(GEN x);
567: GEN lllgramintern(GEN x, long alpha, long flag, long prec);
568: GEN lllgramkerim(GEN x);
569: GEN lllgramkerimgen(GEN x);
570: GEN lllint(GEN x);
1.2 ! noro 571: GEN lllint_i(GEN x, long alpha, int gram, GEN *h, GEN *ptfl, GEN *ptB);
! 572: GEN lllint_ip(GEN x, long alpha);
! 573: GEN lllintern(GEN x, long D, long flag, long prec);
1.1 noro 574: GEN lllintpartial(GEN mat);
575: GEN lllkerim(GEN x);
576: GEN lllkerimgen(GEN x);
577: GEN matkerint0(GEN x,long flag);
578: GEN minim(GEN a, GEN borne, GEN stockmax);
1.2 ! noro 579: GEN nf_get_LLL(GEN nf);
1.1 noro 580: GEN qfminim0(GEN a, GEN borne, GEN stockmax,long flag, long prec);
581: GEN minim2(GEN a, GEN borne, GEN stockmax);
1.2 ! noro 582: GEN ordred(GEN x);
1.1 noro 583: GEN perf(GEN a);
1.2 ! noro 584: GEN polred(GEN x);
! 585: GEN polred0(GEN x, long flag, GEN p);
! 586: GEN polred2(GEN x);
! 587: GEN polredabs(GEN x);
! 588: GEN polredabs0(GEN x, long flag);
! 589: GEN polredabs2(GEN x);
! 590: GEN polredabsall(GEN x, long flun);
1.1 noro 591: GEN qflll0(GEN x, long flag, long prec);
592: GEN qflllgram0(GEN x, long flag, long prec);
1.2 ! noro 593: GEN smallpolred(GEN x);
! 594: GEN smallpolred2(GEN x);
1.1 noro 595:
596: /* bibli2.c */
597:
1.2 ! noro 598: GEN RXQ_powers(GEN a, GEN T, long l);
! 599: GEN RX_RXQ_compo(GEN f, GEN x, GEN T);
1.1 noro 600: GEN binome(GEN x, long k);
601: int cmp_pol(GEN x, GEN y);
602: int cmp_prime_ideal(GEN x, GEN y);
603: int cmp_prime_over_p(GEN x, GEN y);
604: int cmp_vecint(GEN x, GEN y);
605: GEN convol(GEN x, GEN y);
606: GEN cyclo(long n, long v);
607: GEN dirdiv(GEN x, GEN y);
608: GEN dirmul(GEN x, GEN y);
609: GEN dirzetak(GEN nf, GEN b);
1.2 ! noro 610: long gen_search(GEN x, GEN y, int flag, int (*cmp)(GEN,GEN));
! 611: GEN gen_setminus(GEN set1, GEN set2, int (*cmp)(GEN,GEN));
1.1 noro 612: GEN gen_sort(GEN x, int flag, int (*cmp)(GEN,GEN));
613: GEN genrand(GEN N);
614: GEN getheap(void);
615: long getrand(void);
616: long getstack(void);
617: long gettime(void);
618: GEN gprec(GEN x, long l);
619: GEN gprec_w(GEN x, long pr);
620: GEN grando0(GEN x, long n, long do_clone);
621: GEN gtoset(GEN x);
622: GEN indexlexsort(GEN x);
623: GEN indexsort(GEN x);
624: GEN laplace(GEN x);
625: GEN legendre(long n, long v);
626: GEN lexsort(GEN x);
627: GEN mathilbert(long n);
628: GEN matqpascal(long n, GEN q);
1.2 ! noro 629: GEN modreverse_i(GEN a, GEN T);
1.1 noro 630: long mymyrand(void);
631: GEN numtoperm(long n, GEN x);
632: int pari_compare_int(int *a,int *b);
633: int pari_compare_long(long *a,long *b);
634: GEN permtonum(GEN x);
635: GEN polint(GEN xa, GEN ya, GEN x, GEN *dy);
636: GEN polrecip(GEN x);
637: GEN polymodrecip(GEN x);
1.2 ! noro 638: GEN roots_to_pol(GEN a, long v);
1.1 noro 639: GEN setintersect(GEN x, GEN y);
640: long setisset(GEN x);
641: GEN setminus(GEN x, GEN y);
642: long setrand(long seed);
643: long setsearch(GEN x, GEN y, long flag);
644: GEN setunion(GEN x, GEN y);
645: GEN sindexlexsort(GEN x);
646: GEN sindexsort(GEN x);
647: GEN sort(GEN x);
648: long tablesearch(GEN T, GEN x, int (*cmp)(GEN,GEN));
649: GEN tayl(GEN x, long v, long precdl);
650: GEN tchebi(long n, long v);
1.2 ! noro 651: GEN vecbinome(long n);
1.1 noro 652: GEN vecsort(GEN x, GEN k);
653: GEN vecsort0(GEN x, GEN k, long flag);
654:
655: /* buch1.c */
656:
657: GEN buchimag(GEN D, GEN gcbach, GEN gcbach2, GEN gCO);
658: GEN buchreal(GEN D, GEN gsens, GEN gcbach, GEN gcbach2, GEN gRELSUP, long prec);
659: GEN quadclassunit0(GEN x, long flag,GEN data, long prec);
660: GEN quadhilbert(GEN D, GEN flag, long prec);
661: GEN quadray(GEN bnf, GEN f, GEN flag, long prec);
662:
663:
664: /* buch2.c */
665:
666: GEN bnfclassunit0(GEN P,long flag,GEN data,long prec);
667: GEN bnfinit0(GEN P,long flag,GEN data,long prec);
1.2 ! noro 668: GEN bnfmake(GEN sbnf,long prec);
1.1 noro 669: GEN buchall(GEN P, GEN gcbach, GEN gcbach2, GEN gRELSUP, GEN gborne, long nbrelpid, long minsfb, long flun, long prec);
670: GEN buchfu(GEN bignf);
671: GEN classgrouponly(GEN P,GEN data,long prec);
672: GEN isprincipal(GEN bignf, GEN x);
673: GEN isprincipalall(GEN bignf, GEN x,long flall);
1.2 ! noro 674: GEN isprincipalfact(GEN bnf,GEN P, GEN e, GEN C, long flag);
1.1 noro 675: GEN isprincipalforce(GEN bignf,GEN x);
676: GEN isprincipalgen(GEN bignf, GEN x);
677: GEN isprincipalgenforce(GEN bignf,GEN x);
678: GEN isunit(GEN bignf, GEN x);
1.2 ! noro 679: GEN quick_isprincipalgen(GEN bnf, GEN x);
1.1 noro 680: GEN regulator(GEN P,GEN data,long prec);
681: GEN signunits(GEN bignf);
682: GEN smallbuchinit(GEN pol,GEN gcbach,GEN gcbach2,GEN gRELSUP,GEN gborne,long nbrelpid,long minsfb,long prec);
683:
684: /* buch3.c */
685:
686: GEN bnrclass0(GEN bignf, GEN ideal, long flag);
687: GEN bnrconductor(GEN arg0,GEN arg1,GEN arg2,long all);
688: GEN bnrconductorofchar(GEN bnr,GEN chi);
689: GEN bnrdisc0(GEN arg0, GEN arg1, GEN arg2, long flag);
690: GEN bnrdisclist0(GEN bnf,GEN borne, GEN arch, long all);
691: GEN bnrinit0(GEN bignf,GEN ideal,long flag);
692: long bnrisconductor(GEN arg0,GEN arg1,GEN arg2);
693: GEN buchnarrow(GEN bignf);
694: GEN buchray(GEN bignf,GEN ideal);
695: GEN buchrayinit(GEN bignf,GEN ideal);
696: GEN buchrayinitgen(GEN bignf,GEN ideal);
697: long certifybuchall(GEN bnf);
698: GEN conductor(GEN bnr,GEN subgroup,long all);
699: GEN decodemodule(GEN nf, GEN fa);
700: GEN discrayabs(GEN bnr,GEN subgroup);
701: GEN discrayabscond(GEN bnr,GEN subgroup);
702: GEN discrayabslist(GEN bnf,GEN listes);
703: GEN discrayabslistarch(GEN bnf, GEN arch, long bound);
704: GEN discrayabslistlong(GEN bnf, long bound);
705: GEN discrayrel(GEN bnr,GEN subgroup);
706: GEN discrayrelcond(GEN bnr,GEN subgroup);
1.2 ! noro 707: GEN idealmodidele(GEN bnr, GEN x);
1.1 noro 708: GEN isprincipalray(GEN bignf, GEN x);
709: GEN isprincipalrayall(GEN bignf, GEN x,long flall);
710: GEN isprincipalraygen(GEN bignf, GEN x);
711: GEN rayclassno(GEN bignf,GEN ideal);
712: GEN rayclassnolist(GEN bnf,GEN listes);
713: GEN rnfconductor(GEN bnf, GEN polrel, long flag);
714: GEN rnfkummer(GEN bnr, GEN subgroup, long all, long prec);
715: GEN rnfnormgroup(GEN bnr, GEN polrel);
1.2 ! noro 716: GEN subgrouplist0(GEN bnr, GEN indexbound, long all);
1.1 noro 717:
718: /* buch4.c */
719:
720: GEN bnfisnorm(GEN bnf,GEN x,long flag,long PREC);
1.2 ! noro 721: GEN rnfisnorm(GEN S, GEN x, long flag);
! 722: GEN rnfisnorminit(GEN bnf, GEN relpol, int galois);
1.1 noro 723: GEN bnfissunit(GEN bnf,GEN suni,GEN x);
724: GEN bnfsunit(GEN bnf,GEN s,long PREC);
725: long nfhilbert(GEN bnf,GEN a,GEN b);
726: long nfhilbert0(GEN bnf,GEN a,GEN b,GEN p);
727: long nfhilbertp(GEN bnf,GEN a,GEN b,GEN p);
728: long qpsoluble(GEN pol,GEN p);
729: long qpsolublenf(GEN bnf,GEN pol,GEN p);
730: long zpsoluble(GEN pol,GEN p);
731: long zpsolublenf(GEN bnf,GEN pol,GEN p);
732:
733: /* elliptic.c */
734:
735: GEN addell(GEN e, GEN z1, GEN z2);
736: GEN akell(GEN e, GEN n);
737: GEN anell(GEN e, long n);
738: GEN apell(GEN e, GEN p);
739: GEN apell2(GEN e, GEN p);
740: GEN bilhell(GEN e, GEN z1, GEN z2, long prec);
741: GEN coordch(GEN e, GEN ch);
742: GEN ellap0(GEN e, GEN p, long flag);
743: GEN elleisnum(GEN om, long k, long flag, long prec);
744: GEN elleta(GEN om, long prec);
745: GEN ellheight0(GEN e, GEN a, long flag,long prec);
746: GEN ellinit0(GEN x,long flag,long prec);
1.2 ! noro 747: GEN ellminimalmodel(GEN E, GEN *ptv);
1.1 noro 748: long ellrootno(GEN e, GEN p);
749: GEN ellsigma(GEN om, GEN z, long flag, long prec);
750: GEN elltors0(GEN e, long flag);
751: GEN ellwp0(GEN e, GEN z, long flag, long prec, long PREC);
752: GEN ellzeta(GEN om, GEN z, long prec);
753: GEN ghell(GEN e, GEN a, long prec);
754: GEN ghell2(GEN e, GEN a, long prec);
755: GEN globalreduction(GEN e1);
756: GEN initell(GEN x, long prec);
757: GEN localreduction(GEN e, GEN p1);
758: GEN lseriesell(GEN e, GEN s, GEN A, long prec);
759: GEN mathell(GEN e, GEN x, long prec);
760: int oncurve(GEN e, GEN z);
761: GEN ordell(GEN e, GEN x, long prec);
762: GEN orderell(GEN e, GEN p);
763: GEN pointch(GEN x, GEN ch);
764: GEN pointell(GEN e, GEN z, long prec);
765: GEN powell(GEN e, GEN z, GEN n);
766: GEN smallinitell(GEN x);
767: GEN subell(GEN e, GEN z1, GEN z2);
768: GEN taniyama(GEN e);
769: GEN torsell(GEN e);
770: GEN weipell(GEN e, long precdl);
771: GEN zell(GEN e, GEN z, long prec);
772:
773: /* es.c */
774:
775: char* GENtostr(GEN x);
776: void brute(GEN g, char format, long dec);
777: void bruteall(GEN g, char format, long dec, long flbl);
778: void bruterr(GEN x,char format,long dec);
779: const char* eng_ord(long i);
780: void etatpile(unsigned int n);
781: char* expand_tilde(char *s);
782: int file_is_binary(FILE *f);
783: void flusherr(void);
784: void fprintferr(char* pat, ...);
785: void killallfiles(int check);
786: int killfile(pariFILE *f);
787: GEN lisGEN(FILE *f);
788: void matbrute(GEN g, char format, long dec);
789: pariFILE* newfile(FILE *f, char *name, int type);
790: void os_close(long fd);
791: char* os_getenv(char *s);
792: long os_open(char *s, int mode);
793: void os_read(long fd, char ch[], long s);
794: void (*os_signal(int sig, void (*f)(int)))(int);
795: void outbeaut(GEN x);
796: void outbeauterr(GEN x);
797: void outbrute(GEN x);
798: void outerr(GEN x);
799: void outmat(GEN x);
800: void output(GEN x);
801: void outsor(GEN x);
802: void outtex(GEN x);
803: void pari_fclose(pariFILE *f);
804: pariFILE* pari_fopen(char *s, char *mode);
805: pariFILE* pari_safefopen(char *s, char *mode);
806: char* pari_strdup(char *s);
807: char* pari_unique_filename(char *s);
808: void pari_unlink(char *s);
809: void pariflush(void);
810: void pariputc(char c);
811: void pariputs(char *s);
812: void pariputsf(char *format, ...);
813: int popinfile(void);
814: GEN readbin(char *name, FILE *f);
815: void sor(GEN g, char fo, long dd, long chmp);
816: void switchin(char *name);
817: void switchout(char *name);
818: void texe(GEN g, char format, long dec);
819: pariFILE* try_pipe(char *cmd, int flag);
820: char* type_name(long t);
821: void voir(GEN x, long nb);
822: void vpariputs(char* format, va_list args);
823: void writebin(char *name, GEN x);
824:
825: /* galconj.c */
826:
1.2 ! noro 827: GEN checkgal(GEN gal);
1.1 noro 828: GEN galoisconj(GEN nf);
829: GEN galoisconj0(GEN nf, long flag, GEN d, long prec);
830: GEN galoisconj2(GEN x, long nbmax, long prec);
831: GEN galoisconj4(GEN T, GEN den, long flag, long karma);
832: GEN galoisfixedfield(GEN gal, GEN v, long flag, long y);
833: GEN galoisinit(GEN nf, GEN den, long karma);
1.2 ! noro 834: GEN galoisisabelian(GEN gal, long flag);
1.1 noro 835: GEN galoispermtopol(GEN gal, GEN perm);
1.2 ! noro 836: GEN galoissubgroups(GEN G);
! 837: GEN galoissubfields(GEN G, long flag, long v);
1.1 noro 838: long numberofconjugates(GEN T, long pdepart);
839: GEN vandermondeinverse(GEN L, GEN T, GEN den, GEN prep);
840: /* gen1.c */
841:
842: GEN gadd(GEN x, GEN y);
843: GEN gdiv(GEN x, GEN y);
844: GEN gmul(GEN x, GEN y);
845: GEN gred(GEN x);
846: GEN gred_rfrac(GEN x);
847: GEN gsqr(GEN x);
848: GEN gsub(GEN x, GEN y);
849:
850: /* gen2.c */
851: void gop1z(GEN (*f)(GEN), GEN x, GEN y);
852: void gop2z(GEN (*f)(GEN, GEN), GEN x, GEN y, GEN z);
853: GEN gopgs2(GEN (*f)(GEN, GEN), GEN y, long s);
854: void gops2gsz(GEN (*f)(GEN, long), GEN x, long s, GEN z);
855: void gops2sgz(GEN (*f)(long, GEN), long s, GEN y, GEN z);
856: void gops2ssz(GEN (*f)(long, long), long s, long y, GEN z);
857: GEN gopsg2(GEN (*f)(GEN, GEN), long s, GEN y);
858: void gopsg2z(GEN (*f)(GEN, GEN), long s, GEN y, GEN z);
859: long opgs2(int (*f)(GEN, GEN), GEN y, long s);
860:
861: GEN cgetp(GEN x);
862: GEN co8(GEN x, long l);
863: GEN cvtop(GEN x, GEN p, long l);
864: GEN from_Kronecker(GEN z, GEN pol);
865: GEN gabs(GEN x, long prec);
866: void gaffect(GEN x, GEN y);
867: void gaffsg(long s, GEN x);
868: GEN gclone(GEN x);
869: int gcmp(GEN x, GEN y);
870: int gcmp0(GEN x);
871: int gcmp1(GEN x);
872: int gcmp_1(GEN x);
873: GEN gcvtop(GEN x, GEN p, long r);
874: int gegal(GEN x, GEN y);
875: long gexpo(GEN x);
876: long ggval(GEN x, GEN p);
877: long glength(GEN x);
878: GEN gmax(GEN x, GEN y);
879: GEN gmin(GEN x, GEN y);
880: GEN gneg(GEN x);
881: GEN gneg_i(GEN x);
882: GEN greffe(GEN x, long l, long use_stack);
883: int gsigne(GEN x);
884: GEN gtolist(GEN x);
885: long gtolong(GEN x);
886: int lexcmp(GEN x, GEN y);
887: GEN listconcat(GEN list1, GEN list2);
888: GEN listcreate(long n);
889: GEN listinsert(GEN list, GEN object, long index);
890: void listkill(GEN list);
891: GEN listput(GEN list, GEN object, long index);
892: GEN listsort(GEN list, long flag);
893: GEN matsize(GEN x);
894: GEN normalize(GEN x);
895: GEN normalizepol(GEN x);
896: GEN normalizepol_i(GEN x, long lx);
1.2 ! noro 897: long polvaluation(GEN x, GEN *z);
1.1 noro 898: GEN pureimag(GEN x);
899: long pvaluation(GEN x, GEN p, GEN *py);
900: long sizedigit(GEN x);
1.2 ! noro 901: long svaluation(ulong x, ulong p, ulong *py);
1.1 noro 902: GEN vecmax(GEN x);
903: GEN vecmin(GEN x);
904:
905: /* gen3.c */
906:
907: GEN Mod0(GEN x, GEN y,long flag);
908: GEN ceil_safe(GEN x);
909: GEN centerlift(GEN x);
910: GEN centerlift0(GEN x,long v);
911: GEN coefs_to_int(long n, ...);
912: GEN coefs_to_pol(long n, ...);
913: GEN compo(GEN x, long n);
914: GEN deg1pol(GEN x1, GEN x0,long v);
915: GEN deg1pol_i(GEN x1, GEN x0,long v);
916: long degree(GEN x);
917: GEN denom(GEN x);
918: GEN deriv(GEN x, long v);
919: GEN derivpol(GEN x);
920: GEN derivser(GEN x);
1.2 ! noro 921: GEN diviiround(GEN x, GEN y);
! 922: GEN divrem(GEN x, GEN y, long v);
1.1 noro 923: GEN gand(GEN x, GEN y);
924: GEN gceil(GEN x);
925: GEN gcvtoi(GEN x, long *e);
926: GEN gdivent(GEN x, GEN y);
927: GEN gdiventres(GEN x, GEN y);
928: GEN gdivgs(GEN x, long s);
929: GEN gdivmod(GEN x, GEN y, GEN *pr);
930: GEN gdivround(GEN x, GEN y);
931: GEN geq(GEN x, GEN y);
932: GEN geval(GEN x);
933: GEN gfloor(GEN x);
934: GEN gfrac(GEN x);
935: GEN gge(GEN x, GEN y);
936: GEN ggprecision(GEN x);
937: GEN ggt(GEN x, GEN y);
938: GEN gimag(GEN x);
939: GEN ginv(GEN x);
940: GEN gle(GEN x, GEN y);
941: GEN glt(GEN x, GEN y);
942: GEN gmod(GEN x, GEN y);
943: GEN gmodulcp(GEN x,GEN y);
944: GEN gmodulo(GEN x,GEN y);
945: GEN gmodulsg(long x, GEN y);
946: GEN gmodulss(long x, long y);
947: GEN gmul2n(GEN x, long n);
948: GEN gmulsg(long s, GEN y);
949: GEN gne(GEN x, GEN y);
950: GEN gnot(GEN x);
951: GEN gor(GEN x, GEN y);
952: GEN gpolvar(GEN y);
953: long gprecision(GEN x);
954: GEN gram_matrix(GEN M);
955: GEN greal(GEN x);
956: GEN grndtoi(GEN x, long *e);
957: GEN ground(GEN x);
958: GEN gshift(GEN x, long n);
1.2 ! noro 959: GEN gshift3(GEN x, long n, long flag);
1.1 noro 960: GEN gsubst(GEN x, long v, GEN y);
961: GEN gsubst0(GEN x, GEN v, GEN y);
962: GEN gtopoly(GEN x, long v);
963: GEN gtopolyrev(GEN x, long v);
964: GEN gtoser(GEN x, long v);
965: GEN gtovec(GEN x);
966: GEN gtovecsmall(GEN x);
967: GEN gtrunc(GEN x);
968: int gvar(GEN x);
969: int gvar2(GEN x);
970: int gvar9(GEN x);
971: GEN hqfeval(GEN q, GEN x);
972: GEN integ(GEN x, long v);
973: int iscomplex(GEN x);
974: int isexactzero(GEN g);
975: int isinexactreal(GEN x);
976: int ismonome(GEN x);
977: GEN lift(GEN x);
978: GEN lift0(GEN x,long v);
979: GEN lift_intern0(GEN x,long v);
980: GEN mulmat_real(GEN x, GEN y);
981: GEN numer(GEN x);
982: long padicprec(GEN x, GEN p);
983: GEN polcoeff0(GEN x,long n,long v);
1.2 ! noro 984: GEN polcoeff_i(GEN x, long n, long v);
1.1 noro 985: long poldegree(GEN x,long v);
986: GEN poleval(GEN x, GEN y);
987: GEN pollead(GEN x,long v);
988: long precision(GEN x);
989: GEN precision0(GEN x,long n);
990: GEN qf_base_change(GEN q, GEN M, int flag);
991: GEN qfeval(GEN q, GEN x);
1.2 ! noro 992: GEN real2n(long n, long prec);
1.1 noro 993: GEN recip(GEN x);
994: GEN round0(GEN x, GEN *pte);
995: GEN scalarpol(GEN x, long v);
996: GEN scalarser(GEN x, long v, long prec);
997: GEN simplify(GEN x);
998: GEN simplify_i(GEN x);
999: GEN truecoeff(GEN x, long n);
1000: GEN trunc0(GEN x, GEN *pte);
1001: GEN u2toi(ulong a, ulong b);
1002: GEN zeropol(long v);
1003: GEN zeroser(long v, long prec);
1004:
1005: /* ifactor1.c */
1006:
1.2 ! noro 1007: long BSW_psp(GEN N);
1.1 noro 1008: long millerrabin(GEN n, long k);
1009: GEN nextprime(GEN n);
1010: GEN plisprime(GEN N, long flag);
1011: GEN precprime(GEN n);
1012:
1013: /* init.c */
1014:
1.2 ! noro 1015: long TIMER(pari_timer *T);
! 1016: void TIMERstart(pari_timer *T);
! 1017: long allocatemoremem(size_t newsize);
1.1 noro 1018: GEN changevar(GEN x, GEN y);
1019: void checkmemory(GEN x);
1020: void disable_dbg(long val);
1021: GEN dummycopy(GEN x);
1022: void err(long numerr, ...);
1023: void *err_catch(long errnum, jmp_buf env, void *data);
1024: void err_leave(void **v);
1025: GEN forcecopy(GEN x);
1026: void freeall(void);
1027: GEN gcopy(GEN x);
1028: GEN gcopy_i(GEN x, long lx);
1.2 ! noro 1029: GEN gerepile(gpmem_t ltop, gpmem_t lbot, GEN q);
! 1030: void gerepileall(ulong av, int n, ...);
! 1031: GEN gerepilecopy(gpmem_t av, GEN x);
! 1032: void gerepilemany(gpmem_t av, GEN* g[], int n);
! 1033: void gerepilemanycoeffs(gpmem_t av, GEN x, int n);
! 1034: void gerepilemanysp(gpmem_t av, gpmem_t tetpil, GEN* g[], int n);
! 1035: void gerepilemanyvec(gpmem_t av, gpmem_t tetpil, long *g, int n);
! 1036: GEN gerepileupto(gpmem_t av, GEN q);
! 1037: GEN gerepileuptoint(gpmem_t av, GEN q);
! 1038: GEN gerepileuptoleaf(gpmem_t av, GEN q);
1.1 noro 1039: char* gpmalloc(size_t bytes);
1.2 ! noro 1040: char* gprealloc(void *pointer,size_t size);
1.1 noro 1041: void gunclone(GEN x);
1042: void killbloc(GEN x);
1.2 ! noro 1043: void msgTIMER(pari_timer *T, char *format, ...);
1.1 noro 1044: void msgtimer(char *format, ...);
1045: GEN newbloc(long n);
1.2 ! noro 1046: void pari_init(size_t parisize, ulong maxprime);
1.1 noro 1047: GEN reorder(GEN x);
1048: void stackdummy(GEN x, long l);
1049: stackzone* switch_stack(stackzone *z, long n);
1.2 ! noro 1050: long taille(GEN x);
! 1051: long taille2(GEN x);
1.1 noro 1052: long timer(void);
1053: long timer2(void);
1054:
1055: /* mp.c ou mp.s */
1056:
1057: int absi_cmp(GEN x, GEN y);
1058: int absi_equal(GEN x, GEN y);
1059: int absr_cmp(GEN x, GEN y);
1060: GEN addii(GEN x, GEN y);
1061: GEN addir(GEN x, GEN y);
1062: GEN addrr(GEN x, GEN y);
1063: GEN addsi(long x, GEN y);
1064: GEN addsr(long x, GEN y);
1065: GEN addss(long x, long y);
1066: void affir(GEN x, GEN y);
1067: void affrr(GEN x, GEN y);
1068: GEN bezout(GEN a, GEN b, GEN *u, GEN *v);
1069: long cbezout(long a,long b,long *uu,long *vv);
1070: void cgiv(GEN x);
1071: int cmpii(GEN x, GEN y);
1072: int cmprr(GEN x, GEN y);
1073: int cmpsi(long x, GEN y);
1074: GEN dbltor(double x);
1075: GEN diviiexact(GEN x, GEN y);
1.2 ! noro 1076: GEN diviuexact(GEN x, ulong y);
1.1 noro 1077: void diviiz(GEN x, GEN y, GEN z);
1078: GEN divir(GEN x, GEN y);
1079: GEN divis(GEN y, long x);
1080: GEN divri(GEN x, GEN y);
1081: GEN divrr(GEN x, GEN y);
1082: GEN divrs(GEN x, long y);
1083: GEN divsi(long x, GEN y);
1084: GEN divsr(long x, GEN y);
1085: GEN dvmdii(GEN x, GEN y, GEN *z);
1086: int egalii(GEN x, GEN y);
1087: int invmod(GEN a, GEN b, GEN *res);
1088: GEN modii(GEN x, GEN y);
1089: void modiiz(GEN x, GEN y, GEN z);
1090: GEN modiu(GEN y, ulong x);
1091: GEN modsi(long x, GEN y);
1092: GEN modss(long x, long y);
1093: GEN modui(ulong x, GEN y);
1094: void mpdivz(GEN x, GEN y, GEN z);
1095: GEN mpent(GEN x);
1096: GEN mptrunc(GEN x);
1097: GEN mulii(GEN x, GEN y);
1098: GEN mulir(GEN x, GEN y);
1099: GEN mulrr(GEN x, GEN y);
1100: GEN mulsi(long x, GEN y);
1101: GEN mulsr(long x, GEN y);
1102: GEN mulss(long x, long y);
1103: GEN mului(ulong x, GEN y);
1104: GEN muluu(ulong x, ulong y);
1105: int ratlift(GEN x, GEN m, GEN *a, GEN *b, GEN amax, GEN bmax);
1.2 ! noro 1106: GEN resmod2n(GEN x, long n);
1.1 noro 1107: GEN resss(long x, long y);
1108: double rtodbl(GEN x);
1109: GEN shifti(GEN x, long n);
1.2 ! noro 1110: void shift_r(ulong *target, ulong *source, ulong *source_end, ulong prepend, ulong sh);
! 1111: GEN shifti3(GEN x, long n, long flag);
1.1 noro 1112: long smodsi(long x, GEN y);
1113: GEN sqri(GEN x);
1114: GEN truedvmdii(GEN x, GEN y, GEN *z);
1115: ulong umodiu(GEN y, ulong x);
1116: long vals(ulong x);
1117:
1118: /* nffactor.c */
1119:
1120: GEN nffactor(GEN nf,GEN x);
1121: GEN nffactormod(GEN nf,GEN pol,GEN pr);
1.2 ! noro 1122: int nfisgalois(GEN nf, GEN x);
1.1 noro 1123: GEN nfroots(GEN nf,GEN pol);
1124: GEN rnfcharpoly(GEN nf,GEN T,GEN alpha,int n);
1125: GEN rnfdedekind(GEN nf,GEN T,GEN pr);
1126: GEN unifpol(GEN nf,GEN pol,long flag);
1127:
1.2 ! noro 1128: /* perm.c */
! 1129:
! 1130: GEN abelian_group(GEN G);
! 1131: GEN bitvec_alloc(long n);
! 1132: long bitvec_test(GEN bitvec, long b);
! 1133: void bitvec_set(GEN bitvec, long b);
! 1134: void bitvec_clear(GEN bitvec, long b);
! 1135: GEN cyclicperm(long l, long d);
! 1136: GEN cyc_powtoperm(GEN cyc, long exp);
! 1137: GEN group_elts(GEN G, long n);
! 1138: long group_isabelian(GEN G);
! 1139: long group_order(GEN G);
! 1140: GEN group_subgroups(GEN G);
! 1141: GEN perm_cycles(GEN v);
! 1142: GEN perm_identity(long l);
! 1143: GEN perm_inv(GEN x);
! 1144: GEN perm_mul(GEN s, GEN t);
! 1145: GEN perm_pow(GEN perm, long exp);
! 1146: GEN vecperm_orbits(GEN v, long n);
! 1147: GEN vecsmall_append(GEN V, long s);
! 1148: GEN vecsmall_prepend(GEN V, long s);
! 1149: GEN vecsmall_const(long n, long c);
! 1150: int vecsmall_lexcmp(GEN x, GEN y);
! 1151: int vecsmall_prefixcmp(GEN x, GEN y);
! 1152: void vecsmall_sort(GEN V);
! 1153: GEN vecsmall_uniq(GEN V);
! 1154:
1.1 noro 1155: /* polarit1.c */
1.2 ! noro 1156:
1.1 noro 1157: GEN FpV_roots_to_pol(GEN V, GEN p, long v);
1158: long FpX_is_irred(GEN f, GEN p);
1159: long FpX_is_squarefree(GEN f, GEN p);
1160: long FpX_is_totally_split(GEN f, GEN p);
1161: long FpX_nbfact(GEN f, GEN p);
1162: long FpX_nbroots(GEN f, GEN p);
1.2 ! noro 1163: GEN FpX_rand(long d1, long v, GEN p);
1.1 noro 1164: GEN apprgen(GEN f, GEN a);
1165: GEN apprgen9(GEN f, GEN a);
1166: GEN factcantor(GEN x, GEN p);
1167: GEN factmod(GEN f, GEN p);
1168: GEN factmod0(GEN f, GEN p);
1169: GEN factmod9(GEN f, GEN p, GEN a);
1170: GEN factormod0(GEN f, GEN p,long flag);
1171: GEN factorpadic0(GEN f,GEN p,long r,long flag);
1172: GEN factorpadic2(GEN x, GEN p, long r);
1173: GEN factorpadic4(GEN x, GEN p, long r);
1.2 ! noro 1174: GEN ffinit(GEN p,long n, long v);
1.1 noro 1175: int gdivise(GEN x, GEN y);
1176: long hensel_lift_accel(long n, long *pmask);
1177: GEN incloop(GEN a);
1178: GEN mat_to_polpol(GEN x, long v,long w);
1179: GEN mat_to_vecpol(GEN x, long v);
1180: GEN padicsqrtnlift(GEN a, GEN n, GEN S, GEN p, long e);
1.2 ! noro 1181: GEN pol_to_vec(GEN x, long N);
1.1 noro 1182: int poldivis(GEN x, GEN y, GEN *z);
1183: GEN poldivres(GEN x, GEN y, GEN *pr);
1184: GEN polpol_to_mat(GEN v, long n);
1185: GEN rootmod(GEN f, GEN p);
1186: GEN rootmod0(GEN f, GEN p,long flag);
1187: GEN rootmod2(GEN f, GEN p);
1188: GEN rootpadic(GEN f, GEN p, long r);
1189: GEN rootpadicfast(GEN f, GEN p, long e);
1190: GEN rootpadiclift(GEN T, GEN S, GEN q, long e);
1191: GEN rootpadicliftroots(GEN f, GEN S, GEN q, long e);
1192: GEN roots2(GEN pol,long PREC);
1193: GEN rootsold(GEN x, long l);
1194: GEN setloop(GEN a);
1195: GEN simplefactmod(GEN f, GEN p);
1.2 ! noro 1196: GEN swap_polpol(GEN x, long n, long w);
! 1197: GEN vec_to_pol(GEN x, long v);
1.1 noro 1198: GEN vecpol_to_mat(GEN v, long n);
1199:
1200: /* polarit2.c */
1201:
1.2 ! noro 1202: GEN Q_denom(GEN x);
! 1203: GEN Q_div_to_int(GEN x, GEN c);
! 1204: GEN Q_muli_to_int(GEN x, GEN d);
! 1205: GEN Q_primitive_part(GEN x, GEN *ptc);
! 1206: GEN Q_remove_denom(GEN x, GEN *ptd);
! 1207: GEN Q_primpart(GEN x);
1.1 noro 1208: GEN bezoutpol(GEN a, GEN b, GEN *u, GEN *v);
1209: GEN centermod(GEN x, GEN p);
1.2 ! noro 1210: GEN centermodii(GEN x, GEN p, GEN po2);
! 1211: GEN concat_factor(GEN f, GEN g);
1.1 noro 1212: GEN content(GEN x);
1213: GEN discsr(GEN x);
1214: GEN divide_conquer_prod(GEN x, GEN (*mul)(GEN,GEN));
1.2 ! noro 1215: GEN leftright_pow(GEN,GEN,void*,GEN (*sqr)(void*,GEN),GEN (*mul)(void*,GEN,GEN));
1.1 noro 1216: GEN factor(GEN x);
1217: GEN factor0(GEN x,long flag);
1218: GEN factorback(GEN fa,GEN nf);
1.2 ! noro 1219: GEN factorback0(GEN fa,GEN e, GEN nf);
! 1220: GEN factorbackelt(GEN fa, GEN e, GEN nf);
1.1 noro 1221: GEN factpol(GEN x, long hint);
1222: GEN gbezout(GEN x, GEN y, GEN *u, GEN *v);
1223: GEN gcd0(GEN x, GEN y,long flag);
1224: GEN gdeflate(GEN x, long v, long d);
1225: GEN gdivexact(GEN x, GEN y);
1226: GEN ggcd(GEN x, GEN y);
1227: GEN ggcd0(GEN x, GEN y);
1228: GEN ginvmod(GEN x, GEN y);
1229: GEN gisirreducible(GEN x);
1230: GEN glcm(GEN x, GEN y);
1231: GEN glcm0(GEN x, GEN y);
1232: long logint(GEN B, GEN y, GEN *ptq);
1233: GEN newtonpoly(GEN x, GEN p);
1234: GEN nfisincl(GEN a, GEN b);
1235: GEN nfisisom(GEN a, GEN b);
1236: GEN poldeflate(GEN x0, long *m);
1237: GEN poldisc0(GEN x, long v);
1238: GEN polfnf(GEN a, GEN t);
1239: GEN polhensellift(GEN pol, GEN fct, GEN p, long exp);
1240: GEN polinflate(GEN x0, long d);
1241: GEN polresultant0(GEN x, GEN y,long v,long flag);
1242: GEN polsym(GEN x, long n);
1243: GEN primitive_part(GEN x, GEN *c);
1.2 ! noro 1244: GEN primpart(GEN x);
! 1245: GEN pseudorem(GEN x, GEN y);
1.1 noro 1246: GEN quadgen(GEN x);
1247: GEN quadpoly(GEN x);
1248: GEN quadpoly0(GEN x, long v);
1249: GEN reduceddiscsmith(GEN pol);
1250: GEN resultant2(GEN x, GEN y);
1251: GEN resultantducos(GEN x, GEN y);
1252: GEN sort_factor(GEN y, int (*cmp)(GEN,GEN));
1253: GEN sort_factor_gen(GEN y, int (*cmp)(GEN,GEN));
1.2 ! noro 1254: GEN sort_vecpol(GEN a);
1.1 noro 1255: GEN srgcd(GEN x, GEN y);
1256: long sturmpart(GEN x, GEN a, GEN b);
1257: GEN subresall(GEN u, GEN v, GEN *sol);
1258: GEN subresext(GEN x, GEN y, GEN *U, GEN *V);
1259: GEN sylvestermatrix(GEN x,GEN y);
1260: GEN vecbezout(GEN x, GEN y);
1261: GEN vecbezoutres(GEN x, GEN y);
1262:
1263: /* polarit3.c */
1264:
1265: GEN FpM(GEN z, GEN p);
1266: GEN FpM_red(GEN z, GEN p);
1267: GEN FpV(GEN z, GEN p);
1268: GEN FpV_red(GEN z, GEN p);
1269: GEN FpX(GEN z, GEN p);
1270: GEN FpX_FpXQ_compo(GEN T,GEN x,GEN pol,GEN p);
1271: GEN FpX_FpXQV_compo(GEN T,GEN x,GEN pol,GEN p);
1272: GEN FpX_Fp_add(GEN y,GEN x,GEN p);
1273: GEN FpX_Fp_mul(GEN y,GEN x,GEN p);
1274: GEN FpX_add(GEN x,GEN y,GEN p);
1275: GEN FpX_center(GEN T,GEN mod);
1276: GEN FpX_chinese_coprime(GEN x,GEN y,GEN Tx,GEN Ty,GEN Tz,GEN p);
1277: GEN FpX_divres(GEN x, GEN y, GEN p, GEN *pr);
1278: GEN FpX_eval(GEN x,GEN y,GEN p);
1279: GEN FpX_extgcd(GEN x, GEN y, GEN p, GEN *ptu, GEN *ptv);
1280: GEN FpX_gcd(GEN x, GEN y, GEN p);
1281: GEN FpX_mul(GEN x,GEN y,GEN p);
1282: GEN FpX_neg(GEN x,GEN p);
1283: GEN FpX_normalize(GEN z, GEN p);
1284: GEN FpX_red(GEN z, GEN p);
1285: GEN FpX_small(GEN z, GEN p, long l);
1286: GEN FpX_sqr(GEN x,GEN p);
1287: GEN FpX_sub(GEN x,GEN y,GEN p);
1288: GEN FpXQ_charpoly(GEN x, GEN T, GEN p);
1.2 ! noro 1289: GEN FpXQ_div(GEN x,GEN y,GEN T,GEN p);
1.1 noro 1290: GEN FpXQ_inv(GEN x,GEN pol,GEN p);
1291: GEN FpXQ_minpoly(GEN x, GEN T, GEN p);
1292: GEN FpXQ_mul(GEN y,GEN x,GEN pol,GEN p);
1293: GEN FpXQ_pow(GEN x, GEN n, GEN pol, GEN p);
1294: GEN FpXQ_powers(GEN x, long l, GEN T, GEN p);
1295: GEN FpXQ_sqr(GEN y, GEN pol, GEN p);
1296: GEN FpXQX_mul(GEN x, GEN y, GEN T, GEN p);
1297: GEN FpXQX_red(GEN z, GEN T, GEN p);
1298: GEN FpXQX_sqr(GEN x, GEN T, GEN p);
1299: GEN FpXQX_extgcd(GEN x, GEN y, GEN T, GEN p, GEN *ptu, GEN *ptv);
1300: GEN FpXQX_FpXQ_mul(GEN P, GEN U, GEN T, GEN p);
1301: GEN FpXQX_divres(GEN x, GEN y, GEN T, GEN p, GEN *pr);
1302: GEN FpXQX_normalize(GEN z, GEN T, GEN p);
1.2 ! noro 1303: GEN FpXV_FpV_innerprod(GEN V, GEN W, GEN p);
1.1 noro 1304: GEN FpXV_red(GEN z, GEN p);
1305: GEN FpXX_red(GEN z, GEN p);
1.2 ! noro 1306: GEN FpY_FpXY_resultant(GEN a, GEN b0, GEN p);
1.1 noro 1307: GEN Fp_factor_rel(GEN P, GEN l, GEN Q);
1308: GEN Fp_factor_rel0(GEN P, GEN l, GEN Q);
1309: void Fp_intersect(long n,GEN P,GEN Q,GEN l,GEN *SP,GEN *SQ,GEN MA,GEN MB);
1310: GEN Fp_inv_isom(GEN S,GEN Tp, GEN p);
1311: GEN Fp_isom(GEN P,GEN Q,GEN l);
1312: GEN FqV_roots_to_pol(GEN V, GEN p, GEN Tp, long v);
1.2 ! noro 1313: GEN ZX_caract(GEN A, GEN B, long v);
1.1 noro 1314: GEN ZX_disc(GEN x);
1.2 ! noro 1315: GEN QX_invmod(GEN A, GEN B);
! 1316: GEN QX_caract(GEN A, GEN B, long v);
! 1317: int ZX_is_squarefree(GEN x);
1.1 noro 1318: GEN ZX_resultant(GEN A, GEN B);
1.2 ! noro 1319: GEN ZX_QX_resultant(GEN A, GEN B);
1.1 noro 1320: GEN ZX_s_add(GEN y,long x);
1321: long brent_kung_optpow(long d, long n);
1322: GEN ffsqrtnmod(GEN a, GEN n, GEN T, GEN p, GEN *zetan);
1323: GEN modulargcd(GEN a,GEN b);
1324: GEN quickmul(GEN a, GEN b, long na, long nb);
1325: GEN quicksqr(GEN a, long na);
1.2 ! noro 1326: GEN small_to_col(GEN z);
1.1 noro 1327: GEN small_to_mat(GEN z);
1328: GEN small_to_pol(GEN z, long v);
1.2 ! noro 1329: GEN small_to_vec(GEN z);
1.1 noro 1330: GEN pol_to_small(GEN x);
1.2 ! noro 1331: ulong powuumod(ulong x, ulong n0, ulong p);
! 1332: GEN powgumod(GEN x, ulong n0, GEN p);
! 1333: GEN rescale_pol(GEN P, GEN h);
! 1334: GEN unscale_pol(GEN P, GEN h);
1.1 noro 1335: GEN stopoly(long m, long p, long v);
1336: GEN stopoly_gen(GEN m, GEN p, long v);
1337: GEN u_FpXQ_pow(GEN x, GEN n, GEN pol, ulong p);
1.2 ! noro 1338: GEN u_FpX_divrem(GEN x, GEN y, ulong p, GEN *pr);
1.1 noro 1339: GEN u_FpX_rem(GEN x, GEN y, ulong p);
1340: GEN u_Fp_FpM(GEN x, ulong p);
1.2 ! noro 1341: GEN u_Fp_FpV(GEN x, ulong p);
! 1342: GEN u_Fp_FpX(GEN x, ulong p);
1.1 noro 1343: int u_FpX_is_squarefree(GEN z, ulong p);
1344: GEN u_FpX_normalize(GEN z, ulong p);
1345: GEN u_FpX_sub(GEN x, GEN y, ulong p);
1346: GEN u_FpX_gcd(GEN a, GEN b, ulong p);
1.2 ! noro 1347: ulong u_invmod(ulong x, ulong p);
! 1348: int u_pow(int p, int k);
! 1349: int u_val(ulong n, ulong p);
! 1350: GEN u_zeropol(void);
1.1 noro 1351:
1352: /* rootpol.c */
1353:
1354: int isrealappr(GEN x, long l);
1355: GEN roots(GEN x,long l);
1356: GEN roots0(GEN x,long flag,long l);
1357:
1.2 ! noro 1358: /*subcyclo.c */
! 1359:
! 1360: GEN galoissubcyclo(GEN N, GEN sg, long flag, long v);
! 1361: GEN polsubcyclo(long n, long d, long v);
! 1362: GEN subcyclo(long n, long d, long v);
! 1363: GEN znstar_small(GEN zn);
! 1364:
1.1 noro 1365: /* subfields.c */
1366:
1367: GEN subfields(GEN nf,GEN d);
1368: GEN subfields0(GEN nf,GEN d);
1369: GEN conjugates(GEN pol);
1370:
1371: /* subgroup.c */
1372:
1.2 ! noro 1373: void forsubgroup(entree *oep, GEN cyc, GEN bound, char *och);
! 1374: GEN subgrouplist(GEN cyc, GEN bound);
1.1 noro 1375:
1376: /* stark.c */
1377:
1378: GEN bnrL1(GEN bnr, GEN sbgrp, long flag, long prec);
1379: GEN bnrrootnumber(GEN bnr, GEN chi, long flag, long prec);
1380: GEN bnrstark(GEN bnr, GEN subgroup, long flag, long prec);
1381:
1382: /* sumiter.c */
1383:
1384: GEN direulerall(entree *ep, GEN a, GEN b, char *ch, GEN c);
1385: GEN direuler(entree *ep, GEN a, GEN b, char *ch);
1386: GEN divsum(GEN num,entree *ep, char *ch);
1387: void fordiv(GEN a, entree *ep, char *ch);
1388: void forpari(entree *ep, GEN a, GEN b, char *ch);
1389: void forprime(entree *ep, GEN a, GEN b, char *ch);
1390: void forstep(entree *ep, GEN a, GEN b, GEN s, char *ch);
1391: void forvec(entree *ep, GEN x, char *ch, long flag);
1392: GEN intnum0(entree *ep, GEN a, GEN b, char *ch,long flag,long prec);
1393: GEN matrice(GEN nlig, GEN ncol,entree *ep1, entree *ep2, char *ch);
1394: GEN polzag(long n, long m);
1395: GEN polzagreel(long n, long m, long prec);
1396: GEN prodeuler(entree *ep, GEN a, GEN b, char *ch, long prec);
1397: GEN prodinf(entree *ep, GEN a, char *ch, long prec);
1398: GEN prodinf0(entree *ep, GEN a, char *ch, long flag, long prec);
1399: GEN prodinf1(entree *ep, GEN a, char *ch, long prec);
1400: GEN produit(entree *ep, GEN a, GEN b, char *ch, GEN x);
1401: GEN somme(entree *ep, GEN a, GEN b, char *ch, GEN x);
1402: GEN sumalt(entree *ep, GEN a, char *ch, long prec);
1403: GEN sumalt0(entree *ep, GEN a, char *ch,long flag, long prec);
1404: GEN sumalt2(entree *ep, GEN a, char *ch, long prec);
1405: GEN sumpos(entree *ep, GEN a, char *ch, long prec);
1406: GEN sumpos0(entree *ep, GEN a, char *ch, long flag,long prec);
1407: GEN sumpos2(entree *ep, GEN a, char *ch, long prec);
1408: GEN suminf(entree *ep, GEN a, char *ch, long prec);
1409: GEN vecteur(GEN nmax, entree *ep, char *ch);
1.2 ! noro 1410: GEN vecteursmall(GEN nmax, entree *ep, char *ch);
1.1 noro 1411: GEN vvecteur(GEN nmax, entree *ep, char *ch);
1412: GEN zbrent(entree *ep, GEN a, GEN b, char *ch, long prec);
1413:
1414: /* thue.c */
1415:
1416: GEN bnfisintnorm(GEN x, GEN y);
1417: GEN thue(GEN thueres, GEN rhs, GEN ne);
1418: GEN thueinit(GEN poly, long flag, long prec);
1419:
1420: /* trans1.c */
1421:
1.2 ! noro 1422: GEN Pi2n(long n, long prec);
! 1423: GEN PiI2(long prec);
! 1424: GEN PiI2n(long n, long prec);
1.1 noro 1425: void consteuler(long prec);
1426: void constpi(long prec);
1.2 ! noro 1427: GEN exp_Ir(GEN x);
1.1 noro 1428: GEN gcos(GEN x, long prec);
1429: void gcosz(GEN x, GEN y);
1430: GEN gcotan(GEN x, long prec);
1431: GEN gexp(GEN x, long prec);
1432: void gexpz(GEN x, GEN y);
1433: GEN glog(GEN x, long prec);
1434: void glogz(GEN x, GEN y);
1435: GEN gpow(GEN x, GEN n, long prec);
1436: GEN gpowgs(GEN x, long n);
1437: GEN gsin(GEN x, long prec);
1438: void gsincos(GEN x, GEN *s, GEN *c, long prec);
1439: void gsinz(GEN x, GEN y);
1440: GEN gsqrt(GEN x, long prec);
1441: void gsqrtz(GEN x, GEN y);
1442: GEN gsqrtn(GEN x, GEN n, GEN *zetan, long prec);
1443: GEN gtan(GEN x, long prec);
1444: void gtanz(GEN x, GEN y);
1445: GEN log0(GEN x,long flag, long prec);
1446: GEN mpeuler(long prec);
1447: GEN mpexp(GEN x);
1448: GEN mpexp1(GEN x);
1449: GEN mplog(GEN x);
1.2 ! noro 1450: GEN mplog2(long prec);
1.1 noro 1451: GEN mppi(long prec);
1452: GEN mpsqrt(GEN x);
1.2 ! noro 1453: GEN padiczero(GEN p, long e);
1.1 noro 1454: GEN palog(GEN x);
1455: GEN powgi(GEN x, GEN n);
1456: GEN teich(GEN x);
1457: GEN transc(GEN (*f) (GEN, long), GEN x, long prec);
1458:
1459: /* trans2.c */
1460:
1461: GEN bernfrac(long n);
1462: GEN bernreal(long n, long prec);
1463: GEN bernvec(long nomb);
1464: GEN gach(GEN x, long prec);
1465: void gachz(GEN x, GEN y);
1466: GEN gacos(GEN x, long prec);
1467: void gacosz(GEN x, GEN y);
1468: GEN garg(GEN x, long prec);
1469: GEN gash(GEN x, long prec);
1470: void gashz(GEN x, GEN y);
1471: GEN gasin(GEN x, long prec);
1472: void gasinz(GEN x, GEN y);
1473: GEN gatan(GEN x, long prec);
1474: void gatanz(GEN x, GEN y);
1475: GEN gath(GEN x, long prec);
1476: void gathz(GEN x, GEN y);
1477: GEN gch(GEN x, long prec);
1478: void gchz(GEN x, GEN y);
1479: GEN ggamd(GEN x, long prec);
1480: void ggamdz(GEN x, GEN y);
1481: GEN ggamma(GEN x, long prec);
1482: void ggammaz(GEN x, GEN y);
1483: GEN glngamma(GEN x, long prec);
1484: void glngammaz(GEN x, GEN y);
1485: GEN gpsi(GEN x, long prec);
1486: void gpsiz(GEN x, GEN y);
1487: GEN gsh(GEN x, long prec);
1488: void gshz(GEN x, GEN y);
1489: GEN gth(GEN x, long prec);
1490: void gthz(GEN x, GEN y);
1491: void mpbern(long nomb, long prec);
1492: void mpgamdz(long s, GEN y);
1493:
1494: /* trans3.c */
1495:
1496: GEN agm(GEN x, GEN y, long prec);
1497: GEN cgetc(long l);
1498: GEN dilog(GEN x, long prec);
1499: GEN eint1(GEN x, long prec);
1500: GEN eta(GEN x, long prec);
1501: GEN eta0(GEN x, long flag,long prec);
1502: GEN gerfc(GEN x, long prec);
1503: GEN glogagm(GEN x, long prec);
1504: GEN gpolylog(long m, GEN x, long prec);
1505: void gpolylogz(long m, GEN x, GEN y);
1506: GEN gzeta(GEN x, long prec);
1507: void gzetaz(GEN x, GEN y);
1508: GEN hyperu(GEN a, GEN b, GEN gx, long prec);
1509: GEN incgam(GEN a, GEN x, long prec);
1510: GEN incgam0(GEN a, GEN x, GEN z,long prec);
1511: GEN incgam1(GEN a, GEN x, long prec);
1512: GEN incgam2(GEN a, GEN x, long prec);
1513: GEN incgam3(GEN a, GEN x, long prec);
1514: GEN incgam4(GEN a, GEN x, GEN z, long prec);
1.2 ! noro 1515: GEN hbessel1(GEN n, GEN z, long prec);
! 1516: GEN hbessel2(GEN n, GEN z, long prec);
! 1517: GEN ibessel(GEN n, GEN z, long prec);
! 1518: GEN jbessel(GEN n, GEN z, long prec);
1.1 noro 1519: GEN jbesselh(GEN n, GEN z, long prec);
1.2 ! noro 1520: GEN nbessel(GEN n, GEN z, long prec);
1.1 noro 1521: GEN jell(GEN x, long prec);
1522: GEN kbessel(GEN nu, GEN gx, long prec);
1523: GEN kbessel0(GEN nu, GEN gx, long flag,long prec);
1524: GEN kbessel2(GEN nu, GEN x, long prec);
1525: GEN logagm(GEN q);
1526: GEN polylog(long m, GEN x, long prec);
1527: GEN polylog0(long m, GEN x, long flag, long prec);
1528: GEN polylogd(long m, GEN x, long prec);
1529: GEN polylogdold(long m, GEN x, long prec);
1530: GEN polylogp(long m, GEN x, long prec);
1531: GEN theta(GEN q, GEN z, long prec);
1532: GEN thetanullk(GEN q, long k, long prec);
1533: GEN trueeta(GEN x, long prec);
1534: GEN veceint1(GEN nmax, GEN C, long prec);
1535: GEN weber0(GEN x, long flag,long prec);
1536: GEN wf(GEN x, long prec);
1537: GEN wf2(GEN x, long prec);
1538: ENDEXTERN
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to paridecl.h CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / pari-2.2 / src / headers