Annotation of OpenXM_contrib/pari/src/language/init.c, Revision 1.1.1.1
1.1 maekawa 1: /*******************************************************************/
2: /* */
3: /* INITIALIZING THE SYSTEM, ERRORS */
4: /* */
5: /*******************************************************************/
6: /* $Id: init.c,v 1.3 1999/09/24 15:28:35 karim Exp $ */
7: #include <string.h>
8: #include "pari.h"
9: #include "anal.h"
10: #ifdef _WIN32
11: # ifndef WINCE
12: # include <process.h>
13: # endif
14: #endif
15:
16: /* Variables statiques communes : */
17: FILE *pari_outfile, *errfile, *logfile, *infile;
18: GEN *polun, *polx;
19: GEN gnil, gzero, gun, gdeux, ghalf, polvar, gi;
20: GEN gpi=NULL, geuler=NULL, bernzone=NULL;
21: GEN primetab; /* private primetable */
22: byteptr diffptr;
23: char *current_logfile, *current_psfile;
24: int gp_colors[c_LAST];
25: int disable_color = 1, added_newline = 1, under_emacs = 0;
26:
27: int functions_tblsz = 135; /* size of functions_hash */
28: entree **varentries;
29:
30: jmp_buf environnement;
31: long *ordvar;
32: long DEBUGFILES,DEBUGLEVEL,DEBUGMEM,compatible;
33: long prec,precdl;
34: ulong init_opts = INIT_JMPm | INIT_SIGm;
35: ulong top, bot, avma, memused;
36:
37: void *foreignHandler; /* Handler for foreign commands. */
38: char foreignExprSwitch = 3; /* Just some unprobable char. */
39: GEN (*foreignExprHandler)(char*); /* Handler for foreign expressions.*/
40: entree * (*foreignAutoload)(char*, long); /* Autoloader */
41: void (*foreignFuncFree)(entree *); /* How to free external entree. */
42:
43: GEN (*gp_history_fun)(long, long, char *, char *);
44: int (*whatnow_fun)(char *, int);
45:
46: void initout(void);
47: int term_width(void);
48:
49: /*********************************************************************/
50: /* */
51: /* INITIALISATION DU SYSTEME */
52: /* */
53: /*********************************************************************/
54: static int var_not_changed; /* altered in reorder() */
55: static int try_to_recover = 0;
56: static long next_bloc;
57: static GEN cur_bloc=NULL; /* current bloc in bloc list */
58: static long *universal_constants;
59:
60: #ifdef WINCE
61: #else
62: static void
63: pari_sighandler(int sig)
64: {
65: char *msg;
66: switch(sig)
67: {
68: case SIGINT:
69: #ifdef _WIN32
70: # ifdef SIGBREAK
71: case SIGBREAK:
72: # endif
73: if (++win32ctrlc >= 5) _exit(3);
74: signal(sig,pari_sighandler);
75: return;
76: #endif
77: msg="user interrupt";
78: break;
79:
80: case SIGSEGV:
81: msg="segmentation fault: bug in PARI or calling program";
82: break;
83:
84: #ifdef SIGBUS
85: case SIGBUS:
86: msg="bus error: bug in PARI or calling program";
87: break;
88: #endif
89: }
90: signal(sig,pari_sighandler);
91: err(talker,msg);
92: }
93: #endif
94:
95: #ifdef _WIN32
96: int win32ctrlc = 0;
97:
98: void
99: dowin32ctrlc()
100: {
101: win32ctrlc = 0;
102: err(talker,"user interrupt");
103: }
104: #endif
105:
106: /* Initialize hashtable */
107: static void
108: init_hashtable(entree **table, int tblsz)
109: {
110: entree *ep, *ep1, *last;
111: long i, v;
112:
113: for (i = 0; i < tblsz; i++)
114: {
115: last = NULL; ep = table[i]; table[i] = NULL;
116: for ( ; ep; ep = ep1)
117: {
118: ep1 = ep->next; v = EpVALENCE(ep);
119: if (v == EpVAR || v == EpINSTALL) /* keep this one */
120: {
121: if (last)
122: last->next = ep;
123: else
124: table[i] = ep;
125: last = ep; last->next = NULL;
126: }
127: else freeep(ep);
128: }
129: }
130: }
131:
132: static void
133: fill_hashtable(entree **table, entree *ep, char **helpmessage)
134: {
135: long n;
136:
137: for ( ; ep->name; ep++)
138: {
139: EpSETSTATIC(ep);
140: ep->help = helpmessage? *helpmessage++: NULL;
141: n = hashvalue(ep->name);
142: ep->next = table[n]; table[n] = ep;
143: ep->args = NULL;
144: }
145: }
146:
147: void
148: init_defaults(int force)
149: {
150: static int done=0;
151:
152: if (done && !force) return;
153: done = 1;
154:
155: #ifdef LONG_IS_64BIT
156: prec=4;
157: #else
158: prec=5;
159: #endif
160:
161: precdl = 16;
162: compatible = NONE;
163: DEBUGFILES = DEBUGLEVEL = DEBUGMEM = 0;
164:
165: current_psfile = pari_strdup("pari.ps");
166: current_logfile= pari_strdup("pari.log");
167: logfile = NULL;
168: infile = stdin; pari_outfile = stdout; errfile = stderr;
169: initout(); next_bloc=0;
170: }
171:
172: /* does elt belong to list, after position start (excluded) ? */
173: static int
174: list_isin(void **list, void *elt, int start)
175: {
176: long indelt=0;
177:
178: if (list)
179: {
180: while (*list)
181: {
182: if (indelt>start && *list==elt) return indelt;
183: list++; indelt++;
184: }
185: }
186: return -1;
187: }
188:
189: static void
190: list_prepend(void ***listptr, void *elt)
191: {
192: void **list=*listptr;
193: long nbelt=0;
194:
195: if (list)
196: while (list[nbelt]) nbelt++;
197: list = (void **) gpmalloc(sizeof(void *)*(nbelt+2));
198: list[0]=elt;
199: if (nbelt)
200: {
201: memcpy(list+1,*listptr,nbelt*sizeof(void *));
202: free(*listptr);
203: }
204: list[nbelt+1]=NULL; *listptr=list;
205: }
206:
207: /* Load modlist in hashtable hash. If force == 0, do not load twice the
208: * same list in the same hashtable, which would only destroy user variables.
209: * As it stands keep a complete history (instead of most recent changes).
210: */
211: int
212: gp_init_entrees(module *modlist, entree **hash, int force)
213: {
214: static void **oldmodlist=NULL, **oldhash=NULL;
215:
216: if (!force)
217: {
218: const long indhash = list_isin(oldhash,(void *)hash,-1);
219: if (indhash != -1 && oldmodlist[indhash]==modlist) return 0;
220: }
221: /* record the new pair (hash,modlist) */
222: list_prepend(&oldmodlist,(void *)modlist);
223: list_prepend(&oldhash,(void *)hash);
224:
225: init_hashtable(hash,functions_tblsz);
226: while (modlist && modlist->func)
227: {
228: fill_hashtable(hash, modlist->func, modlist->help);
229: modlist++;
230: }
231: return (hash == functions_hash);
232: }
233:
234: module *pari_modules = NULL;
235: module *pari_oldmodules = NULL;
236: module *pari_membermodules = NULL;
237: entree **functions_hash = NULL;
238: entree **funct_old_hash = NULL;
239: entree **members_hash = NULL;
240:
241: /* add to modlist the functions in func, with helpmsg help */
242: void
243: pari_addfunctions(module **modlist_p, entree *func, char **help)
244: {
245: module *modlist = *modlist_p;
246: int nbmodules = 0;
247:
248: while (modlist && modlist->func) { nbmodules++; modlist++; }
249: modlist = *modlist_p;
250: *modlist_p = (module*) gpmalloc(sizeof(module)*(nbmodules+2));
251: if (nbmodules)
252: {
253: memcpy(1+ *modlist_p, modlist, sizeof(module)*nbmodules);
254: free(modlist);
255: }
256: modlist = *modlist_p;
257: modlist->func = func;
258: modlist->help = help;
259:
260: modlist += nbmodules+1;
261: modlist->func = NULL;
262: modlist->help = NULL;
263: }
264:
265: static long
266: fix_size(long a)
267: {
268: /* BYTES_IN_LONG*ceil(a/BYTES_IN_LONG) */
269: ulong b = a+BYTES_IN_LONG - (((a-1) & (BYTES_IN_LONG-1)) + 1);
270: if (b > VERYBIGINT) err(talker,"stack too large");
271: return b;
272: }
273:
274: void
275: pari_sig_init(void (*f)(int))
276: {
277: #ifdef WINCE
278: #else
279: #ifdef SIGBUS
280: signal(SIGBUS,f);
281: #endif
282: signal(SIGINT,f);
283: #ifdef SIGBREAK
284: signal(SIGBREAK,f);
285: #endif
286: signal(SIGSEGV,f);
287: #endif
288: }
289:
290: /* initialise les donnees de la bibliotheque PARI. Peut être précédée d'un
291: * appel à pari_addfunctions si on ajoute d'autres fonctions au pool de base.
292: */
293: void
294: pari_init(long parisize, long maxprime)
295: {
296: long n;
297: GEN p;
298:
299: init_defaults(0);
300: if (INIT_JMP && setjmp(environnement))
301: {
302: fprintferr(" *** Error in the PARI system. End of program.\n");
303: exit(1);
304: }
305: #ifndef WINCE
306: if (INIT_SIG) pari_sig_init(pari_sighandler);
307: #endif
308: parisize = fix_size(parisize);
309: #if __MWERKS__
310: {
311: OSErr resultCode;
312: Handle newHand = TempNewHandle(parisize,&resultCode);
313:
314: if (!newHand) err(memer);
315: HLock(newHand);
316: bot = (long)*newHand;
317: }
318: #else
319: bot = (long) gpmalloc(parisize);
320: #endif
321: top = avma = memused = bot+parisize;
322: diffptr = initprimes(maxprime);
323:
324: varentries = (entree**) gpmalloc((MAXVARN+1)*sizeof(entree*));
325: polvar = (GEN) gpmalloc((MAXVARN+1)*sizeof(long));
326: ordvar = (GEN) gpmalloc((MAXVARN+1)*sizeof(long));
327: polx = (GEN*) gpmalloc((MAXVARN+1)*sizeof(GEN));
328: polun = (GEN*) gpmalloc((MAXVARN+1)*sizeof(GEN));
329: polvar[0] = evaltyp(t_VEC) | evallg(1);
330: for (n=0; n <= MAXVARN; n++) ordvar[n] = n;
331:
332: /* 2 (gnil) + 2 (gzero) + 3 (gun) + 3 (gdeux) + 3 (half) + 3 (gi) */
333: p = universal_constants = (long *) gpmalloc(16*sizeof(long));
334:
335: gzero = p; p+=2; gnil = p; p+=2;
336: gzero[0] = gnil[0] = evaltyp(t_INT) | evallg(2);
337: gzero[1] = gnil[1] = evallgefint(2);
338:
339: gun = p; p+=3; gdeux = p; p+=3;
340: gun[0] = gdeux[0] = evaltyp(t_INT) | evallg(3);
341: gun[1] = gdeux[1] = evalsigne(1) | evallgefint(3);
342: gun[2] = 1; gdeux[2]= 2;
343:
344: ghalf = p; p+=3; gi = p; p+=3;
345: ghalf[0] = evaltyp(t_FRAC) | evallg(3);
346: ghalf[1] = un;
347: ghalf[2] = deux;
348: gi[0] = evaltyp(t_COMPLEX) | evallg(3);
349: gi[1] = zero;
350: gi[2] = un;
351: fetch_var(); /* create polx/polun[MAXVARN] */
352: primetab = (GEN) gpmalloc((NUMPRTBELT+2)*sizeof(long));
353: primetab[0] = evaltyp(t_VEC) | evallg(1);
354:
355: pari_addfunctions(&pari_modules, functions_basic,helpmessages_basic);
356: functions_hash = (entree **) gpmalloc(sizeof(entree*)*functions_tblsz);
357: for (n = 0; n < functions_tblsz; n++) functions_hash[n] = NULL;
358:
359: pari_addfunctions(&pari_oldmodules, oldfonctions,oldhelpmessage);
360: funct_old_hash = (entree **) gpmalloc(sizeof(entree*)*functions_tblsz);
361: for (n = 0; n < functions_tblsz; n++) funct_old_hash[n] = NULL;
362: gp_init_entrees(pari_oldmodules, funct_old_hash, 1);
363:
364: if (new_fun_set)
365: gp_init_entrees(pari_modules, functions_hash, 1);
366: else
367: gp_init_entrees(pari_oldmodules, functions_hash, 1);
368:
369: pari_addfunctions(&pari_membermodules, gp_member_list, NULL);
370: members_hash = (entree **) gpmalloc(sizeof(entree*)*functions_tblsz);
371: for (n = 0; n < functions_tblsz; n++) members_hash[n] = NULL;
372: gp_init_entrees(pari_membermodules, members_hash, 1);
373:
374: gp_history_fun = NULL;
375: whatnow_fun = NULL;
376: manage_var(2,NULL); /* init nvar */
377: var_not_changed = 1; fetch_named_var("x", 0);
378: try_to_recover=1;
379: }
380:
381: void
382: freeall()
383: {
384: long i;
385: entree *ep,*ep1;
386:
387: while (delete_var()) /* empty */;
388: for (i = 0; i < functions_tblsz; i++)
389: {
390: for (ep = functions_hash[i]; ep; ep = ep1)
391: {
392: ep1 = ep->next; freeep(ep);
393: }
394: for (ep = members_hash[i]; ep; ep = ep1)
395: {
396: ep1 = ep->next; freeep(ep);
397: }
398: }
399: free((void*)varentries); free((void*)ordvar); free((void*)polvar);
400: free((void*)polx[MAXVARN]); free((void*)polx); free((void*)polun);
401: free((void*)primetab);
402: free((void*)universal_constants);
403:
404: /* set first cell to 0 to inhibit recursion in all cases */
405: while (cur_bloc) { *cur_bloc=0; killbloc(cur_bloc); }
406: killallfiles(1);
407: free((void *)functions_hash);
408: free((void *)bot); free((void *)diffptr);
409: free(current_logfile);
410: free(current_psfile);
411:
412: if (gp_history_fun)
413: gp_history_fun(0,-1,NULL,NULL);
414: }
415:
416: GEN
417: getheap()
418: {
419: long m=0,l=0;
420: GEN x;
421:
422: for (x = cur_bloc; x; x = (GEN)bl_prev(x))
423: {
424: m++; l+=4;
425: if (! x[0]) /* user function */
426: l += (strlen((char *)(x+sizeof(entree*)))) / sizeof(long);
427: else if (x==bernzone)
428: l += x[0];
429: else /* GEN */
430: l += taille(x);
431: }
432: x=cgetg(3,t_VEC); x[1]=lstoi(m); x[2]=lstoi(l);
433: return x;
434: }
435:
436: /* Return x, where:
437: * x[-3]: adress of next bloc
438: * x[-2]: adress of preceding bloc.
439: * x[-1]: number of allocated blocs.
440: * x[0..n-1]: malloc-ed memory.
441: */
442: GEN
443: newbloc(long n)
444: {
445: long *x = (long *) gpmalloc((n + BL_HEAD)*sizeof(long)) + BL_HEAD;
446:
447: bl_next(x) = 0; /* the NULL address */
448: bl_prev(x) = (long)cur_bloc;
449: bl_num(x) = next_bloc++;
450: if (n) *x = 0; /* initialize first cell to 0. See killbloc */
451: if (cur_bloc) bl_next(cur_bloc) = (long)x;
452: if (DEBUGMEM)
453: {
454: if (!n) err(warner,"mallocing NULL object in newbloc");
455: if (DEBUGMEM > 2)
456: fprintferr("new bloc, size %6ld (no %ld): %08lx\n", n, next_bloc-1, x);
457: }
458: return cur_bloc = x;
459: }
460:
461: void
462: killbloc0(GEN x, int inspect)
463: {
464: long tx,lx,l,i,j;
465: GEN p1;
466:
467: if (!x || isonstack(x)) return;
468: if (bl_next(x)) bl_prev(bl_next(x)) = bl_prev(x);
469: else
470: {
471: cur_bloc = (GEN)bl_prev(x);
472: next_bloc = bl_num(x);
473: }
474: if (bl_prev(x)) bl_next(bl_prev(x)) = bl_next(x);
475: if (DEBUGMEM > 2)
476: fprintferr("killing bloc (no %ld): %08lx\n", bl_num(x), x);
477: if (inspect)
478: {
479: /* FIXME: SIGINT should be blocked at this point */
480: tx=typ(x); /* if x is not a GEN, we will have tx=0 */
481: if (is_vec_t(tx))
482: {
483: lx = lg(x);
484: for (i=1;i<lx;i++)
485: {
486: p1=(GEN)x[i];
487: if (isclone(p1)) killbloc(p1);
488: }
489: }
490: else if (tx==t_MAT)
491: {
492: lx = lg(x);
493: if (lx>1)
494: {
495: l=lg(x[1]);
496: if (l>1)
497: for (i=1;i<lx;i++)
498: for (j=1;j<l;j++)
499: {
500: p1=gmael(x,i,j);
501: if (isclone(p1)) killbloc(p1);
502: }
503: }
504: }
505: else if (tx==t_LIST)
506: {
507: lx = lgef(x);
508: for (i=2;i<lx;i++)
509: {
510: p1=(GEN)x[i];
511: if (isclone(p1)) killbloc(p1);
512: }
513: }
514: unsetisclone(x);
515: /* FIXME: SIGINT should be released here */
516: }
517: free((void *)bl_base(x));
518: }
519: void
520: killbloc(GEN x) { killbloc0(x,1); }
521: void
522: gunclone(GEN x) { killbloc0(x,0); }
523:
524: /********************************************************************/
525: /** **/
526: /** VARIABLE ORDERING **/
527: /** **/
528: /********************************************************************/
529:
530: /* Substitution globale des composantes du vecteur y aux variables de x */
531: GEN
532: changevar(GEN x, GEN y)
533: {
534: long tx,ty,lx,vx,vy,i,av,tetpil;
535: GEN p1,p2,z;
536:
537: if (var_not_changed && y==polvar) return x;
538: tx=typ(x); if (!is_recursive_t(tx)) return gcopy(x);
539: ty=typ(y); if (! is_vec_t(ty)) err(changer1);
540: if (is_scalar_t(tx))
541: {
542: if (tx!=t_POLMOD) return gcopy(x);
543: av=avma;
544: p1=changevar((GEN)x[1],y);
545: p2=changevar((GEN)x[2],y); tetpil=avma;
546: return gerepile(av,tetpil, gmodulcp(p2,p1));
547: }
548: if (is_rfrac_t(tx))
549: {
550: av=avma;
551: p1=changevar((GEN)x[1],y);
552: p2=changevar((GEN)x[2],y); tetpil=avma;
553: return gerepile(av,tetpil, gdiv(p1,p2));
554: }
555:
556: lx = (tx==t_POL)? lgef(x): lg(x);
557: if (tx == t_POL || tx == t_SER)
558: {
559: vx=varn(x)+1; if (vx>=lg(y)) return gcopy(x);
560: p1=(GEN)y[vx];
561: if (!signe(x))
562: {
563: vy=gvar(p1); if (vy>MAXVARN) err(changer1);
564: z=gcopy(x); setvarn(z,vy); return z;
565: }
566: av=avma; p2=changevar((GEN)x[lx-1],y);
567: for (i=lx-2; i>=2; i--)
568: {
569: p2 = gmul(p2,p1);
570: p2 = gadd(p2, changevar((GEN)x[i],y));
571: }
572: if (tx==t_SER)
573: {
574: p2 = gadd(p2, ggrando(p1,lx-2));
575: if (valp(x))
576: p2 = gmul(gpuigs(p1,valp(x)), p2);
577: }
578: return gerepileupto(av,p2);
579: }
580: z=cgetg(lx,tx);
581: for (i=1; i<lx; i++) z[i]=lchangevar((GEN)x[i],y);
582: return z;
583: }
584:
585: GEN
586: reorder(GEN x)
587: {
588: long tx,lx,i,n, nvar = manage_var(3,NULL);
589: int *var,*varsort,*t1;
590:
591: if (!x) return polvar;
592: tx=typ(x); lx=lg(x)-1;
593: if (! is_vec_t(tx)) err(typeer,"reorder");
594: if (! lx) return polvar;
595:
596: varsort = (int *) gpmalloc(lx*sizeof(int));
597: var = (int *) gpmalloc(lx*sizeof(int));
598: t1 = (int *) gpmalloc(nvar*sizeof(int));
599:
600: for (n=0; n<nvar; n++) t1[n] = 0;
601: for (n=0; n<lx; n++)
602: {
603: var[n] = i = gvar((GEN)x[n+1]);
604: varsort[n] = ordvar[var[n]]; /* position in polvar */
605: if (i >= nvar) err(talker,"variable out of range in reorder");
606: /* check if x is a permutation */
607: if (t1[i]) err(talker,"duplicated indeterminates in reorder");
608: t1[i] = 1;
609: }
610: qsort(varsort,lx,sizeof(int),(QSCOMP)pari_compare_int);
611:
612: for (n=0; n<lx; n++)
613: {
614: /* variables are numbered 0,1 etc... while polvar starts at 1. */
615: polvar[varsort[n]+1] = lpolx[var[n]];
616: ordvar[var[n]] = varsort[n];
617: }
618:
619: var_not_changed=1;
620: for (i=0; i<nvar; i++)
621: if (ordvar[i]!=i) { var_not_changed=0; break; }
622:
623: free(t1); free(var); free(varsort);
624: return polvar;
625: }
626:
627: /*******************************************************************/
628: /* */
629: /* ERROR RECOVERY */
630: /* */
631: /*******************************************************************/
632: int pop_val_if_newer(entree *ep, long loc);
633: void kill_from_hashlist(entree *ep);
634:
635: /* if flag = 0: record address of next bloc allocated.
636: * if flag = 1: (after an error) recover all memory allocated since last call
637: */
638: void
639: recover(int flag)
640: {
641: static long listloc;
642: long n;
643: entree *ep, *epnext;
644: #ifndef WINCE
645: void (*sigfun)(int);
646: #endif
647:
648: if (!flag) { listloc = next_bloc; return; }
649:
650: /* disable recover() and SIGINT. Better: sigint_[block|release] as in
651: * readline/rltty.c ? */
652: try_to_recover=0;
653: #ifndef WINCE
654: sigfun = signal(SIGINT, SIG_IGN);
655: #endif
656:
657: for (n = 0; n < functions_tblsz; n++)
658: for (ep = functions_hash[n]; ep; ep = epnext)
659: {
660: epnext = ep->next;
661: switch(EpVALENCE(ep))
662: {
663: case EpVAR:
664: while (pop_val_if_newer(ep,listloc)) /* empty */;
665: break;
666: case EpNEW:
667: kill_from_hashlist(ep);
668: break;
669: case EpUSER:
670: case EpALIAS:
671: case EpMEMBER:
672: if (bl_num(ep->value) >= listloc)
673: {
674: gunclone((GEN)ep->value);
675: ep->value = (void*)initial_value(ep);
676: kill_from_hashlist(ep);
677: }
678: }
679: }
680: #if 0
681: /* This causes SEGV on lists and GP-2.0 vectors: internal component is
682: * destroyed while global object is not updated. Two solutions:
683: * - comment it out: should not be a big memory problem except for huge
684: * vec. components. Has the added advantadge that the results computed so
685: * far are not lost.
686: *
687: * - tag every variable whose component has been modified in the last
688: * cycle. Untag it at the begining of each cycle. Maybe this should be
689: * done. But do we really want to destroy a huge global vector if one of
690: * its components was modified before the error ? (we don't copy the whole
691: * thing anymore). K.B.
692: */
693: {
694: GEN y;
695: for (x = cur_bloc; x && bl_num(x) >= listloc; x = y)
696: {
697: y = (GEN)bl_prev(x);
698: if (x != gpi && x != geuler && x != bernzone) killbloc(x);
699: }
700: }
701: #endif
702: try_to_recover=1;
703: #ifndef WINCE
704: signal(SIGINT, sigfun);
705: #endif
706: }
707:
708: void
709: disable_dbg(long val)
710: {
711: static long oldval = -1;
712: if (val < 0)
713: {
714: if (oldval >= 0) { DEBUGLEVEL = oldval; oldval = -1; }
715: }
716: else if (DEBUGLEVEL)
717: { oldval = DEBUGLEVEL; DEBUGLEVEL = val; }
718: }
719:
720: void
721: err_recover(long numerr)
722: {
723: pari_outfile=stdout; errfile=stderr;
724: disable_dbg(-1);
725: if (pariErr->die) pariErr->die(); /* Caller wants to catch exceptions? */
726: fprintferr("\n"); flusherr();
727: if (!environnement) exit(1);
728:
729: /* reclaim memory stored in "blocs" */
730: if (try_to_recover) recover(1);
731: /* allocate _after_ recover (otherwise we may inspect freed memory) */
732: if (numerr==errpile) (void)allocatemoremem(0);
733: longjmp(environnement, numerr);
734: }
735:
736: #define MAX_PAST 25
737: #define STR_LEN 20
738: /* Outputs a beautiful error message
739: * msg is errmessage to print.
740: * s points to the offending chars.
741: * entry tells how much we can go back from s[0].
742: */
743: static void
744: errcontext(char *msg, char *s, char *entry)
745: {
746: char *prefix = " *** ";
747: int past = (s-entry);
748: char str[STR_LEN + 2];
749: char *buf = gpmalloc(strlen(msg) + MAX_PAST + 5), *t = buf;
750:
751: sprintf(t,"%s: ", msg);
752: if (past <= 0) past = 0;
753: else
754: {
755: t += strlen(t);
756: if (past > MAX_PAST) { past=MAX_PAST; strcpy(t, "..."); t += 3; }
757: strncpy(t, s - past, past); t[past] = 0;
758: }
759:
760: t = str; if (!past) *t++ = ' ';
761: strncpy(t, s, STR_LEN); t[STR_LEN] = 0;
762: print_prefixed_text(buf, prefix, str); free(buf);
763: }
764:
765: #define op_err(ap, op) {\
766: long _x = va_arg(ap, long);\
767: long _y = va_arg(ap, long);\
768: (pariputsf(" %s %s %s.",type_name(_x),(op),type_name(_y)));\
769: }
770:
771: VOLATILE void
772: err(long numerr, ...)
773: {
774: char s[128], *ch1, ret = 0;
775: PariOUT *out = pariOut;
776: va_list ap;
777:
778: va_start(ap,numerr);
779: if (!added_newline) { pariputc('\n'); added_newline=1; }
780: pariflush(); pariOut = pariErr;
781: pariflush(); term_color(c_ERR);
782:
783: if (numerr < talker)
784: {
785: strcpy(s, errmessage[numerr]);
786: switch (numerr)
787: {
788: case obsoler:
789: ch1 = va_arg(ap,char *);
790: errcontext(s,ch1,va_arg(ap,char *));
791: if (whatnow_fun)
792: {
793: print_text("For full compatibility with GP 1.39, type \"default(compatible,3)\" (you can also set \"compatible = 3\" in your GPRC file)");
794: pariputc('\n');
795: term_color(c_NONE); ch1 = va_arg(ap,char *);
796: whatnow_fun(ch1, - va_arg(ap,int));
797: }
798: break;
799:
800: case openfiler:
801: sprintf(s+strlen(s), "%s file", va_arg(ap,char*));
802: ch1 = va_arg(ap,char *);
803: errcontext(s,ch1,ch1); break;
804:
805: case talker2:
806: case member:
807: strcat(s,va_arg(ap, char*)); /* fall through */
808: default:
809: ch1 = va_arg(ap,char *);
810: errcontext(s,ch1,va_arg(ap,char *));
811: }
812: }
813: else
814: {
815: pariputsf(" *** %s", errmessage[numerr]);
816: switch (numerr)
817: {
818: case talker:
819: ch1=va_arg(ap, char*);
820: vpariputs(ch1,ap); pariputs(".\n"); break;
821:
822: case impl:
823: ch1=va_arg(ap, char*);
824: pariputsf(" %s is not yet implemented.",ch1); break;
825:
826: case breaker: case typeer: case mattype1: case overwriter:
827: case accurer: case infprecer: case negexper: case polrationer:
828: case funder2: case constpoler: case notpoler: case redpoler:
829: case zeropoler: case consister: case flagerr:
830: pariputsf(" %s.",va_arg(ap, char*)); break;
831:
832: case bugparier:
833: pariputsf(" %s, please report",va_arg(ap, char*)); break;
834:
835: case assigneri: case assignerf:
836: op_err(ap, "-->"); break;
837: case gadderi: case gadderf:
838: op_err(ap, "+"); break;
839: case gmuleri: case gmulerf:
840: op_err(ap, "*"); break;
841: case gdiveri: case gdiverf:
842: op_err(ap, "/"); break;
843:
844: /* the following 4 are only warnings (they return) */
845: case warnmem: case warner:
846: pariputc(' '); ch1=va_arg(ap, char*);
847: vpariputs(ch1,ap); pariputs(".\n");
848: ret = 1; break;
849:
850: case warnprec:
851: vpariputs(" %s; new prec = %ld\n",ap);
852: ret = 1; break;
853:
854: case warnfile:
855: ch1=va_arg(ap, char*);
856: pariputsf(" %s: %s", ch1, va_arg(ap, char*));
857: }
858: }
859: term_color(c_NONE); va_end(ap);
860: pariOut = out; if (ret) { flusherr(); return; }
861: err_recover(numerr); exit(1); /* not reached */
862: }
863: #undef op_err
864:
865: /*******************************************************************/
866: /* */
867: /* STACK MANAGEMENT */
868: /* */
869: /*******************************************************************/
870: /* Inhibit some area gerepile-wise: declare it to be a non recursive
871: * type, of length l. Thus gerepile won't inspect the zone, just copy it.
872: * For the following situation:
873: * z = cgetg(t,a); garbage of length l;
874: * for (i=1; i<HUGE; i++) z[i] = ...
875: * stackdummy(z,l); z += l; We lose l words but save a costly gerepile.
876: */
877: void
878: stackdummy(GEN z, long l)
879: {
880: z[0] = evaltyp(t_STR) | evallg(l);
881: }
882:
883: /* Takes an array of pointers to GENs, of length n. Copies all
884: * objects to contiguous locations and cleans up the stack between
885: * av and avma.
886: */
887: void
888: gerepilemany(long av, GEN* gptr[], long n)
889: {
890: GEN *l = (GEN*)gpmalloc(n*sizeof(GEN));
891: long i;
892:
893: /* copy objects */
894: for (i=0; i<n; i++) l[i] = gclone(*(gptr[i]));
895: avma = av;
896: /* copy them back, kill clones */
897: for (--i; i>=0; i--)
898: {
899: *(gptr[i]) = forcecopy(l[i]);
900: gunclone(l[i]);
901: }
902: free(l);
903: }
904:
905: void
906: gerepilemanycoeffs(long av, GEN x, long n)
907: {
908: long i;
909:
910: /* copy objects */
911: for (i=0; i<n; i++) x[i] = lclone((GEN)x[i]);
912: avma = av;
913: /* copy them back, kill clones */
914: for (--i; i>=0; i--)
915: {
916: GEN p1 = (GEN)x[i];
917: x[i] = (long)forcecopy(p1); gunclone(p1);
918: }
919: }
920:
921: /* Takes an array of pointers to GENs, of length n.
922: * Cleans up the stack between av and tetpil, updating those GENs.
923: */
924: void
925: gerepilemanysp(long av, long tetpil, GEN* gptr[], long n)
926: {
927: const long av2 = avma, dec = av-tetpil;
928: long i;
929:
930: (void)gerepile(av,tetpil,NULL);
931: for (i=0; i<n; i++)
932: {
933: ulong *g1 = (ulong*) gptr[i];
934: if (*g1 < (ulong)tetpil)
935: {
936: if (*g1 >= (ulong)av2) *g1 += dec; /* Update address if in stack */
937: else if (*g1 >=(ulong)av) err(gerper);
938: }
939: }
940: }
941:
942: /* Takes an array of GENs (casted to longs), of length n. Cleans up the
943: * stack between av and tetpil, and update those GENs.
944: */
945: void
946: gerepilemanyvec(long av, long tetpil, long *g, long n)
947: {
948: const long av2 = avma, dec = av-tetpil;
949: long i;
950:
951: (void)gerepile(av,tetpil,NULL);
952: for (i=0; i<n; i++,g++)
953: if ((ulong)*g < (ulong)tetpil)
954: {
955: if ((ulong)*g >= (ulong)av2) *g += dec;/* Update addresses if in stack */
956: else if ((ulong)*g >= (ulong)av) err(gerper);
957: }
958: }
959:
960: GEN
961: gerepileupto(long av, GEN q)
962: {
963: if (!isonstack(q)) { avma=av; return q; } /* universal object */
964: /* empty garbage */
965: if ((ulong)av <= (ulong)q) return q;
966: /* The garbage is only empty when av==q. It's probably a mistake if
967: * av < q. But "temporary variables" from sumiter are a problem since
968: * ep->values are returned as-is by identifier() and they can be in the
969: * stack: if we put a gerepileupto in lisseq(), we get an error. Maybe add,
970: * if (DEBUGMEM) err(warner,"av>q in gerepileupto") ???
971: */
972:
973: /* Beware: (long)(q+i) --> ((long)q)+i*sizeof(long) */
974: return gerepile(av, (long) (q+lg(q)), q);
975: }
976:
977: /* internal */
978: GEN
979: gerepileuptoleaf(long av, GEN q)
980: {
981: long i;
982: GEN q0;
983:
984: if (!isonstack(q) || av==(long)q) { avma=av; return q; }
985: i=lg(q); avma = (long)(((GEN)av) - i);
986: q0 = (GEN)avma; while (--i >= 0) q0[i]=q[i];
987: return q0;
988: }
989: /* internal */
990: GEN
991: gerepileuptoint(long av, GEN q)
992: {
993: if (!isonstack(q) || av==(long)q) { avma=av; return q; }
994: avma = (long)icopy_av(q, (GEN)av);
995: return (GEN)avma;
996: }
997:
998: /* check that x and all its components are out of stack, or have been
999: * created after av */
1000: int
1001: ok_for_gerepileupto(long r, GEN x)
1002: {
1003: long i,lx = lg(x),tx = typ(x);
1004: if (! is_recursive_t(tx))
1005: return !isonstack(x) || x <= (GEN)r;
1006: if (x > (GEN)r)
1007: {
1008: err(warner,"bad object %Z\n",x);
1009: return 0;
1010: }
1011:
1012: lx = lg(x);
1013: if (tx==t_POL || tx==t_LIST) lx = lgef(x);
1014: for (i=lontyp[tx]; i<lx; i++)
1015: if (!ok_for_gerepileupto(r, (GEN)x[i]))
1016: {
1017: err(warner,"bad component %ld in object %Z\n",i,x);
1018: return 0;
1019: }
1020: return 1;
1021: }
1022:
1023: GEN
1024: gerepile(long av, long tetpil, GEN q)
1025: {
1026: long avmb, dec = av - tetpil;
1027: GEN ll,a,b;
1028:
1029: if (dec==0) return q;
1030: if (dec<0) err(talker,"lbot>ltop in gerepile");
1031:
1032: if ((ulong)q>=(ulong)avma && (ulong)q<(ulong)tetpil)
1033: q = (GEN) (((long)q) + dec);
1034:
1035: #if 1
1036: for (ll=(GEN)av, a=(GEN)tetpil; a > (GEN)avma; ) *--ll= *--a;
1037: avmb = (long)ll;
1038: #else /* slower */
1039: ll = (GEN)(avmb=avma+dec); a = (GEN)avma;
1040: for (i=((tetpil-avma)>>TWOPOTBYTES_IN_LONG)-1; i>=0; i--) ll[i] = a[i];
1041: #endif
1042:
1043: while (ll < (GEN)av)
1044: {
1045: const long tl=typ(ll);
1046:
1047: if (! is_recursive_t(tl)) { ll+=lg(ll); continue; }
1048: a = ll+lontyp[tl];
1049: if (tl==t_POL) { b=ll+lgef(ll); ll+=lg(ll); } else { ll+=lg(ll); b=ll; }
1050: for ( ; a<b; a++)
1051: if ((ulong)*a < (ulong)av && (ulong)*a >= (ulong)avma)
1052: {
1053: if ((ulong)*a < (ulong)tetpil) *a += dec; else err(gerper);
1054: }
1055: }
1056: avma = avmb; return q;
1057: }
1058:
1059: long
1060: allocatemoremem(ulong newsize)
1061: {
1062: long sizeold = top - bot, newbot;
1063:
1064: if (!newsize)
1065: {
1066: newsize = sizeold << 1;
1067: err(warner,"doubling stack size; new stack = %lu",newsize);
1068: }
1069: else if ((long)newsize < 0)
1070: err(talker,"required stack memory too small");
1071: /* can't do bot = malloc directly, in case we lack memory */
1072: newsize = fix_size(newsize);
1073: newbot = (long) gpmalloc(newsize);
1074: free((void*)bot); bot = newbot;
1075: memused = avma = top = bot + newsize;
1076: return newsize;
1077: }
1078:
1079: /* alternate stack management routine */
1080: stackzone *
1081: switch_stack(stackzone *z, long n)
1082: {
1083: if (!z)
1084: { /* create parallel stack */
1085: long size = n*sizeof(long) + sizeof(stackzone);
1086: z = (stackzone*) gpmalloc(size);
1087: z->zonetop = ((long)z) + size;
1088: return z;
1089: }
1090:
1091: if (n)
1092: { /* switch to parallel stack */
1093: z->bot = bot;
1094: z->top = top;
1095: z->avma = avma;
1096: z->memused = memused;
1097: bot = (long) (z+1);
1098: top = z->zonetop;
1099: avma = top;
1100: memused = (ulong)-1;
1101: }
1102: else
1103: { /* back to normalcy */
1104: bot = z->bot;
1105: top = z->top;
1106: avma = z->avma;
1107: memused = z->memused;
1108: }
1109: return NULL;
1110: }
1111:
1112: #if 0 /* for a specific broken machine (readline not correctly installed) */
1113: char *xmalloc(long x) { return malloc(x); }
1114: char *xrealloc(char *c,long x) { return realloc(c,x); }
1115: #endif
1116:
1117: char*
1118: gpmalloc(size_t bytes)
1119: {
1120: char *tmp;
1121:
1122: if (bytes)
1123: {
1124: tmp = (char *) malloc(bytes);
1125: if (!tmp) err(memer);
1126: return tmp;
1127: }
1128: if (DEBUGMEM)
1129: err(warner,"mallocing NULL object");
1130: return NULL;
1131: }
1132:
1133: #if __MWERKS__
1134: static void *
1135: macrealloc(void *p, size_t newsize, size_t oldsize)
1136: {
1137: char *q = gpmalloc(newsize), *qq = q, *pp = p;
1138: int l = newsize > oldsize ? oldsize : newsize;
1139:
1140: while (l--) *qq++ = *pp++;
1141: free(p); return q;
1142: }
1143: #endif
1144:
1145: char*
1146: gprealloc(void *pointer, size_t newsize, size_t oldsize)
1147: {
1148: char *tmp;
1149:
1150: if (!pointer) tmp = (char *) malloc(newsize);
1151: #if __MWERKS__
1152: else tmp = (char *) macrealloc(pointer,newsize,oldsize);
1153: #else
1154: else tmp = (char *) realloc(pointer,newsize);
1155: #endif
1156: if (!tmp) err(memer,oldsize);
1157: return tmp;
1158: }
1159:
1160: #ifdef MEMSTEP
1161: void
1162: checkmemory(GEN z)
1163: {
1164: if (DEBUGMEM && memused != (ulong)-1 &&
1165: ((GEN)memused > z + MEMSTEP || z > (GEN)memused + MEMSTEP))
1166: {
1167: memused=(ulong)z;
1168: #if MEMSTEP >= 1048576
1169: fprintferr("...%4.0lf Mbytes used\n",(top-memused)/1048576.);
1170: #else
1171: fprintferr("...%5.1lf Mbytes used\n",(top-memused)/1048576.);
1172: #endif
1173: }
1174: }
1175: #endif
1176:
1177: /*******************************************************************/
1178: /* */
1179: /* TIMER */
1180: /* */
1181: /*******************************************************************/
1182: #define MAX_TIMER 3
1183:
1184: #ifdef WINCE
1185: static long
1186: timer_proto(int i)
1187: {
1188: static DWORD oldticks[MAX_TIMER];
1189: DWORD ticks = GetTickCount();
1190: DWORD delay = ticks - oldticks[i];
1191: oldticks[i] = ticks;
1192: return delay;
1193:
1194: }
1195: #elif defined(macintosh)
1196: # include <Events.h>
1197: static long
1198: timer_proto(int i)
1199: {
1200: static long oldticks[MAX_TIMER];
1201: long ticks = TickCount(), delay = ticks - oldticks[i];
1202:
1203: oldticks[i] = ticks;
1204: return 50 * delay / 3;
1205: }
1206: #elif USE_TIMES
1207:
1208: # include <sys/times.h>
1209: # include <sys/time.h>
1210: static long
1211: timer_proto(int i)
1212: {
1213: static clock_t oldticks[MAX_TIMER];
1214: struct tms t;
1215: long delay;
1216:
1217: times(&t);
1218: delay = (long)((t.tms_utime - oldticks[i]) * (1000. / CLK_TCK));
1219: oldticks[i] = t.tms_utime;
1220: return delay;
1221: }
1222: #elif USE_GETRUSAGE
1223:
1224: # include <sys/time.h>
1225: # include <sys/resource.h>
1226: static long
1227: timer_proto(int i)
1228: {
1229: static long oldmusec[MAX_TIMER],oldsec[MAX_TIMER];
1230: struct rusage r;
1231: struct timeval t;
1232: long delay;
1233:
1234: getrusage(0,&r); t=r.ru_utime;
1235: delay = 1000 * (t.tv_sec - oldsec[i]) + (t.tv_usec - oldmusec[i]) / 1000;
1236: oldmusec[i] = t.tv_usec; oldsec[i] = t.tv_sec;
1237: return delay;
1238: }
1239: #elif USE_FTIME
1240:
1241: # include <sys/timeb.h>
1242: static long
1243: timer_proto(int i)
1244: {
1245: static long oldmsec[MAX_TIMER],oldsec[MAX_TIMER];
1246: struct timeb t;
1247: long delay;
1248:
1249: ftime(&t);
1250: delay = 1000 * (t.time - oldsec[i]) + (t.millitm - oldmsec[i]);
1251: oldmsec[i] = t.millitm; oldsec[i] = t.time;
1252: return delay;
1253: }
1254: #else
1255:
1256: # include <time.h>
1257: # ifndef CLOCKS_PER_SEC
1258: # define CLOCKS_PER_SEC 1000000 /* may be false on YOUR system */
1259: # endif
1260: static long
1261: timer_proto(int i)
1262: {
1263: static clock_t oldclocks[MAX_TIMER];
1264: clock_t t = clock();
1265: long delay = (long)((t-oldclocks[i]) * 1000. / CLOCKS_PER_SEC);
1266:
1267: oldclocks[i] = t;
1268: return delay;
1269: }
1270: #endif
1271:
1272: long
1273: gptimer() { return timer_proto(0); }
1274: long
1275: timer() { return timer_proto(1); }
1276: long
1277: timer2() { return timer_proto(2); }
1278:
1279: void
1280: msgtimer(char *format, ...)
1281: {
1282: va_list args;
1283: PariOUT *out = pariOut; pariOut = pariErr;
1284:
1285: pariputs("Time "); va_start(args, format);
1286: vpariputs(format,args); va_end(args);
1287: pariputsf(": %ld\n",timer2()); pariflush();
1288: pariOut = out;
1289: }
1290:
1291: /*******************************************************************/
1292: /* */
1293: /* FUNCTIONS KNOWN TO THE ANALYZER */
1294: /* */
1295: /*******************************************************************/
1296: void alias0(char *s, char *old);
1297: GEN break0(long n);
1298: GEN next0(long n);
1299: GEN return0(GEN x);
1300:
1301: GEN
1302: geni(void) { return gi; }
1303:
1304: /* List of GP functions:
1305: * ---------------------
1306: * Format (struct entree) :
1307: * char *name : name (under GP).
1308: * ulong valence : used to form arg list, now often handled by code.
1309: * void *value : For PREDEFINED FUNCTIONS: C function to call.
1310: * For USER FUNCTIONS: pointer to defining data (bloc) =
1311: * entree*: NULL, list of entree (arguments), NULL
1312: * char* : function text
1313: * long menu : which help section do we belong (See below).
1314: * char *code : argument list (See below).
1315: * entree *next : next entree (init to NULL, used in hashing code).
1316: * char *help : short help text (init to NULL).
1317: * void *args : For USER FUNCTIONS: default arguments (NULL terminated).
1318: * For VARIABLES: (esp. loop indexes): push_val history.
1319: * (while processing a loop, ep->value may not be a bloc)
1320: * menu:
1321: * -----
1322: * 1: Standard monadic or dyadic OPERATORS
1323: * 2: CONVERSIONS and similar elementary functions
1324: * 3: TRANSCENDENTAL functions
1325: * 4: NUMBER THEORETICAL functions
1326: * 5: Functions related to ELLIPTIC CURVES
1327: * 6: Functions related to general NUMBER FIELDS
1328: * 7: POLYNOMIALS and power series
1329: * 8: Vectors, matrices, LINEAR ALGEBRA and sets
1330: * 9: SUMS, products, integrals and similar functions
1331: * 10: GRAPHIC functions
1332: * 11: PROGRAMMING under GP
1333: *
1334: * code: describe function prototype. NULL = use valence instead.
1335: * -----
1336: * Arguments:
1337: * I input position (to be processed with lisexpr or lisseq).
1338: * G GEN
1339: * L long
1340: * S symbol (i.e GP function name)
1341: * V variable (same as S, but valence must equal EpVAR/EpGVAR)
1342: * n variable number
1343: * & *GEN
1344: * F Fake *GEN (function requires a *GEN, but we don't use the resulting GEN)
1345: * f Fake *long
1346: * p real precision (prec for the C library)
1347: * P series precision (precdl dor the C library)
1348: * r raw input (treated as a string without quotes).
1349: * Quoted args are copied as strings. Stops at first unquoted ')' or ','.
1350: * Special chars can be quoted using '\'. Ex : aa"b\n)"c => "aab\n)c".
1351: * s expanded string. Example: pi"x"2 yields "3.142x2".
1352: * The unquoted components can be of any pari type (converted according to
1353: * the current output format)
1354: * s* any number of strings (see s)
1355: * s*p idem, setting prettyp=1
1356: * s*t idem, in TeX format.
1357: * D Has a default value. Format is "Dvalue,type," (the ending comma is
1358: * mandatory). Ex: D0,L, (arg is long, 0 by default).
1359: * Special syntax:
1360: * if type = G, &, I or V: D[G&IV] all send NULL.
1361: * if type = v: Dn sends -1.
1362: *
1363: * The user-given args are read first, then completed by the defaults
1364: *
1365: * Return type (first char or immediately after 'x'): GEN by default, otherwise
1366: * l Return long
1367: * v Return void
1368: *
1369: * Syntax requirements:
1370: * = Separator '=' required.
1371: *
1372: * Origin:
1373: * x Installed foreign function. Put the ep of the function as the
1374: * first argument, fill the rest with PARI arguments,
1375: * then call installedHandler with these arguments.
1376: * Should be the first char in the code.
1377: *
1378: ****************************************************************************
1379: * If new codes are added, change identifier and skipidentifier.
1380: *
1381: * Currently the following functions have no code word:
1382: * 'O' 50, 'if' 80, 'until' 82, 'while' 81, 'global' 88,
1383: *
1384: * Valence 0 reserved for functions without mandatory args.
1385: * Valence 99 reserved for codes which do not correspond 1-to-1 to valences.
1386: * Any other valence (what to do with 0?) should correspond to exactly
1387: * one code.
1388: */
1389:
1390: entree functions_basic[]={
1391: {"Euler",0,(void*)mpeuler,3,"p"},
1392: {"I",0,(void*)geni,2,""},
1393: {"List",0,(void*)gtolist,2,"DG"},
1394: {"Mat",0,(void*)gtomat,2,"DG"},
1395: {"Mod",25,(void*)Mod0,2,"GGD0,L,"},
1396: {"O",50,NULL,7,NULL},
1397: {"Pi",0,(void*)mppi,3,"p"},
1398: {"Pol",14,(void*)gtopoly,2,"GDn"},
1399: {"Polrev",14,(void*)gtopolyrev,2,"GDn"},
1400: {"Qfb",99,(void*)Qfb0,2,"GGGDGp"},
1401: {"Ser",14,(void*)gtoser,2,"GDn"},
1402: {"Set",0,(void*)gtoset,2,"DG"},
1403: {"Str",0,(void*)strtoGENstr,2,"D\"\",s,D0,L,"},
1404: {"Vec",0,(void*)gtovec,2,"DG"},
1405: {"abs",1,(void*)gabs,3,"Gp"},
1406: {"acos",1,(void*)gacos,3,"Gp"},
1407: {"acosh",1,(void*)gach,3,"Gp"},
1408: {"addprimes",0,(void*)addprimes,4,"DG"},
1409: {"agm",29,(void*)agm,3,"GGp"},
1410: {"algdep",99,(void*)algdep0,8,"GLD0,L,p"},
1411: {"alias",99,(void*)alias0,11,"vrr"},
1412: {"arg",1,(void*)garg,3,"Gp"},
1413: {"asin",1,(void*)gasin,3,"Gp"},
1414: {"asinh",1,(void*)gash,3,"Gp"},
1415: {"atan",1,(void*)gatan,3,"Gp"},
1416: {"atanh",1,(void*)gath,3,"Gp"},
1417: {"bernfrac",11,(void*)bernfrac,3,"L"},
1418: {"bernreal",99,(void*)bernreal,3,"Lp"},
1419: {"bernvec",11,(void*)bernvec,3,"L"},
1420: {"besseljh",29,(void*)jbesselh,3,"GGp"},
1421: {"besselk",99,(void*)kbessel0,3,"GGD0,L,p"},
1422: {"bestappr",2,(void*)bestappr,4,"GG"},
1423: {"bezout",2,(void*)vecbezout,4,"GG"},
1424: {"bezoutres",2,(void*)vecbezoutres,4,"GG"},
1425: {"bigomega",18,(void*)gbigomega,4,"G"},
1426: {"binary",18,(void*)binaire,2,"G"},
1427: {"binomial",21,(void*)binome,4,"GL"},
1428: {"bittest",2,(void*)gbittest,2,"GG"},
1429: {"bnfcertify",10,(void*)certifybuchall,6,"lG"},
1430: {"bnfclassunit",99,(void*)bnfclassunit0,6,"GD0,L,DGp"},
1431: {"bnfclgp",99,(void*)classgrouponly,6,"GDGp"},
1432: {"bnfdecodemodule",2,(void*)decodemodule,6,"GG"},
1433: {"bnfinit",91,(void*)bnfinit0,6,"GD0,L,DGp"},
1434: {"bnfisintnorm",99,(void*)bnfisintnorm,6,"GG"},
1435: {"bnfisnorm",99,(void*)bnfisnorm,6,"GGD1,L,p"},
1436: {"bnfisprincipal",99,(void*)isprincipalall,6,"GGD1,L,"},
1437: {"bnfissunit",99,(void*)bnfissunit,6,"GGG"},
1438: {"bnfisunit",2,(void*)isunit,6,"GG"},
1439: {"bnfmake",1,(void*)bnfmake,6,"Gp"},
1440: {"bnfnarrow",18,(void*)buchnarrow,6,"G"},
1441: {"bnfreg",99,(void*)regulator,6,"GDGp"},
1442: {"bnfsignunit",18,(void*)signunits,6,"G"},
1443: {"bnfsunit",99,(void*)bnfsunit,6,"GGp"},
1444: {"bnfunit",1,(void*)buchfu,6,"Gp"},
1445: {"bnrL1",99,(void*)bnrL1,6,"GD0,L,p"},
1446: {"bnrclass",99,(void*)bnrclass0,6,"GGD0,L,p"},
1447: {"bnrclassno",2,(void*)rayclassno,6,"GG"},
1448: {"bnrclassnolist",2,(void*)rayclassnolist,6,"GG"},
1449: {"bnrconductor",62,(void*)bnrconductor,6,"GDGDGD0,L,p"},
1450: {"bnrconductorofchar",29,(void*)bnrconductorofchar,6,"GGp"},
1451: {"bnrdisc",62,(void*)bnrdisc0,6,"GDGDGD0,L,p"},
1452: {"bnrdisclist",99,(void*)bnrdisclist0,6,"GGDGD0,L,"},
1453: {"bnrinit",99,(void*)bnrinit0,6,"GGD0,L,p"},
1454: {"bnrisconductor",99,(void*)bnrisconductor,6,"lGDGDGp"},
1455: {"bnrisprincipal",99,(void*)isprincipalrayall,6,"GGD1,L,"},
1456: {"bnrrootnumber",99,(void*)bnrrootnumber,6,"GGD0,L,p"},
1457: {"bnrstark",99,(void*)bnrstark,6,"GGD0,L,p"},
1458: {"break",0,(void*)break0,11,"D1,L,"},
1459: {"ceil",18,(void*)gceil,2,"G"},
1460: {"centerlift",99,(void*)centerlift0,2,"GDn"},
1461: {"changevar",2,(void*)changevar,2,"GG"},
1462: {"charpoly",99,(void*)charpoly0,8,"GDnD0,L,"},
1463: {"chinese",2,(void*)chinois,4,"GG"},
1464: {"component",21,(void*)compo,2,"GL"},
1465: {"concat",99,(void*)concat,8,"GDG"},
1466: {"conj",18,(void*)gconj,2,"G"},
1467: {"conjvec",1,(void*)conjvec,2,"Gp"},
1468: {"content",18,(void*)content,4,"G"},
1469: {"contfrac",99,(void*)sfcont0,4,"GDGD0,L,"},
1470: {"contfracpnqn",18,(void*)pnqn,4,"G"},
1471: {"core",99,(void*)core0,4,"GD0,L,"},
1472: {"coredisc",99,(void*)coredisc0,4,"GD0,L,"},
1473: {"cos",1,(void*)gcos,3,"Gp"},
1474: {"cosh",1,(void*)gch,3,"Gp"},
1475: {"cotan",1,(void*)gcotan,3,"Gp"},
1476: {"denominator",18,(void*)denom,2,"G"},
1477: {"deriv",14,(void*)deriv,7,"GDn"},
1478: {"dilog",1,(void*)dilog,3,"Gp"},
1479: {"dirdiv",2,(void*)dirdiv,7,"GG"},
1480: {"direuler",99,(void*)direuler,7,"V=GGI"},
1481: {"dirmul",2,(void*)dirmul,7,"GG"},
1482: {"dirzetak",2,(void*)dirzetak,6,"GG"},
1483: {"divisors",18,(void*)divisors,4,"G"},
1484: {"divrem",2,(void*)gdiventres,1,"GG"},
1485: {"eint1",99,(void*)veceint1,3,"GDGp"},
1486: {"elladd",3,(void*)addell,5,"GGG"},
1487: {"ellak",2,(void*)akell,5,"GG"},
1488: {"ellan",23,(void*)anell,5,"GL"},
1489: {"ellap",25,(void*)ellap0,5,"GGD0,L,"},
1490: {"ellbil",99,(void*)bilhell,5,"GGGp"},
1491: {"ellchangecurve",2,(void*)coordch,5,"GG"},
1492: {"ellchangepoint",2,(void*)pointch,5,"GG"},
1493: {"elleisnum",99,(void*)elleisnum,5,"GLD0,L,p"},
1494: {"elleta",1,(void*)elleta,5,"Gp"},
1495: {"ellglobalred",18,(void*)globalreduction,5,"G"},
1496: {"ellheight",99,(void*)ellheight0,5,"GGD0,L,p"},
1497: {"ellheightmatrix",29,(void*)mathell,5,"GGp"},
1498: {"ellinit",99,(void*)ellinit0,5,"GD0,L,p"},
1499: {"ellisoncurve",20,(void*)oncurve,5,"lGG"},
1500: {"ellj",1,(void*)jell,5,"Gp"},
1501: {"elllocalred",2,(void*)localreduction,5,"GG"},
1502: {"elllseries",99,(void*)lseriesell,5,"GGDGp"},
1503: {"ellorder",2,(void*)orderell,5,"GG"},
1504: {"ellordinate",29,(void*)ordell,5,"GGp"},
1505: {"ellpointtoz",29,(void*)zell,5,"GGp"},
1506: {"ellpow",99,(void*)powell,5,"GGGp"},
1507: {"ellrootno",99,(void*)ellrootno,5,"lGDG"},
1508: {"ellsigma",99,(void*)ellsigma,5,"GGD0,L,p"},
1509: {"ellsub",99,(void*)subell,5,"GGGp"},
1510: {"elltaniyama",1,(void*)taniyama,5,"Gp"},
1511: {"elltors",99,(void*)elltors0,5,"GD0,L,p"},
1512: {"ellwp",99,(void*)ellwp0,5,"GDGD0,L,pP"},
1513: {"ellzeta",99,(void*)ellzeta,5,"GGp"},
1514: {"ellztopoint",29,(void*)pointell,5,"GGp"},
1515: {"erfc",1,(void*)gerfc,3,"Gp"},
1516: {"eta",99,(void*)eta0,3,"GD0,L,p"},
1517: {"eulerphi",18,(void*)gphi,4,"G"},
1518: {"eval",18,(void*)geval,7,"G"},
1519: {"exp",1,(void*)gexp,3,"Gp"},
1520: {"factor",99,(void*)factor0,4,"GD-1,L,"},
1521: {"factorback",99,(void*)factorback,4,"GDG"},
1522: {"factorcantor",2,(void*)factcantor,4,"GG"},
1523: {"factorff",3,(void*)factmod9,4,"GGG"},
1524: {"factorial",99,(void*)mpfactr,4,"Lp"},
1525: {"factorint",99,(void*)factorint,4,"GD0,L,"},
1526: {"factormod",25,(void*)factormod0,4,"GGD0,L,"},
1527: {"factornf",2,(void*)polfnf,6,"GG"},
1528: {"factorpadic",99,(void*)factorpadic0,7,"GGLD0,L,"},
1529: {"ffinit",99,(void*)ffinit,4,"GLDn"},
1530: {"fibonacci",11,(void*)fibo,4,"L"},
1531: {"floor",18,(void*)gfloor,2,"G"},
1532: {"for",83,(void*)forpari,11,"vV=GGI"},
1533: {"fordiv",84,(void*)fordiv,11,"vGVI"},
1534: {"forprime",83,(void*)forprime,11,"vV=GGI"},
1535: {"forstep",86,(void*)forstep,11,"vV=GGGI"},
1536: {"forsubgroup",99,(void*)forsubgroup,11,"vV=GD0,L,I"},
1537: {"forvec",87,(void*)forvec,11,"vV=GID0,L,"},
1538: {"frac",18,(void*)gfrac,2,"G"},
1539: {"galoisfixedfield",99,(void*)galoisfixedfield,6,"GGDG"},
1540: {"galoisinit",99,(void*)galoisinit,6,"GDG,"},
1541: {"galoispermtopol",2,(void*)galoispermtopol,6,"GG"},
1542: {"gamma",1,(void*)ggamma,3,"Gp"},
1543: {"gammah",1,(void*)ggamd,3,"Gp"},
1544: {"gcd",25,(void*)gcd0,4,"GGD0,L,"},
1545: {"getheap",0,(void*)getheap,11,""},
1546: {"getrand",0,(void*)getrand,11,"l"},
1547: {"getstack",0,(void*)getstack,11,"l"},
1548: {"gettime",0,(void*)gettime,11,"l"},
1549: {"hilbert",99,(void*)hil0,4,"lGGDG"},
1550: {"hyperu",99,(void*)hyperu,3,"GGGp"},
1551: {"idealadd",3,(void*)idealadd,6,"GGG"},
1552: {"idealaddtoone",99,(void*)idealaddtoone0,6,"GGDG"},
1553: {"idealappr",25,(void*)idealappr0,6,"GGD0,L,"},
1554: {"idealchinese",3,(void*)idealchinese,6,"GGG"},
1555: {"idealcoprime",3,(void*)idealcoprime,6,"GGG"},
1556: {"idealdiv",99,(void*)idealdiv0,6,"GGGD0,L,"},
1557: {"idealfactor",2,(void*)idealfactor,6,"GG"},
1558: {"idealhnf",99,(void*)idealhnf0,6,"GGDG"},
1559: {"idealintersect",3,(void*)idealintersect,6,"GGG"},
1560: {"idealinv",25,(void*)idealinv0,6,"GGD0,L,"},
1561: {"ideallist",99,(void*)ideallist0,6,"GLD4,L,"},
1562: {"ideallistarch",99,(void*)ideallistarch0,6,"GGDGD0,L,"},
1563: {"ideallog",99,(void*)zideallog,6,"GGGp"},
1564: {"idealmin",99,(void*)minideal,6,"GGGp"},
1565: {"idealmul",99,(void*)idealmul0,6,"GGGD0,L,p"},
1566: {"idealnorm",2,(void*)idealnorm,6,"GG"},
1567: {"idealpow",99,(void*)idealpow0,6,"GGGD0,L,p"},
1568: {"idealprimedec",29,(void*)primedec,6,"GGp"},
1569: {"idealprincipal",2,(void*)principalideal,6,"GG"},
1570: {"idealred",99,(void*)ideallllred,6,"GGDGp"},
1571: {"idealstar",99,(void*)idealstar0,6,"GGD1,L,"},
1572: {"idealtwoelt",99,(void*)ideal_two_elt0,6,"GGDG"},
1573: {"idealval",30,(void*)idealval,6,"lGGG"},
1574: {"ideleprincipal",29,(void*)principalidele,6,"GGp"},
1575: {"if",80,NULL,11,NULL},
1576: {"imag",18,(void*)gimag,2,"G"},
1577: {"incgam",99,(void*)incgam0,3,"GGDGp"},
1578: {"incgamc",29,(void*)incgam3,3,"GGp"},
1579: {"intformal",14,(void*)integ,7,"GDn"},
1580: {"intnum",99,(void*)intnum0,9,"V=GGID0,L,p"},
1581: {"isfundamental",18,(void*)gisfundamental,4,"G"},
1582: {"isprime",18,(void*)gisprime,4,"G"},
1583: {"ispseudoprime",18,(void*)gispsp,4,"G"},
1584: {"issquare",99,(void*)gcarrecomplet,4,"GD&"},
1585: {"issquarefree",18,(void*)gissquarefree,4,"G"},
1586: {"kronecker",2,(void*)gkronecker,4,"GG"},
1587: {"lcm",2,(void*)glcm,4,"GG"},
1588: {"length",10,(void*)glength,2,"lG"},
1589: {"lex",20,(void*)lexcmp,2,"lGG"},
1590: {"lift",99,(void*)lift0,2,"GDn"},
1591: {"lindep",99,(void*)lindep0,8,"GD0,L,p"},
1592: {"listcreate",11,(void*)listcreate,8,"L"},
1593: {"listinsert",99,(void*)listinsert,8,"GGL"},
1594: {"listkill",99,(void*)listkill,8,"vG"},
1595: {"listput",25,(void*)listput,8,"GGD0,L,"},
1596: {"listsort",99,(void*)listsort,8,"GD0,L,"},
1597: {"lngamma",1,(void*)glngamma,3,"Gp"},
1598: {"log",99,(void*)log0,3,"GD0,L,p"},
1599: {"matadjoint",18,(void*)adj,8,"G"},
1600: {"matalgtobasis",2,(void*)matalgtobasis,6,"GG"},
1601: {"matbasistoalg",2,(void*)matbasistoalg,6,"GG"},
1602: {"matcompanion",18,(void*)assmat,8,"G"},
1603: {"matdet",99,(void*)det0,8,"GD0,L,"},
1604: {"matdetint",18,(void*)detint,8,"G"},
1605: {"matdiagonal",18,(void*)diagonal,8,"G"},
1606: {"mateigen",1,(void*)eigen,8,"Gp"},
1607: {"mathess",18,(void*)hess,8,"G"},
1608: {"mathilbert",11,(void*)mathilbert,8,"L"},
1609: {"mathnf",99,(void*)mathnf0,8,"GD0,L,"},
1610: {"mathnfmod",2,(void*)hnfmod,8,"GG"},
1611: {"mathnfmodid",2,(void*)hnfmodid,8,"GG"},
1612: {"matid",11,(void*)idmat,8,"L"},
1613: {"matimage",99,(void*)matimage0,8,"GD0,L,"},
1614: {"matimagecompl",18,(void*)imagecompl,8,"G"},
1615: {"matindexrank",18,(void*)indexrank,8,"G"},
1616: {"matintersect",2,(void*)intersect,8,"GG"},
1617: {"matinverseimage",2,(void*)inverseimage,8,"GG"},
1618: {"matisdiagonal",10,(void*)isdiagonal,8,"lG"},
1619: {"matker",99,(void*)matker0,8,"GD0,L,p"},
1620: {"matkerint",99,(void*)matkerint0,8,"GD0,L,"},
1621: {"matmuldiagonal",2,(void*)matmuldiagonal,8,"GG"},
1622: {"matmultodiagonal",2,(void*)matmultodiagonal,8,"GG"},
1623: {"matpascal",99,(void*)matqpascal,8,"LDG"},
1624: {"matrank",10,(void*)rank,8,"lG"},
1625: {"matrix",49,(void*)matrice,8,"GGDVDVDI"},
1626: {"matrixqz",2,(void*)matrixqz0,8,"GG"},
1627: {"matsize",18,(void*)matsize,8,"G"},
1628: {"matsnf",99,(void*)matsnf0,8,"GD0,L,"},
1629: {"matsolve",2,(void*)gauss,8,"GG"},
1630: {"matsolvemod",99,(void*)matsolvemod0,8,"GGGD0,L,"},
1631: {"matsupplement",1,(void*)suppl,8,"Gp"},
1632: {"mattranspose",18,(void*)gtrans,8,"G"},
1633: {"max",2,(void*)gmax,1,"GG"},
1634: {"min",2,(void*)gmin,1,"GG"},
1635: {"modreverse",18,(void*)polymodrecip,6,"G"},
1636: {"moebius",18,(void*)gmu,4,"G"},
1637: {"newtonpoly",2,(void*)newtonpoly,6,"GG"},
1638: {"next",0,(void*)next0,11,"D1,L,"},
1639: {"nextprime",18,(void*)gnextprime,4,"G"},
1640: {"nfalgtobasis",2,(void*)algtobasis,6,"GG"},
1641: {"nfbasis",99,(void*)nfbasis0,6,"GD0,L,DG"},
1642: {"nfbasistoalg",2,(void*)basistoalg,6,"GG"},
1643: {"nfdetint",2,(void*)nfdetint,6,"GG"},
1644: {"nfdisc",99,(void*)nfdiscf0,6,"GD0,L,DG"},
1645: {"nfeltdiv",3,(void*)element_div,6,"GGG"},
1646: {"nfeltdiveuc",3,(void*)nfdiveuc,6,"GGG"},
1647: {"nfeltdivmodpr",4,(void*)element_divmodpr,6,"GGGG"},
1648: {"nfeltdivrem",3,(void*)nfdivres,6,"GGG"},
1649: {"nfeltmod",3,(void*)nfmod,6,"GGG"},
1650: {"nfeltmul",3,(void*)element_mul,6,"GGG"},
1651: {"nfeltmulmodpr",4,(void*)element_mulmodpr2,6,"GGGG"},
1652: {"nfeltpow",3,(void*)element_pow,6,"GGG"},
1653: {"nfeltpowmodpr",4,(void*)element_powmodpr,6,"GGGG"},
1654: {"nfeltreduce",3,(void*)element_reduce,6,"GGG"},
1655: {"nfeltreducemodpr",3,(void*)nfreducemodpr2,6,"GGG"},
1656: {"nfeltval",30,(void*)element_val,6,"lGGG"},
1657: {"nffactor",99,(void*)nffactor,6,"GG"},
1658: {"nffactormod",99,(void*)nffactormod,6,"GGG"},
1659: {"nfgaloisapply",3,(void*)galoisapply,6,"GGG"},
1660: {"nfgaloisconj",99,(void*)galoisconj0,6,"GD0,L,DGp"},
1661: {"nfhilbert",99,(void*)nfhilbert0,6,"lGGGDG"},
1662: {"nfhnf",2,(void*)nfhermite,6,"GG"},
1663: {"nfhnfmod",3,(void*)nfhermitemod,6,"GGG"},
1664: {"nfinit",99,(void*)nfinit0,6,"GD0,L,p"},
1665: {"nfisideal",20,(void*)isideal,6,"lGG"},
1666: {"nfisincl",2,(void*)nfisincl,6,"GG"},
1667: {"nfisisom",2,(void*)nfisisom,6,"GG"},
1668: {"nfkermodpr",3,(void*)nfkermodpr,6,"GGG"},
1669: {"nfmodprinit",2,(void*)nfmodprinit,6,"GG"},
1670: {"nfnewprec",1,(void*)nfnewprec,6,"Gp"},
1671: {"nfroots",99,(void*)nfroots,6,"GG"},
1672: {"nfrootsof1",1,(void*)rootsof1,6,"Gp"},
1673: {"nfsnf",2,(void*)nfsmith,6,"GG"},
1674: {"nfsolvemodpr",4,(void*)nfsolvemodpr,6,"GGGG"},
1675: {"nfsubfields",99,(void*)subfields0,6,"GDG"},
1676: {"norm",18,(void*)gnorm,2,"G"},
1677: {"norml2",18,(void*)gnorml2,2,"G"},
1678: {"numdiv",18,(void*)gnumbdiv,4,"G"},
1679: {"numerator",18,(void*)numer,2,"G"},
1680: {"numtoperm",24,(void*)permute,2,"LG"},
1681: {"omega",18,(void*)gomega,4,"G"},
1682: {"padicappr",2,(void*)apprgen9,7,"GG"},
1683: {"padicprec",20,(void*)padicprec,2,"lGG"},
1684: {"permtonum",18,(void*)permuteInv,2,"G"},
1685: {"polcoeff",99,(void*)polcoeff0,2,"GLDn"},
1686: {"polcompositum",25,(void*)polcompositum0,6,"GGD0,L,"},
1687: {"polcyclo",99,(void*)cyclo,7,"LDn"},
1688: {"poldegree",99,(void*)poldegree,7,"lGDn"},
1689: {"poldisc",99,(void*)poldisc0,7,"GDn"},
1690: {"poldiscreduced",18,(void*)reduceddiscsmith,7,"G"},
1691: {"polgalois",99,(void*)galois,6,"Gp"},
1692: {"polinterpolate",31,(void*)polint,7,"GGDGD&"},
1693: {"polisirreducible",18,(void*)gisirreducible,7,"G"},
1694: {"pollead",99,(void*)pollead,7,"GDn"},
1695: {"pollegendre",99,(void*)legendre,7,"LDn"},
1696: {"polrecip",18,(void*)polrecip,7,"G"},
1697: {"polred",99,(void*)polred0,6,"GD0,L,DGp"},
1698: {"polredabs",99,(void*)polredabs0,6,"GD0,L,p"},
1699: {"polredord",1,(void*)ordred,6,"Gp"},
1700: {"polresultant",99,(void*)polresultant0,7,"GGDnD0,L,"},
1701: {"polroots",99,(void*)roots0,7,"GD0,L,p"},
1702: {"polrootsmod",25,(void*)rootmod0,7,"GGD0,L,"},
1703: {"polrootspadic",32,(void*)rootpadic,7,"GGL"},
1704: {"polsturm",99,(void*)sturmpart,7,"lGDGDG"},
1705: {"polsubcyclo",99,(void*)subcyclo,6,"GGDn"},
1706: {"polsylvestermatrix",29,(void*)sylvestermatrix,7,"GGp"},
1707: {"polsym",21,(void*)polsym,7,"GL"},
1708: {"poltchebi",99,(void*)tchebi,7,"LDn"},
1709: {"poltschirnhaus",18,(void*)tschirnhaus,6,"G"},
1710: {"polylog",99,(void*)polylog0,3,"LGD0,L,p"},
1711: {"polzagier",99,(void*)polzag,7,"LL"},
1712: {"precision",99,(void*)precision0,2,"GD0,L,"},
1713: {"precprime",18,(void*)gprecprime,4,"G"},
1714: {"prime",11,(void*)prime,4,"L"},
1715: {"primes",11,(void*)primes,4,"L"},
1716: {"prod",47,(void*)produit,9,"V=GGIDG"},
1717: {"prodeuler",37,(void*)prodeuler,9,"V=GGIp"},
1718: {"prodinf",99,(void*)prodinf0,9,"V=GID0,L,p"},
1719: {"psi",1,(void*)gpsi,3,"Gp"},
1720: {"qfbclassno",99,(void*)qfbclassno0,4,"GD0,L,"},
1721: {"qfbcompraw",2,(void*)compraw,4,"GG"},
1722: {"qfbhclassno",18,(void*)hclassno,4,"G"},
1723: {"qfbnucomp",3,(void*)nucomp,4,"GGG"},
1724: {"qfbnupow",2,(void*)nupow,4,"GG"},
1725: {"qfbpowraw",23,(void*)powraw,4,"GL"},
1726: {"qfbprimeform",29,(void*)primeform,4,"GGp"},
1727: {"qfbred",99,(void*)qfbred0,4,"GD0,L,DGDGDG"},
1728: {"qfgaussred",18,(void*)sqred,8,"G"},
1729: {"qfjacobi",1,(void*)jacobi,8,"Gp"},
1730: {"qflll",99,(void*)qflll0,8,"GD0,L,p"},
1731: {"qflllgram",99,(void*)qflllgram0,8,"GD0,L,p"},
1732: {"qfminim",33,(void*)minim0,8,"GGGD0,L,p"},
1733: {"qfperfection",18,(void*)perf,8,"G"},
1734: {"qfsign",18,(void*)signat,8,"G"},
1735: {"quadclassunit",96,(void*)quadclassunit0,4,"GD0,L,DGp"},
1736: {"quaddisc",18,(void*)quaddisc,4,"G"},
1737: {"quadgen",18,(void*)quadgen,4,"G"},
1738: {"quadhilbert",99,(void*)quadhilbert,4,"GDGp"},
1739: {"quadpoly",99,(void*)quadpoly0,4,"GDn"},
1740: {"quadray",99,(void*)quadray,4,"GGDGp"},
1741: {"quadregulator",1,(void*)gregula,4,"Gp"},
1742: {"quadunit",1,(void*)gfundunit,4,"Gp"},
1743: {"random",0,(void*)genrand,2,"DG"},
1744: {"real",18,(void*)greal,2,"G"},
1745: {"removeprimes",0,(void*)removeprimes,4,"DG"},
1746: {"reorder",0,(void*)reorder,11,"DG"},
1747: {"return",0,(void*)return0,11,"DG"},
1748: {"rnfalgtobasis",2,(void*)rnfalgtobasis,6,"GG"},
1749: {"rnfbasis",2,(void*)rnfbasis,6,"GG"},
1750: {"rnfbasistoalg",2,(void*)rnfbasistoalg,6,"GG"},
1751: {"rnfcharpoly",99,(void*)rnfcharpoly,6,"GGGDn"},
1752: {"rnfconductor",29,(void*)rnfconductor,6,"GGp"},
1753: {"rnfdedekind",99,(void*)rnfdedekind,6,"GGG"},
1754: {"rnfdet",99,(void*)rnfdet0,6,"GGDG"},
1755: {"rnfdisc",2,(void*)rnfdiscf,6,"GG"},
1756: {"rnfeltabstorel",2,(void*)rnfelementabstorel,6,"GG"},
1757: {"rnfeltdown",2,(void*)rnfelementdown,6,"GG"},
1758: {"rnfeltreltoabs",2,(void*)rnfelementreltoabs,6,"GG"},
1759: {"rnfeltup",2,(void*)rnfelementup,6,"GG"},
1760: {"rnfequation",25,(void*)rnfequation0,6,"GGD0,L,"},
1761: {"rnfhnfbasis",2,(void*)rnfhermitebasis,6,"GG"},
1762: {"rnfidealabstorel",2,(void*)rnfidealabstorel,6,"GG"},
1763: {"rnfidealdown",2,(void*)rnfidealdown,6,"GG"},
1764: {"rnfidealhnf",2,(void*)rnfidealhermite,6,"GG"},
1765: {"rnfidealmul",2,(void*)rnfidealmul,6,"GG"},
1766: {"rnfidealnormabs",2,(void*)rnfidealnormabs,6,"GG"},
1767: {"rnfidealnormrel",2,(void*)rnfidealnormrel,6,"GG"},
1768: {"rnfidealreltoabs",2,(void*)rnfidealreltoabs,6,"GG"},
1769: {"rnfidealtwoelt",2,(void*)rnfidealtwoelement,6,"GG"},
1770: {"rnfidealup",2,(void*)rnfidealup,6,"GG"},
1771: {"rnfinit",29,(void*)rnfinitalg,6,"GGp"},
1772: {"rnfisfree",20,(void*)rnfisfree,6,"lGG"},
1773: {"rnfisnorm",99,(void*)rnfisnorm,6,"GGGD1,L,p"},
1774: {"rnfkummer",99,(void*)rnfkummer,6,"GGD0,L,p"},
1775: {"rnflllgram",99,(void*)rnflllgram,6,"GGGp"},
1776: {"rnfnormgroup",2,(void*)rnfnormgroup,6,"GG"},
1777: {"rnfpolred",29,(void*)rnfpolred,6,"GGp"},
1778: {"rnfpolredabs",99,(void*)rnfpolredabs,6,"GGD0,L,p"},
1779: {"rnfpseudobasis",2,(void*)rnfpseudobasis,6,"GG"},
1780: {"rnfsteinitz",2,(void*)rnfsteinitz,6,"GG"},
1781: {"round",99,(void*)round0,2,"GD&"},
1782: {"serconvol",2,(void*)convol,7,"GG"},
1783: {"serlaplace",18,(void*)laplace,7,"G"},
1784: {"serreverse",18,(void*)recip,7,"G"},
1785: {"setintersect",2,(void*)setintersect,8,"GG"},
1786: {"setisset",10,(void*)setisset,8,"lG"},
1787: {"setminus",2,(void*)setminus,8,"GG"},
1788: {"setrand",99,(void*)setrand,11,"lL"},
1789: {"setsearch",99,(void*)setsearch,8,"lGGD0,L,"},
1790: {"setunion",2,(void*)setunion,8,"GG"},
1791: {"shift",99,(void*)gshift,1,"GL"},
1792: {"shiftmul",99,(void*)gmul2n,1,"GL"},
1793: {"sigma",99,(void*)gsumdivk,4,"GD1,L,"},
1794: {"sign",10,(void*)gsigne,1,"lG"},
1795: {"simplify",18,(void*)simplify,2,"G"},
1796: {"sin",1,(void*)gsin,3,"Gp"},
1797: {"sinh",1,(void*)gsh,3,"Gp"},
1798: {"sizebyte",10,(void*)taille2,2,"lG"},
1799: {"sizedigit",10,(void*)gsize,2,"lG"},
1800: {"solve",37,(void*)zbrent,9,"V=GGIp"},
1801: {"sqr",18,(void*)gsqr,3,"G"},
1802: {"sqrt",1,(void*)gsqrt,3,"Gp"},
1803: {"sqrtint",1,(void*)racine,4,"Gp"},
1804: {"subgrouplist",99,(void*)subgrouplist0,6,"GD0,L,D0,L,p"},
1805: {"subst",26,(void*)gsubst,7,"GnG"},
1806: {"sum",48,(void*)somme,9,"V=GGIDG"},
1807: {"sumalt",99,(void*)sumalt0,9,"V=GID0,L,p"},
1808: {"sumdiv",22,(void*)divsum,9,"GVI"},
1809: {"suminf",27,(void*)suminf,9,"V=GIp"},
1810: {"sumpos",99,(void*)sumpos0,9,"V=GID0,L,p"},
1811: {"tan",1,(void*)gtan,3,"Gp"},
1812: {"tanh",1,(void*)gth,3,"Gp"},
1813: {"taylor",12,(void*)tayl,7,"GnP"},
1814: {"teichmuller",1,(void*)teich,3,"Gp"},
1815: {"theta",29,(void*)theta,3,"GGp"},
1816: {"thetanullk",99,(void*)thetanullk,3,"GL"},
1817: {"thue",99,(void*)thue,7,"GGDG"},
1818: {"thueinit",99,(void*)thueinit,7,"GD0,L,p"},
1819: {"trace",1,(void*)gtrace,8,"Gp"},
1820: {"truncate",99,(void*)trunc0,2,"GD&"},
1821: {"until",82,NULL,11,NULL},
1822: {"valuation",20,(void*)ggval,2,"lGG"},
1823: {"variable",18,(void*)gpolvar,2,"G"},
1824: {"vecextract",99,(void*)extract0,8,"GGDG"},
1825: {"vecmax",1,(void*)vecmax,1,"Gp"},
1826: {"vecmin",1,(void*)vecmin,1,"Gp"},
1827: {"vecsort",99,(void*)vecsort0,8,"GDGD0,L,"},
1828: {"vector",28,(void*)vecteur,8,"GDVDI"},
1829: {"vectorv",28,(void*)vvecteur,8,"GDVDI"},
1830: {"weber",99,(void*)weber0,3,"GD0,L,p"},
1831: {"while",81,NULL,11,NULL},
1832: {"zeta",1,(void*)gzeta,3,"Gp"},
1833: {"zetak",99,(void*)gzetakall,6,"GGD0,L,p"},
1834: {"zetakinit",1,(void*)initzeta,6,"Gp"},
1835: {"znlog",2,(void*)znlog,4,"GG"},
1836: {"znorder",18,(void*)order,4,"G"},
1837: {"znprimroot",18,(void*)ggener,4,"G"},
1838: {"znstar",1,(void*)znstar,4,"Gp"},
1839:
1840: /* DO NOT REMOVE THIS BLANK LINE: chname & helpsynchro depend on it */
1841: {NULL,0,NULL,0,NULL} /* sentinel */
1842: };
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to init.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / pari / src / language