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