/*******************************************************************/ /* */ /* INITIALIZING THE SYSTEM, ERRORS */ /* */ /*******************************************************************/ /* $Id: init.c,v 1.3 1999/09/24 15:28:35 karim Exp $ */ #include #include "pari.h" #include "anal.h" #ifdef _WIN32 # ifndef WINCE # include # endif #endif /* Variables statiques communes : */ FILE *pari_outfile, *errfile, *logfile, *infile; GEN *polun, *polx; GEN gnil, gzero, gun, gdeux, ghalf, polvar, gi; GEN gpi=NULL, geuler=NULL, bernzone=NULL; GEN primetab; /* private primetable */ byteptr diffptr; char *current_logfile, *current_psfile; int gp_colors[c_LAST]; int disable_color = 1, added_newline = 1, under_emacs = 0; int functions_tblsz = 135; /* size of functions_hash */ entree **varentries; jmp_buf environnement; long *ordvar; long DEBUGFILES,DEBUGLEVEL,DEBUGMEM,compatible; long prec,precdl; ulong init_opts = INIT_JMPm | INIT_SIGm; ulong top, bot, avma, memused; void *foreignHandler; /* Handler for foreign commands. */ char foreignExprSwitch = 3; /* Just some unprobable char. */ GEN (*foreignExprHandler)(char*); /* Handler for foreign expressions.*/ entree * (*foreignAutoload)(char*, long); /* Autoloader */ void (*foreignFuncFree)(entree *); /* How to free external entree. */ GEN (*gp_history_fun)(long, long, char *, char *); int (*whatnow_fun)(char *, int); void initout(void); int term_width(void); /*********************************************************************/ /* */ /* INITIALISATION DU SYSTEME */ /* */ /*********************************************************************/ static int var_not_changed; /* altered in reorder() */ static int try_to_recover = 0; static long next_bloc; static GEN cur_bloc=NULL; /* current bloc in bloc list */ static long *universal_constants; #ifdef WINCE #else static void pari_sighandler(int sig) { char *msg; switch(sig) { case SIGINT: #ifdef _WIN32 # ifdef SIGBREAK case SIGBREAK: # endif if (++win32ctrlc >= 5) _exit(3); signal(sig,pari_sighandler); return; #endif msg="user interrupt"; break; case SIGSEGV: msg="segmentation fault: bug in PARI or calling program"; break; #ifdef SIGBUS case SIGBUS: msg="bus error: bug in PARI or calling program"; break; #endif } signal(sig,pari_sighandler); err(talker,msg); } #endif #ifdef _WIN32 int win32ctrlc = 0; void dowin32ctrlc() { win32ctrlc = 0; err(talker,"user interrupt"); } #endif /* Initialize hashtable */ static void init_hashtable(entree **table, int tblsz) { entree *ep, *ep1, *last; long i, v; for (i = 0; i < tblsz; i++) { last = NULL; ep = table[i]; table[i] = NULL; for ( ; ep; ep = ep1) { ep1 = ep->next; v = EpVALENCE(ep); if (v == EpVAR || v == EpINSTALL) /* keep this one */ { if (last) last->next = ep; else table[i] = ep; last = ep; last->next = NULL; } else freeep(ep); } } } static void fill_hashtable(entree **table, entree *ep, char **helpmessage) { long n; for ( ; ep->name; ep++) { EpSETSTATIC(ep); ep->help = helpmessage? *helpmessage++: NULL; n = hashvalue(ep->name); ep->next = table[n]; table[n] = ep; ep->args = NULL; } } void init_defaults(int force) { static int done=0; if (done && !force) return; done = 1; #ifdef LONG_IS_64BIT prec=4; #else prec=5; #endif precdl = 16; compatible = NONE; DEBUGFILES = DEBUGLEVEL = DEBUGMEM = 0; current_psfile = pari_strdup("pari.ps"); current_logfile= pari_strdup("pari.log"); logfile = NULL; infile = stdin; pari_outfile = stdout; errfile = stderr; initout(); next_bloc=0; } /* does elt belong to list, after position start (excluded) ? */ static int list_isin(void **list, void *elt, int start) { long indelt=0; if (list) { while (*list) { if (indelt>start && *list==elt) return indelt; list++; indelt++; } } return -1; } static void list_prepend(void ***listptr, void *elt) { void **list=*listptr; long nbelt=0; if (list) while (list[nbelt]) nbelt++; list = (void **) gpmalloc(sizeof(void *)*(nbelt+2)); list[0]=elt; if (nbelt) { memcpy(list+1,*listptr,nbelt*sizeof(void *)); free(*listptr); } list[nbelt+1]=NULL; *listptr=list; } /* Load modlist in hashtable hash. If force == 0, do not load twice the * same list in the same hashtable, which would only destroy user variables. * As it stands keep a complete history (instead of most recent changes). */ int gp_init_entrees(module *modlist, entree **hash, int force) { static void **oldmodlist=NULL, **oldhash=NULL; if (!force) { const long indhash = list_isin(oldhash,(void *)hash,-1); if (indhash != -1 && oldmodlist[indhash]==modlist) return 0; } /* record the new pair (hash,modlist) */ list_prepend(&oldmodlist,(void *)modlist); list_prepend(&oldhash,(void *)hash); init_hashtable(hash,functions_tblsz); while (modlist && modlist->func) { fill_hashtable(hash, modlist->func, modlist->help); modlist++; } return (hash == functions_hash); } module *pari_modules = NULL; module *pari_oldmodules = NULL; module *pari_membermodules = NULL; entree **functions_hash = NULL; entree **funct_old_hash = NULL; entree **members_hash = NULL; /* add to modlist the functions in func, with helpmsg help */ void pari_addfunctions(module **modlist_p, entree *func, char **help) { module *modlist = *modlist_p; int nbmodules = 0; while (modlist && modlist->func) { nbmodules++; modlist++; } modlist = *modlist_p; *modlist_p = (module*) gpmalloc(sizeof(module)*(nbmodules+2)); if (nbmodules) { memcpy(1+ *modlist_p, modlist, sizeof(module)*nbmodules); free(modlist); } modlist = *modlist_p; modlist->func = func; modlist->help = help; modlist += nbmodules+1; modlist->func = NULL; modlist->help = NULL; } static long fix_size(long a) { /* BYTES_IN_LONG*ceil(a/BYTES_IN_LONG) */ ulong b = a+BYTES_IN_LONG - (((a-1) & (BYTES_IN_LONG-1)) + 1); if (b > VERYBIGINT) err(talker,"stack too large"); return b; } void pari_sig_init(void (*f)(int)) { #ifdef WINCE #else #ifdef SIGBUS signal(SIGBUS,f); #endif signal(SIGINT,f); #ifdef SIGBREAK signal(SIGBREAK,f); #endif signal(SIGSEGV,f); #endif } /* initialise les donnees de la bibliotheque PARI. Peut être précédée d'un * appel à pari_addfunctions si on ajoute d'autres fonctions au pool de base. */ void pari_init(long parisize, long maxprime) { long n; GEN p; init_defaults(0); if (INIT_JMP && setjmp(environnement)) { fprintferr(" *** Error in the PARI system. End of program.\n"); exit(1); } #ifndef WINCE if (INIT_SIG) pari_sig_init(pari_sighandler); #endif parisize = fix_size(parisize); #if __MWERKS__ { OSErr resultCode; Handle newHand = TempNewHandle(parisize,&resultCode); if (!newHand) err(memer); HLock(newHand); bot = (long)*newHand; } #else bot = (long) gpmalloc(parisize); #endif top = avma = memused = bot+parisize; diffptr = initprimes(maxprime); varentries = (entree**) gpmalloc((MAXVARN+1)*sizeof(entree*)); polvar = (GEN) gpmalloc((MAXVARN+1)*sizeof(long)); ordvar = (GEN) gpmalloc((MAXVARN+1)*sizeof(long)); polx = (GEN*) gpmalloc((MAXVARN+1)*sizeof(GEN)); polun = (GEN*) gpmalloc((MAXVARN+1)*sizeof(GEN)); polvar[0] = evaltyp(t_VEC) | evallg(1); for (n=0; n <= MAXVARN; n++) ordvar[n] = n; /* 2 (gnil) + 2 (gzero) + 3 (gun) + 3 (gdeux) + 3 (half) + 3 (gi) */ p = universal_constants = (long *) gpmalloc(16*sizeof(long)); gzero = p; p+=2; gnil = p; p+=2; gzero[0] = gnil[0] = evaltyp(t_INT) | evallg(2); gzero[1] = gnil[1] = evallgefint(2); gun = p; p+=3; gdeux = p; p+=3; gun[0] = gdeux[0] = evaltyp(t_INT) | evallg(3); gun[1] = gdeux[1] = evalsigne(1) | evallgefint(3); gun[2] = 1; gdeux[2]= 2; ghalf = p; p+=3; gi = p; p+=3; ghalf[0] = evaltyp(t_FRAC) | evallg(3); ghalf[1] = un; ghalf[2] = deux; gi[0] = evaltyp(t_COMPLEX) | evallg(3); gi[1] = zero; gi[2] = un; fetch_var(); /* create polx/polun[MAXVARN] */ primetab = (GEN) gpmalloc((NUMPRTBELT+2)*sizeof(long)); primetab[0] = evaltyp(t_VEC) | evallg(1); pari_addfunctions(&pari_modules, functions_basic,helpmessages_basic); functions_hash = (entree **) gpmalloc(sizeof(entree*)*functions_tblsz); for (n = 0; n < functions_tblsz; n++) functions_hash[n] = NULL; pari_addfunctions(&pari_oldmodules, oldfonctions,oldhelpmessage); funct_old_hash = (entree **) gpmalloc(sizeof(entree*)*functions_tblsz); for (n = 0; n < functions_tblsz; n++) funct_old_hash[n] = NULL; gp_init_entrees(pari_oldmodules, funct_old_hash, 1); if (new_fun_set) gp_init_entrees(pari_modules, functions_hash, 1); else gp_init_entrees(pari_oldmodules, functions_hash, 1); pari_addfunctions(&pari_membermodules, gp_member_list, NULL); members_hash = (entree **) gpmalloc(sizeof(entree*)*functions_tblsz); for (n = 0; n < functions_tblsz; n++) members_hash[n] = NULL; gp_init_entrees(pari_membermodules, members_hash, 1); gp_history_fun = NULL; whatnow_fun = NULL; manage_var(2,NULL); /* init nvar */ var_not_changed = 1; fetch_named_var("x", 0); try_to_recover=1; } void freeall() { long i; entree *ep,*ep1; while (delete_var()) /* empty */; for (i = 0; i < functions_tblsz; i++) { for (ep = functions_hash[i]; ep; ep = ep1) { ep1 = ep->next; freeep(ep); } for (ep = members_hash[i]; ep; ep = ep1) { ep1 = ep->next; freeep(ep); } } free((void*)varentries); free((void*)ordvar); free((void*)polvar); free((void*)polx[MAXVARN]); free((void*)polx); free((void*)polun); free((void*)primetab); free((void*)universal_constants); /* set first cell to 0 to inhibit recursion in all cases */ while (cur_bloc) { *cur_bloc=0; killbloc(cur_bloc); } killallfiles(1); free((void *)functions_hash); free((void *)bot); free((void *)diffptr); free(current_logfile); free(current_psfile); if (gp_history_fun) gp_history_fun(0,-1,NULL,NULL); } GEN getheap() { long m=0,l=0; GEN x; for (x = cur_bloc; x; x = (GEN)bl_prev(x)) { m++; l+=4; if (! x[0]) /* user function */ l += (strlen((char *)(x+sizeof(entree*)))) / sizeof(long); else if (x==bernzone) l += x[0]; else /* GEN */ l += taille(x); } x=cgetg(3,t_VEC); x[1]=lstoi(m); x[2]=lstoi(l); return x; } /* Return x, where: * x[-3]: adress of next bloc * x[-2]: adress of preceding bloc. * x[-1]: number of allocated blocs. * x[0..n-1]: malloc-ed memory. */ GEN newbloc(long n) { long *x = (long *) gpmalloc((n + BL_HEAD)*sizeof(long)) + BL_HEAD; bl_next(x) = 0; /* the NULL address */ bl_prev(x) = (long)cur_bloc; bl_num(x) = next_bloc++; if (n) *x = 0; /* initialize first cell to 0. See killbloc */ if (cur_bloc) bl_next(cur_bloc) = (long)x; if (DEBUGMEM) { if (!n) err(warner,"mallocing NULL object in newbloc"); if (DEBUGMEM > 2) fprintferr("new bloc, size %6ld (no %ld): %08lx\n", n, next_bloc-1, x); } return cur_bloc = x; } void killbloc0(GEN x, int inspect) { long tx,lx,l,i,j; GEN p1; if (!x || isonstack(x)) return; if (bl_next(x)) bl_prev(bl_next(x)) = bl_prev(x); else { cur_bloc = (GEN)bl_prev(x); next_bloc = bl_num(x); } if (bl_prev(x)) bl_next(bl_prev(x)) = bl_next(x); if (DEBUGMEM > 2) fprintferr("killing bloc (no %ld): %08lx\n", bl_num(x), x); if (inspect) { /* FIXME: SIGINT should be blocked at this point */ tx=typ(x); /* if x is not a GEN, we will have tx=0 */ if (is_vec_t(tx)) { lx = lg(x); for (i=1;i1) { l=lg(x[1]); if (l>1) for (i=1;i=lg(y)) return gcopy(x); p1=(GEN)y[vx]; if (!signe(x)) { vy=gvar(p1); if (vy>MAXVARN) err(changer1); z=gcopy(x); setvarn(z,vy); return z; } av=avma; p2=changevar((GEN)x[lx-1],y); for (i=lx-2; i>=2; i--) { p2 = gmul(p2,p1); p2 = gadd(p2, changevar((GEN)x[i],y)); } if (tx==t_SER) { p2 = gadd(p2, ggrando(p1,lx-2)); if (valp(x)) p2 = gmul(gpuigs(p1,valp(x)), p2); } return gerepileupto(av,p2); } z=cgetg(lx,tx); for (i=1; i= nvar) err(talker,"variable out of range in reorder"); /* check if x is a permutation */ if (t1[i]) err(talker,"duplicated indeterminates in reorder"); t1[i] = 1; } qsort(varsort,lx,sizeof(int),(QSCOMP)pari_compare_int); for (n=0; nnext; switch(EpVALENCE(ep)) { case EpVAR: while (pop_val_if_newer(ep,listloc)) /* empty */; break; case EpNEW: kill_from_hashlist(ep); break; case EpUSER: case EpALIAS: case EpMEMBER: if (bl_num(ep->value) >= listloc) { gunclone((GEN)ep->value); ep->value = (void*)initial_value(ep); kill_from_hashlist(ep); } } } #if 0 /* This causes SEGV on lists and GP-2.0 vectors: internal component is * destroyed while global object is not updated. Two solutions: * - comment it out: should not be a big memory problem except for huge * vec. components. Has the added advantadge that the results computed so * far are not lost. * * - tag every variable whose component has been modified in the last * cycle. Untag it at the begining of each cycle. Maybe this should be * done. But do we really want to destroy a huge global vector if one of * its components was modified before the error ? (we don't copy the whole * thing anymore). K.B. */ { GEN y; for (x = cur_bloc; x && bl_num(x) >= listloc; x = y) { y = (GEN)bl_prev(x); if (x != gpi && x != geuler && x != bernzone) killbloc(x); } } #endif try_to_recover=1; #ifndef WINCE signal(SIGINT, sigfun); #endif } void disable_dbg(long val) { static long oldval = -1; if (val < 0) { if (oldval >= 0) { DEBUGLEVEL = oldval; oldval = -1; } } else if (DEBUGLEVEL) { oldval = DEBUGLEVEL; DEBUGLEVEL = val; } } void err_recover(long numerr) { pari_outfile=stdout; errfile=stderr; disable_dbg(-1); if (pariErr->die) pariErr->die(); /* Caller wants to catch exceptions? */ fprintferr("\n"); flusherr(); if (!environnement) exit(1); /* reclaim memory stored in "blocs" */ if (try_to_recover) recover(1); /* allocate _after_ recover (otherwise we may inspect freed memory) */ if (numerr==errpile) (void)allocatemoremem(0); longjmp(environnement, numerr); } #define MAX_PAST 25 #define STR_LEN 20 /* Outputs a beautiful error message * msg is errmessage to print. * s points to the offending chars. * entry tells how much we can go back from s[0]. */ static void errcontext(char *msg, char *s, char *entry) { char *prefix = " *** "; int past = (s-entry); char str[STR_LEN + 2]; char *buf = gpmalloc(strlen(msg) + MAX_PAST + 5), *t = buf; sprintf(t,"%s: ", msg); if (past <= 0) past = 0; else { t += strlen(t); if (past > MAX_PAST) { past=MAX_PAST; strcpy(t, "..."); t += 3; } strncpy(t, s - past, past); t[past] = 0; } t = str; if (!past) *t++ = ' '; strncpy(t, s, STR_LEN); t[STR_LEN] = 0; print_prefixed_text(buf, prefix, str); free(buf); } #define op_err(ap, op) {\ long _x = va_arg(ap, long);\ long _y = va_arg(ap, long);\ (pariputsf(" %s %s %s.",type_name(_x),(op),type_name(_y)));\ } VOLATILE void err(long numerr, ...) { char s[128], *ch1, ret = 0; PariOUT *out = pariOut; va_list ap; va_start(ap,numerr); if (!added_newline) { pariputc('\n'); added_newline=1; } pariflush(); pariOut = pariErr; pariflush(); term_color(c_ERR); if (numerr < talker) { strcpy(s, errmessage[numerr]); switch (numerr) { case obsoler: ch1 = va_arg(ap,char *); errcontext(s,ch1,va_arg(ap,char *)); if (whatnow_fun) { print_text("For full compatibility with GP 1.39, type \"default(compatible,3)\" (you can also set \"compatible = 3\" in your GPRC file)"); pariputc('\n'); term_color(c_NONE); ch1 = va_arg(ap,char *); whatnow_fun(ch1, - va_arg(ap,int)); } break; case openfiler: sprintf(s+strlen(s), "%s file", va_arg(ap,char*)); ch1 = va_arg(ap,char *); errcontext(s,ch1,ch1); break; case talker2: case member: strcat(s,va_arg(ap, char*)); /* fall through */ default: ch1 = va_arg(ap,char *); errcontext(s,ch1,va_arg(ap,char *)); } } else { pariputsf(" *** %s", errmessage[numerr]); switch (numerr) { case talker: ch1=va_arg(ap, char*); vpariputs(ch1,ap); pariputs(".\n"); break; case impl: ch1=va_arg(ap, char*); pariputsf(" %s is not yet implemented.",ch1); break; case breaker: case typeer: case mattype1: case overwriter: case accurer: case infprecer: case negexper: case polrationer: case funder2: case constpoler: case notpoler: case redpoler: case zeropoler: case consister: case flagerr: pariputsf(" %s.",va_arg(ap, char*)); break; case bugparier: pariputsf(" %s, please report",va_arg(ap, char*)); break; case assigneri: case assignerf: op_err(ap, "-->"); break; case gadderi: case gadderf: op_err(ap, "+"); break; case gmuleri: case gmulerf: op_err(ap, "*"); break; case gdiveri: case gdiverf: op_err(ap, "/"); break; /* the following 4 are only warnings (they return) */ case warnmem: case warner: pariputc(' '); ch1=va_arg(ap, char*); vpariputs(ch1,ap); pariputs(".\n"); ret = 1; break; case warnprec: vpariputs(" %s; new prec = %ld\n",ap); ret = 1; break; case warnfile: ch1=va_arg(ap, char*); pariputsf(" %s: %s", ch1, va_arg(ap, char*)); } } term_color(c_NONE); va_end(ap); pariOut = out; if (ret) { flusherr(); return; } err_recover(numerr); exit(1); /* not reached */ } #undef op_err /*******************************************************************/ /* */ /* STACK MANAGEMENT */ /* */ /*******************************************************************/ /* Inhibit some area gerepile-wise: declare it to be a non recursive * type, of length l. Thus gerepile won't inspect the zone, just copy it. * For the following situation: * z = cgetg(t,a); garbage of length l; * for (i=1; i=0; i--) { *(gptr[i]) = forcecopy(l[i]); gunclone(l[i]); } free(l); } void gerepilemanycoeffs(long av, GEN x, long n) { long i; /* copy objects */ for (i=0; i=0; i--) { GEN p1 = (GEN)x[i]; x[i] = (long)forcecopy(p1); gunclone(p1); } } /* Takes an array of pointers to GENs, of length n. * Cleans up the stack between av and tetpil, updating those GENs. */ void gerepilemanysp(long av, long tetpil, GEN* gptr[], long n) { const long av2 = avma, dec = av-tetpil; long i; (void)gerepile(av,tetpil,NULL); for (i=0; i= (ulong)av2) *g1 += dec; /* Update address if in stack */ else if (*g1 >=(ulong)av) err(gerper); } } } /* Takes an array of GENs (casted to longs), of length n. Cleans up the * stack between av and tetpil, and update those GENs. */ void gerepilemanyvec(long av, long tetpil, long *g, long n) { const long av2 = avma, dec = av-tetpil; long i; (void)gerepile(av,tetpil,NULL); for (i=0; i= (ulong)av2) *g += dec;/* Update addresses if in stack */ else if ((ulong)*g >= (ulong)av) err(gerper); } } GEN gerepileupto(long av, GEN q) { if (!isonstack(q)) { avma=av; return q; } /* universal object */ /* empty garbage */ if ((ulong)av <= (ulong)q) return q; /* The garbage is only empty when av==q. It's probably a mistake if * av < q. But "temporary variables" from sumiter are a problem since * ep->values are returned as-is by identifier() and they can be in the * stack: if we put a gerepileupto in lisseq(), we get an error. Maybe add, * if (DEBUGMEM) err(warner,"av>q in gerepileupto") ??? */ /* Beware: (long)(q+i) --> ((long)q)+i*sizeof(long) */ return gerepile(av, (long) (q+lg(q)), q); } /* internal */ GEN gerepileuptoleaf(long av, GEN q) { long i; GEN q0; if (!isonstack(q) || av==(long)q) { avma=av; return q; } i=lg(q); avma = (long)(((GEN)av) - i); q0 = (GEN)avma; while (--i >= 0) q0[i]=q[i]; return q0; } /* internal */ GEN gerepileuptoint(long av, GEN q) { if (!isonstack(q) || av==(long)q) { avma=av; return q; } avma = (long)icopy_av(q, (GEN)av); return (GEN)avma; } /* check that x and all its components are out of stack, or have been * created after av */ int ok_for_gerepileupto(long r, GEN x) { long i,lx = lg(x),tx = typ(x); if (! is_recursive_t(tx)) return !isonstack(x) || x <= (GEN)r; if (x > (GEN)r) { err(warner,"bad object %Z\n",x); return 0; } lx = lg(x); if (tx==t_POL || tx==t_LIST) lx = lgef(x); for (i=lontyp[tx]; iltop in gerepile"); if ((ulong)q>=(ulong)avma && (ulong)q<(ulong)tetpil) q = (GEN) (((long)q) + dec); #if 1 for (ll=(GEN)av, a=(GEN)tetpil; a > (GEN)avma; ) *--ll= *--a; avmb = (long)ll; #else /* slower */ ll = (GEN)(avmb=avma+dec); a = (GEN)avma; for (i=((tetpil-avma)>>TWOPOTBYTES_IN_LONG)-1; i>=0; i--) ll[i] = a[i]; #endif while (ll < (GEN)av) { const long tl=typ(ll); if (! is_recursive_t(tl)) { ll+=lg(ll); continue; } a = ll+lontyp[tl]; if (tl==t_POL) { b=ll+lgef(ll); ll+=lg(ll); } else { ll+=lg(ll); b=ll; } for ( ; a= (ulong)avma) { if ((ulong)*a < (ulong)tetpil) *a += dec; else err(gerper); } } avma = avmb; return q; } long allocatemoremem(ulong newsize) { long sizeold = top - bot, newbot; if (!newsize) { newsize = sizeold << 1; err(warner,"doubling stack size; new stack = %lu",newsize); } else if ((long)newsize < 0) err(talker,"required stack memory too small"); /* can't do bot = malloc directly, in case we lack memory */ newsize = fix_size(newsize); newbot = (long) gpmalloc(newsize); free((void*)bot); bot = newbot; memused = avma = top = bot + newsize; return newsize; } /* alternate stack management routine */ stackzone * switch_stack(stackzone *z, long n) { if (!z) { /* create parallel stack */ long size = n*sizeof(long) + sizeof(stackzone); z = (stackzone*) gpmalloc(size); z->zonetop = ((long)z) + size; return z; } if (n) { /* switch to parallel stack */ z->bot = bot; z->top = top; z->avma = avma; z->memused = memused; bot = (long) (z+1); top = z->zonetop; avma = top; memused = (ulong)-1; } else { /* back to normalcy */ bot = z->bot; top = z->top; avma = z->avma; memused = z->memused; } return NULL; } #if 0 /* for a specific broken machine (readline not correctly installed) */ char *xmalloc(long x) { return malloc(x); } char *xrealloc(char *c,long x) { return realloc(c,x); } #endif char* gpmalloc(size_t bytes) { char *tmp; if (bytes) { tmp = (char *) malloc(bytes); if (!tmp) err(memer); return tmp; } if (DEBUGMEM) err(warner,"mallocing NULL object"); return NULL; } #if __MWERKS__ static void * macrealloc(void *p, size_t newsize, size_t oldsize) { char *q = gpmalloc(newsize), *qq = q, *pp = p; int l = newsize > oldsize ? oldsize : newsize; while (l--) *qq++ = *pp++; free(p); return q; } #endif char* gprealloc(void *pointer, size_t newsize, size_t oldsize) { char *tmp; if (!pointer) tmp = (char *) malloc(newsize); #if __MWERKS__ else tmp = (char *) macrealloc(pointer,newsize,oldsize); #else else tmp = (char *) realloc(pointer,newsize); #endif if (!tmp) err(memer,oldsize); return tmp; } #ifdef MEMSTEP void checkmemory(GEN z) { if (DEBUGMEM && memused != (ulong)-1 && ((GEN)memused > z + MEMSTEP || z > (GEN)memused + MEMSTEP)) { memused=(ulong)z; #if MEMSTEP >= 1048576 fprintferr("...%4.0lf Mbytes used\n",(top-memused)/1048576.); #else fprintferr("...%5.1lf Mbytes used\n",(top-memused)/1048576.); #endif } } #endif /*******************************************************************/ /* */ /* TIMER */ /* */ /*******************************************************************/ #define MAX_TIMER 3 #ifdef WINCE static long timer_proto(int i) { static DWORD oldticks[MAX_TIMER]; DWORD ticks = GetTickCount(); DWORD delay = ticks - oldticks[i]; oldticks[i] = ticks; return delay; } #elif defined(macintosh) # include static long timer_proto(int i) { static long oldticks[MAX_TIMER]; long ticks = TickCount(), delay = ticks - oldticks[i]; oldticks[i] = ticks; return 50 * delay / 3; } #elif USE_TIMES # include # include static long timer_proto(int i) { static clock_t oldticks[MAX_TIMER]; struct tms t; long delay; times(&t); delay = (long)((t.tms_utime - oldticks[i]) * (1000. / CLK_TCK)); oldticks[i] = t.tms_utime; return delay; } #elif USE_GETRUSAGE # include # include static long timer_proto(int i) { static long oldmusec[MAX_TIMER],oldsec[MAX_TIMER]; struct rusage r; struct timeval t; long delay; getrusage(0,&r); t=r.ru_utime; delay = 1000 * (t.tv_sec - oldsec[i]) + (t.tv_usec - oldmusec[i]) / 1000; oldmusec[i] = t.tv_usec; oldsec[i] = t.tv_sec; return delay; } #elif USE_FTIME # include static long timer_proto(int i) { static long oldmsec[MAX_TIMER],oldsec[MAX_TIMER]; struct timeb t; long delay; ftime(&t); delay = 1000 * (t.time - oldsec[i]) + (t.millitm - oldmsec[i]); oldmsec[i] = t.millitm; oldsec[i] = t.time; return delay; } #else # include # ifndef CLOCKS_PER_SEC # define CLOCKS_PER_SEC 1000000 /* may be false on YOUR system */ # endif static long timer_proto(int i) { static clock_t oldclocks[MAX_TIMER]; clock_t t = clock(); long delay = (long)((t-oldclocks[i]) * 1000. / CLOCKS_PER_SEC); oldclocks[i] = t; return delay; } #endif long gptimer() { return timer_proto(0); } long timer() { return timer_proto(1); } long timer2() { return timer_proto(2); } void msgtimer(char *format, ...) { va_list args; PariOUT *out = pariOut; pariOut = pariErr; pariputs("Time "); va_start(args, format); vpariputs(format,args); va_end(args); pariputsf(": %ld\n",timer2()); pariflush(); pariOut = out; } /*******************************************************************/ /* */ /* FUNCTIONS KNOWN TO THE ANALYZER */ /* */ /*******************************************************************/ void alias0(char *s, char *old); GEN break0(long n); GEN next0(long n); GEN return0(GEN x); GEN geni(void) { return gi; } /* List of GP functions: * --------------------- * Format (struct entree) : * char *name : name (under GP). * ulong valence : used to form arg list, now often handled by code. * void *value : For PREDEFINED FUNCTIONS: C function to call. * For USER FUNCTIONS: pointer to defining data (bloc) = * entree*: NULL, list of entree (arguments), NULL * char* : function text * long menu : which help section do we belong (See below). * char *code : argument list (See below). * entree *next : next entree (init to NULL, used in hashing code). * char *help : short help text (init to NULL). * void *args : For USER FUNCTIONS: default arguments (NULL terminated). * For VARIABLES: (esp. loop indexes): push_val history. * (while processing a loop, ep->value may not be a bloc) * menu: * ----- * 1: Standard monadic or dyadic OPERATORS * 2: CONVERSIONS and similar elementary functions * 3: TRANSCENDENTAL functions * 4: NUMBER THEORETICAL functions * 5: Functions related to ELLIPTIC CURVES * 6: Functions related to general NUMBER FIELDS * 7: POLYNOMIALS and power series * 8: Vectors, matrices, LINEAR ALGEBRA and sets * 9: SUMS, products, integrals and similar functions * 10: GRAPHIC functions * 11: PROGRAMMING under GP * * code: describe function prototype. NULL = use valence instead. * ----- * Arguments: * I input position (to be processed with lisexpr or lisseq). * G GEN * L long * S symbol (i.e GP function name) * V variable (same as S, but valence must equal EpVAR/EpGVAR) * n variable number * & *GEN * F Fake *GEN (function requires a *GEN, but we don't use the resulting GEN) * f Fake *long * p real precision (prec for the C library) * P series precision (precdl dor the C library) * r raw input (treated as a string without quotes). * Quoted args are copied as strings. Stops at first unquoted ')' or ','. * Special chars can be quoted using '\'. Ex : aa"b\n)"c => "aab\n)c". * s expanded string. Example: pi"x"2 yields "3.142x2". * The unquoted components can be of any pari type (converted according to * the current output format) * s* any number of strings (see s) * s*p idem, setting prettyp=1 * s*t idem, in TeX format. * D Has a default value. Format is "Dvalue,type," (the ending comma is * mandatory). Ex: D0,L, (arg is long, 0 by default). * Special syntax: * if type = G, &, I or V: D[G&IV] all send NULL. * if type = v: Dn sends -1. * * The user-given args are read first, then completed by the defaults * * Return type (first char or immediately after 'x'): GEN by default, otherwise * l Return long * v Return void * * Syntax requirements: * = Separator '=' required. * * Origin: * x Installed foreign function. Put the ep of the function as the * first argument, fill the rest with PARI arguments, * then call installedHandler with these arguments. * Should be the first char in the code. * **************************************************************************** * If new codes are added, change identifier and skipidentifier. * * Currently the following functions have no code word: * 'O' 50, 'if' 80, 'until' 82, 'while' 81, 'global' 88, * * Valence 0 reserved for functions without mandatory args. * Valence 99 reserved for codes which do not correspond 1-to-1 to valences. * Any other valence (what to do with 0?) should correspond to exactly * one code. */ entree functions_basic[]={ {"Euler",0,(void*)mpeuler,3,"p"}, {"I",0,(void*)geni,2,""}, {"List",0,(void*)gtolist,2,"DG"}, {"Mat",0,(void*)gtomat,2,"DG"}, {"Mod",25,(void*)Mod0,2,"GGD0,L,"}, {"O",50,NULL,7,NULL}, {"Pi",0,(void*)mppi,3,"p"}, {"Pol",14,(void*)gtopoly,2,"GDn"}, {"Polrev",14,(void*)gtopolyrev,2,"GDn"}, {"Qfb",99,(void*)Qfb0,2,"GGGDGp"}, {"Ser",14,(void*)gtoser,2,"GDn"}, {"Set",0,(void*)gtoset,2,"DG"}, {"Str",0,(void*)strtoGENstr,2,"D\"\",s,D0,L,"}, {"Vec",0,(void*)gtovec,2,"DG"}, {"abs",1,(void*)gabs,3,"Gp"}, {"acos",1,(void*)gacos,3,"Gp"}, {"acosh",1,(void*)gach,3,"Gp"}, {"addprimes",0,(void*)addprimes,4,"DG"}, {"agm",29,(void*)agm,3,"GGp"}, {"algdep",99,(void*)algdep0,8,"GLD0,L,p"}, {"alias",99,(void*)alias0,11,"vrr"}, {"arg",1,(void*)garg,3,"Gp"}, {"asin",1,(void*)gasin,3,"Gp"}, {"asinh",1,(void*)gash,3,"Gp"}, {"atan",1,(void*)gatan,3,"Gp"}, {"atanh",1,(void*)gath,3,"Gp"}, {"bernfrac",11,(void*)bernfrac,3,"L"}, {"bernreal",99,(void*)bernreal,3,"Lp"}, {"bernvec",11,(void*)bernvec,3,"L"}, {"besseljh",29,(void*)jbesselh,3,"GGp"}, {"besselk",99,(void*)kbessel0,3,"GGD0,L,p"}, {"bestappr",2,(void*)bestappr,4,"GG"}, {"bezout",2,(void*)vecbezout,4,"GG"}, {"bezoutres",2,(void*)vecbezoutres,4,"GG"}, {"bigomega",18,(void*)gbigomega,4,"G"}, {"binary",18,(void*)binaire,2,"G"}, {"binomial",21,(void*)binome,4,"GL"}, {"bittest",2,(void*)gbittest,2,"GG"}, {"bnfcertify",10,(void*)certifybuchall,6,"lG"}, {"bnfclassunit",99,(void*)bnfclassunit0,6,"GD0,L,DGp"}, {"bnfclgp",99,(void*)classgrouponly,6,"GDGp"}, {"bnfdecodemodule",2,(void*)decodemodule,6,"GG"}, {"bnfinit",91,(void*)bnfinit0,6,"GD0,L,DGp"}, {"bnfisintnorm",99,(void*)bnfisintnorm,6,"GG"}, {"bnfisnorm",99,(void*)bnfisnorm,6,"GGD1,L,p"}, {"bnfisprincipal",99,(void*)isprincipalall,6,"GGD1,L,"}, {"bnfissunit",99,(void*)bnfissunit,6,"GGG"}, {"bnfisunit",2,(void*)isunit,6,"GG"}, {"bnfmake",1,(void*)bnfmake,6,"Gp"}, {"bnfnarrow",18,(void*)buchnarrow,6,"G"}, {"bnfreg",99,(void*)regulator,6,"GDGp"}, {"bnfsignunit",18,(void*)signunits,6,"G"}, {"bnfsunit",99,(void*)bnfsunit,6,"GGp"}, {"bnfunit",1,(void*)buchfu,6,"Gp"}, {"bnrL1",99,(void*)bnrL1,6,"GD0,L,p"}, {"bnrclass",99,(void*)bnrclass0,6,"GGD0,L,p"}, {"bnrclassno",2,(void*)rayclassno,6,"GG"}, {"bnrclassnolist",2,(void*)rayclassnolist,6,"GG"}, {"bnrconductor",62,(void*)bnrconductor,6,"GDGDGD0,L,p"}, {"bnrconductorofchar",29,(void*)bnrconductorofchar,6,"GGp"}, {"bnrdisc",62,(void*)bnrdisc0,6,"GDGDGD0,L,p"}, {"bnrdisclist",99,(void*)bnrdisclist0,6,"GGDGD0,L,"}, {"bnrinit",99,(void*)bnrinit0,6,"GGD0,L,p"}, {"bnrisconductor",99,(void*)bnrisconductor,6,"lGDGDGp"}, {"bnrisprincipal",99,(void*)isprincipalrayall,6,"GGD1,L,"}, {"bnrrootnumber",99,(void*)bnrrootnumber,6,"GGD0,L,p"}, {"bnrstark",99,(void*)bnrstark,6,"GGD0,L,p"}, {"break",0,(void*)break0,11,"D1,L,"}, {"ceil",18,(void*)gceil,2,"G"}, {"centerlift",99,(void*)centerlift0,2,"GDn"}, {"changevar",2,(void*)changevar,2,"GG"}, {"charpoly",99,(void*)charpoly0,8,"GDnD0,L,"}, {"chinese",2,(void*)chinois,4,"GG"}, {"component",21,(void*)compo,2,"GL"}, {"concat",99,(void*)concat,8,"GDG"}, {"conj",18,(void*)gconj,2,"G"}, {"conjvec",1,(void*)conjvec,2,"Gp"}, {"content",18,(void*)content,4,"G"}, {"contfrac",99,(void*)sfcont0,4,"GDGD0,L,"}, {"contfracpnqn",18,(void*)pnqn,4,"G"}, {"core",99,(void*)core0,4,"GD0,L,"}, {"coredisc",99,(void*)coredisc0,4,"GD0,L,"}, {"cos",1,(void*)gcos,3,"Gp"}, {"cosh",1,(void*)gch,3,"Gp"}, {"cotan",1,(void*)gcotan,3,"Gp"}, {"denominator",18,(void*)denom,2,"G"}, {"deriv",14,(void*)deriv,7,"GDn"}, {"dilog",1,(void*)dilog,3,"Gp"}, {"dirdiv",2,(void*)dirdiv,7,"GG"}, {"direuler",99,(void*)direuler,7,"V=GGI"}, {"dirmul",2,(void*)dirmul,7,"GG"}, {"dirzetak",2,(void*)dirzetak,6,"GG"}, {"divisors",18,(void*)divisors,4,"G"}, {"divrem",2,(void*)gdiventres,1,"GG"}, {"eint1",99,(void*)veceint1,3,"GDGp"}, {"elladd",3,(void*)addell,5,"GGG"}, {"ellak",2,(void*)akell,5,"GG"}, {"ellan",23,(void*)anell,5,"GL"}, {"ellap",25,(void*)ellap0,5,"GGD0,L,"}, {"ellbil",99,(void*)bilhell,5,"GGGp"}, {"ellchangecurve",2,(void*)coordch,5,"GG"}, {"ellchangepoint",2,(void*)pointch,5,"GG"}, {"elleisnum",99,(void*)elleisnum,5,"GLD0,L,p"}, {"elleta",1,(void*)elleta,5,"Gp"}, {"ellglobalred",18,(void*)globalreduction,5,"G"}, {"ellheight",99,(void*)ellheight0,5,"GGD0,L,p"}, {"ellheightmatrix",29,(void*)mathell,5,"GGp"}, {"ellinit",99,(void*)ellinit0,5,"GD0,L,p"}, {"ellisoncurve",20,(void*)oncurve,5,"lGG"}, {"ellj",1,(void*)jell,5,"Gp"}, {"elllocalred",2,(void*)localreduction,5,"GG"}, {"elllseries",99,(void*)lseriesell,5,"GGDGp"}, {"ellorder",2,(void*)orderell,5,"GG"}, {"ellordinate",29,(void*)ordell,5,"GGp"}, {"ellpointtoz",29,(void*)zell,5,"GGp"}, {"ellpow",99,(void*)powell,5,"GGGp"}, {"ellrootno",99,(void*)ellrootno,5,"lGDG"}, {"ellsigma",99,(void*)ellsigma,5,"GGD0,L,p"}, {"ellsub",99,(void*)subell,5,"GGGp"}, {"elltaniyama",1,(void*)taniyama,5,"Gp"}, {"elltors",99,(void*)elltors0,5,"GD0,L,p"}, {"ellwp",99,(void*)ellwp0,5,"GDGD0,L,pP"}, {"ellzeta",99,(void*)ellzeta,5,"GGp"}, {"ellztopoint",29,(void*)pointell,5,"GGp"}, {"erfc",1,(void*)gerfc,3,"Gp"}, {"eta",99,(void*)eta0,3,"GD0,L,p"}, {"eulerphi",18,(void*)gphi,4,"G"}, {"eval",18,(void*)geval,7,"G"}, {"exp",1,(void*)gexp,3,"Gp"}, {"factor",99,(void*)factor0,4,"GD-1,L,"}, {"factorback",99,(void*)factorback,4,"GDG"}, {"factorcantor",2,(void*)factcantor,4,"GG"}, {"factorff",3,(void*)factmod9,4,"GGG"}, {"factorial",99,(void*)mpfactr,4,"Lp"}, {"factorint",99,(void*)factorint,4,"GD0,L,"}, {"factormod",25,(void*)factormod0,4,"GGD0,L,"}, {"factornf",2,(void*)polfnf,6,"GG"}, {"factorpadic",99,(void*)factorpadic0,7,"GGLD0,L,"}, {"ffinit",99,(void*)ffinit,4,"GLDn"}, {"fibonacci",11,(void*)fibo,4,"L"}, {"floor",18,(void*)gfloor,2,"G"}, {"for",83,(void*)forpari,11,"vV=GGI"}, {"fordiv",84,(void*)fordiv,11,"vGVI"}, {"forprime",83,(void*)forprime,11,"vV=GGI"}, {"forstep",86,(void*)forstep,11,"vV=GGGI"}, {"forsubgroup",99,(void*)forsubgroup,11,"vV=GD0,L,I"}, {"forvec",87,(void*)forvec,11,"vV=GID0,L,"}, {"frac",18,(void*)gfrac,2,"G"}, {"galoisfixedfield",99,(void*)galoisfixedfield,6,"GGDG"}, {"galoisinit",99,(void*)galoisinit,6,"GDG,"}, {"galoispermtopol",2,(void*)galoispermtopol,6,"GG"}, {"gamma",1,(void*)ggamma,3,"Gp"}, {"gammah",1,(void*)ggamd,3,"Gp"}, {"gcd",25,(void*)gcd0,4,"GGD0,L,"}, {"getheap",0,(void*)getheap,11,""}, {"getrand",0,(void*)getrand,11,"l"}, {"getstack",0,(void*)getstack,11,"l"}, {"gettime",0,(void*)gettime,11,"l"}, {"hilbert",99,(void*)hil0,4,"lGGDG"}, {"hyperu",99,(void*)hyperu,3,"GGGp"}, {"idealadd",3,(void*)idealadd,6,"GGG"}, {"idealaddtoone",99,(void*)idealaddtoone0,6,"GGDG"}, {"idealappr",25,(void*)idealappr0,6,"GGD0,L,"}, {"idealchinese",3,(void*)idealchinese,6,"GGG"}, {"idealcoprime",3,(void*)idealcoprime,6,"GGG"}, {"idealdiv",99,(void*)idealdiv0,6,"GGGD0,L,"}, {"idealfactor",2,(void*)idealfactor,6,"GG"}, {"idealhnf",99,(void*)idealhnf0,6,"GGDG"}, {"idealintersect",3,(void*)idealintersect,6,"GGG"}, {"idealinv",25,(void*)idealinv0,6,"GGD0,L,"}, {"ideallist",99,(void*)ideallist0,6,"GLD4,L,"}, {"ideallistarch",99,(void*)ideallistarch0,6,"GGDGD0,L,"}, {"ideallog",99,(void*)zideallog,6,"GGGp"}, {"idealmin",99,(void*)minideal,6,"GGGp"}, {"idealmul",99,(void*)idealmul0,6,"GGGD0,L,p"}, {"idealnorm",2,(void*)idealnorm,6,"GG"}, {"idealpow",99,(void*)idealpow0,6,"GGGD0,L,p"}, {"idealprimedec",29,(void*)primedec,6,"GGp"}, {"idealprincipal",2,(void*)principalideal,6,"GG"}, {"idealred",99,(void*)ideallllred,6,"GGDGp"}, {"idealstar",99,(void*)idealstar0,6,"GGD1,L,"}, {"idealtwoelt",99,(void*)ideal_two_elt0,6,"GGDG"}, {"idealval",30,(void*)idealval,6,"lGGG"}, {"ideleprincipal",29,(void*)principalidele,6,"GGp"}, {"if",80,NULL,11,NULL}, {"imag",18,(void*)gimag,2,"G"}, {"incgam",99,(void*)incgam0,3,"GGDGp"}, {"incgamc",29,(void*)incgam3,3,"GGp"}, {"intformal",14,(void*)integ,7,"GDn"}, {"intnum",99,(void*)intnum0,9,"V=GGID0,L,p"}, {"isfundamental",18,(void*)gisfundamental,4,"G"}, {"isprime",18,(void*)gisprime,4,"G"}, {"ispseudoprime",18,(void*)gispsp,4,"G"}, {"issquare",99,(void*)gcarrecomplet,4,"GD&"}, {"issquarefree",18,(void*)gissquarefree,4,"G"}, {"kronecker",2,(void*)gkronecker,4,"GG"}, {"lcm",2,(void*)glcm,4,"GG"}, {"length",10,(void*)glength,2,"lG"}, {"lex",20,(void*)lexcmp,2,"lGG"}, {"lift",99,(void*)lift0,2,"GDn"}, {"lindep",99,(void*)lindep0,8,"GD0,L,p"}, {"listcreate",11,(void*)listcreate,8,"L"}, {"listinsert",99,(void*)listinsert,8,"GGL"}, {"listkill",99,(void*)listkill,8,"vG"}, {"listput",25,(void*)listput,8,"GGD0,L,"}, {"listsort",99,(void*)listsort,8,"GD0,L,"}, {"lngamma",1,(void*)glngamma,3,"Gp"}, {"log",99,(void*)log0,3,"GD0,L,p"}, {"matadjoint",18,(void*)adj,8,"G"}, {"matalgtobasis",2,(void*)matalgtobasis,6,"GG"}, {"matbasistoalg",2,(void*)matbasistoalg,6,"GG"}, {"matcompanion",18,(void*)assmat,8,"G"}, {"matdet",99,(void*)det0,8,"GD0,L,"}, {"matdetint",18,(void*)detint,8,"G"}, {"matdiagonal",18,(void*)diagonal,8,"G"}, {"mateigen",1,(void*)eigen,8,"Gp"}, {"mathess",18,(void*)hess,8,"G"}, {"mathilbert",11,(void*)mathilbert,8,"L"}, {"mathnf",99,(void*)mathnf0,8,"GD0,L,"}, {"mathnfmod",2,(void*)hnfmod,8,"GG"}, {"mathnfmodid",2,(void*)hnfmodid,8,"GG"}, {"matid",11,(void*)idmat,8,"L"}, {"matimage",99,(void*)matimage0,8,"GD0,L,"}, {"matimagecompl",18,(void*)imagecompl,8,"G"}, {"matindexrank",18,(void*)indexrank,8,"G"}, {"matintersect",2,(void*)intersect,8,"GG"}, {"matinverseimage",2,(void*)inverseimage,8,"GG"}, {"matisdiagonal",10,(void*)isdiagonal,8,"lG"}, {"matker",99,(void*)matker0,8,"GD0,L,p"}, {"matkerint",99,(void*)matkerint0,8,"GD0,L,"}, {"matmuldiagonal",2,(void*)matmuldiagonal,8,"GG"}, {"matmultodiagonal",2,(void*)matmultodiagonal,8,"GG"}, {"matpascal",99,(void*)matqpascal,8,"LDG"}, {"matrank",10,(void*)rank,8,"lG"}, {"matrix",49,(void*)matrice,8,"GGDVDVDI"}, {"matrixqz",2,(void*)matrixqz0,8,"GG"}, {"matsize",18,(void*)matsize,8,"G"}, {"matsnf",99,(void*)matsnf0,8,"GD0,L,"}, {"matsolve",2,(void*)gauss,8,"GG"}, {"matsolvemod",99,(void*)matsolvemod0,8,"GGGD0,L,"}, {"matsupplement",1,(void*)suppl,8,"Gp"}, {"mattranspose",18,(void*)gtrans,8,"G"}, {"max",2,(void*)gmax,1,"GG"}, {"min",2,(void*)gmin,1,"GG"}, {"modreverse",18,(void*)polymodrecip,6,"G"}, {"moebius",18,(void*)gmu,4,"G"}, {"newtonpoly",2,(void*)newtonpoly,6,"GG"}, {"next",0,(void*)next0,11,"D1,L,"}, {"nextprime",18,(void*)gnextprime,4,"G"}, {"nfalgtobasis",2,(void*)algtobasis,6,"GG"}, {"nfbasis",99,(void*)nfbasis0,6,"GD0,L,DG"}, {"nfbasistoalg",2,(void*)basistoalg,6,"GG"}, {"nfdetint",2,(void*)nfdetint,6,"GG"}, {"nfdisc",99,(void*)nfdiscf0,6,"GD0,L,DG"}, {"nfeltdiv",3,(void*)element_div,6,"GGG"}, {"nfeltdiveuc",3,(void*)nfdiveuc,6,"GGG"}, {"nfeltdivmodpr",4,(void*)element_divmodpr,6,"GGGG"}, {"nfeltdivrem",3,(void*)nfdivres,6,"GGG"}, {"nfeltmod",3,(void*)nfmod,6,"GGG"}, {"nfeltmul",3,(void*)element_mul,6,"GGG"}, {"nfeltmulmodpr",4,(void*)element_mulmodpr2,6,"GGGG"}, {"nfeltpow",3,(void*)element_pow,6,"GGG"}, {"nfeltpowmodpr",4,(void*)element_powmodpr,6,"GGGG"}, {"nfeltreduce",3,(void*)element_reduce,6,"GGG"}, {"nfeltreducemodpr",3,(void*)nfreducemodpr2,6,"GGG"}, {"nfeltval",30,(void*)element_val,6,"lGGG"}, {"nffactor",99,(void*)nffactor,6,"GG"}, {"nffactormod",99,(void*)nffactormod,6,"GGG"}, {"nfgaloisapply",3,(void*)galoisapply,6,"GGG"}, {"nfgaloisconj",99,(void*)galoisconj0,6,"GD0,L,DGp"}, {"nfhilbert",99,(void*)nfhilbert0,6,"lGGGDG"}, {"nfhnf",2,(void*)nfhermite,6,"GG"}, {"nfhnfmod",3,(void*)nfhermitemod,6,"GGG"}, {"nfinit",99,(void*)nfinit0,6,"GD0,L,p"}, {"nfisideal",20,(void*)isideal,6,"lGG"}, {"nfisincl",2,(void*)nfisincl,6,"GG"}, {"nfisisom",2,(void*)nfisisom,6,"GG"}, {"nfkermodpr",3,(void*)nfkermodpr,6,"GGG"}, {"nfmodprinit",2,(void*)nfmodprinit,6,"GG"}, {"nfnewprec",1,(void*)nfnewprec,6,"Gp"}, {"nfroots",99,(void*)nfroots,6,"GG"}, {"nfrootsof1",1,(void*)rootsof1,6,"Gp"}, {"nfsnf",2,(void*)nfsmith,6,"GG"}, {"nfsolvemodpr",4,(void*)nfsolvemodpr,6,"GGGG"}, {"nfsubfields",99,(void*)subfields0,6,"GDG"}, {"norm",18,(void*)gnorm,2,"G"}, {"norml2",18,(void*)gnorml2,2,"G"}, {"numdiv",18,(void*)gnumbdiv,4,"G"}, {"numerator",18,(void*)numer,2,"G"}, {"numtoperm",24,(void*)permute,2,"LG"}, {"omega",18,(void*)gomega,4,"G"}, {"padicappr",2,(void*)apprgen9,7,"GG"}, {"padicprec",20,(void*)padicprec,2,"lGG"}, {"permtonum",18,(void*)permuteInv,2,"G"}, {"polcoeff",99,(void*)polcoeff0,2,"GLDn"}, {"polcompositum",25,(void*)polcompositum0,6,"GGD0,L,"}, {"polcyclo",99,(void*)cyclo,7,"LDn"}, {"poldegree",99,(void*)poldegree,7,"lGDn"}, {"poldisc",99,(void*)poldisc0,7,"GDn"}, {"poldiscreduced",18,(void*)reduceddiscsmith,7,"G"}, {"polgalois",99,(void*)galois,6,"Gp"}, {"polinterpolate",31,(void*)polint,7,"GGDGD&"}, {"polisirreducible",18,(void*)gisirreducible,7,"G"}, {"pollead",99,(void*)pollead,7,"GDn"}, {"pollegendre",99,(void*)legendre,7,"LDn"}, {"polrecip",18,(void*)polrecip,7,"G"}, {"polred",99,(void*)polred0,6,"GD0,L,DGp"}, {"polredabs",99,(void*)polredabs0,6,"GD0,L,p"}, {"polredord",1,(void*)ordred,6,"Gp"}, {"polresultant",99,(void*)polresultant0,7,"GGDnD0,L,"}, {"polroots",99,(void*)roots0,7,"GD0,L,p"}, {"polrootsmod",25,(void*)rootmod0,7,"GGD0,L,"}, {"polrootspadic",32,(void*)rootpadic,7,"GGL"}, {"polsturm",99,(void*)sturmpart,7,"lGDGDG"}, {"polsubcyclo",99,(void*)subcyclo,6,"GGDn"}, {"polsylvestermatrix",29,(void*)sylvestermatrix,7,"GGp"}, {"polsym",21,(void*)polsym,7,"GL"}, {"poltchebi",99,(void*)tchebi,7,"LDn"}, {"poltschirnhaus",18,(void*)tschirnhaus,6,"G"}, {"polylog",99,(void*)polylog0,3,"LGD0,L,p"}, {"polzagier",99,(void*)polzag,7,"LL"}, {"precision",99,(void*)precision0,2,"GD0,L,"}, {"precprime",18,(void*)gprecprime,4,"G"}, {"prime",11,(void*)prime,4,"L"}, {"primes",11,(void*)primes,4,"L"}, {"prod",47,(void*)produit,9,"V=GGIDG"}, {"prodeuler",37,(void*)prodeuler,9,"V=GGIp"}, {"prodinf",99,(void*)prodinf0,9,"V=GID0,L,p"}, {"psi",1,(void*)gpsi,3,"Gp"}, {"qfbclassno",99,(void*)qfbclassno0,4,"GD0,L,"}, {"qfbcompraw",2,(void*)compraw,4,"GG"}, {"qfbhclassno",18,(void*)hclassno,4,"G"}, {"qfbnucomp",3,(void*)nucomp,4,"GGG"}, {"qfbnupow",2,(void*)nupow,4,"GG"}, {"qfbpowraw",23,(void*)powraw,4,"GL"}, {"qfbprimeform",29,(void*)primeform,4,"GGp"}, {"qfbred",99,(void*)qfbred0,4,"GD0,L,DGDGDG"}, {"qfgaussred",18,(void*)sqred,8,"G"}, {"qfjacobi",1,(void*)jacobi,8,"Gp"}, {"qflll",99,(void*)qflll0,8,"GD0,L,p"}, {"qflllgram",99,(void*)qflllgram0,8,"GD0,L,p"}, {"qfminim",33,(void*)minim0,8,"GGGD0,L,p"}, {"qfperfection",18,(void*)perf,8,"G"}, {"qfsign",18,(void*)signat,8,"G"}, {"quadclassunit",96,(void*)quadclassunit0,4,"GD0,L,DGp"}, {"quaddisc",18,(void*)quaddisc,4,"G"}, {"quadgen",18,(void*)quadgen,4,"G"}, {"quadhilbert",99,(void*)quadhilbert,4,"GDGp"}, {"quadpoly",99,(void*)quadpoly0,4,"GDn"}, {"quadray",99,(void*)quadray,4,"GGDGp"}, {"quadregulator",1,(void*)gregula,4,"Gp"}, {"quadunit",1,(void*)gfundunit,4,"Gp"}, {"random",0,(void*)genrand,2,"DG"}, {"real",18,(void*)greal,2,"G"}, {"removeprimes",0,(void*)removeprimes,4,"DG"}, {"reorder",0,(void*)reorder,11,"DG"}, {"return",0,(void*)return0,11,"DG"}, {"rnfalgtobasis",2,(void*)rnfalgtobasis,6,"GG"}, {"rnfbasis",2,(void*)rnfbasis,6,"GG"}, {"rnfbasistoalg",2,(void*)rnfbasistoalg,6,"GG"}, {"rnfcharpoly",99,(void*)rnfcharpoly,6,"GGGDn"}, {"rnfconductor",29,(void*)rnfconductor,6,"GGp"}, {"rnfdedekind",99,(void*)rnfdedekind,6,"GGG"}, {"rnfdet",99,(void*)rnfdet0,6,"GGDG"}, {"rnfdisc",2,(void*)rnfdiscf,6,"GG"}, {"rnfeltabstorel",2,(void*)rnfelementabstorel,6,"GG"}, {"rnfeltdown",2,(void*)rnfelementdown,6,"GG"}, {"rnfeltreltoabs",2,(void*)rnfelementreltoabs,6,"GG"}, {"rnfeltup",2,(void*)rnfelementup,6,"GG"}, {"rnfequation",25,(void*)rnfequation0,6,"GGD0,L,"}, {"rnfhnfbasis",2,(void*)rnfhermitebasis,6,"GG"}, {"rnfidealabstorel",2,(void*)rnfidealabstorel,6,"GG"}, {"rnfidealdown",2,(void*)rnfidealdown,6,"GG"}, {"rnfidealhnf",2,(void*)rnfidealhermite,6,"GG"}, {"rnfidealmul",2,(void*)rnfidealmul,6,"GG"}, {"rnfidealnormabs",2,(void*)rnfidealnormabs,6,"GG"}, {"rnfidealnormrel",2,(void*)rnfidealnormrel,6,"GG"}, {"rnfidealreltoabs",2,(void*)rnfidealreltoabs,6,"GG"}, {"rnfidealtwoelt",2,(void*)rnfidealtwoelement,6,"GG"}, {"rnfidealup",2,(void*)rnfidealup,6,"GG"}, {"rnfinit",29,(void*)rnfinitalg,6,"GGp"}, {"rnfisfree",20,(void*)rnfisfree,6,"lGG"}, {"rnfisnorm",99,(void*)rnfisnorm,6,"GGGD1,L,p"}, {"rnfkummer",99,(void*)rnfkummer,6,"GGD0,L,p"}, {"rnflllgram",99,(void*)rnflllgram,6,"GGGp"}, {"rnfnormgroup",2,(void*)rnfnormgroup,6,"GG"}, {"rnfpolred",29,(void*)rnfpolred,6,"GGp"}, {"rnfpolredabs",99,(void*)rnfpolredabs,6,"GGD0,L,p"}, {"rnfpseudobasis",2,(void*)rnfpseudobasis,6,"GG"}, {"rnfsteinitz",2,(void*)rnfsteinitz,6,"GG"}, {"round",99,(void*)round0,2,"GD&"}, {"serconvol",2,(void*)convol,7,"GG"}, {"serlaplace",18,(void*)laplace,7,"G"}, {"serreverse",18,(void*)recip,7,"G"}, {"setintersect",2,(void*)setintersect,8,"GG"}, {"setisset",10,(void*)setisset,8,"lG"}, {"setminus",2,(void*)setminus,8,"GG"}, {"setrand",99,(void*)setrand,11,"lL"}, {"setsearch",99,(void*)setsearch,8,"lGGD0,L,"}, {"setunion",2,(void*)setunion,8,"GG"}, {"shift",99,(void*)gshift,1,"GL"}, {"shiftmul",99,(void*)gmul2n,1,"GL"}, {"sigma",99,(void*)gsumdivk,4,"GD1,L,"}, {"sign",10,(void*)gsigne,1,"lG"}, {"simplify",18,(void*)simplify,2,"G"}, {"sin",1,(void*)gsin,3,"Gp"}, {"sinh",1,(void*)gsh,3,"Gp"}, {"sizebyte",10,(void*)taille2,2,"lG"}, {"sizedigit",10,(void*)gsize,2,"lG"}, {"solve",37,(void*)zbrent,9,"V=GGIp"}, {"sqr",18,(void*)gsqr,3,"G"}, {"sqrt",1,(void*)gsqrt,3,"Gp"}, {"sqrtint",1,(void*)racine,4,"Gp"}, {"subgrouplist",99,(void*)subgrouplist0,6,"GD0,L,D0,L,p"}, {"subst",26,(void*)gsubst,7,"GnG"}, {"sum",48,(void*)somme,9,"V=GGIDG"}, {"sumalt",99,(void*)sumalt0,9,"V=GID0,L,p"}, {"sumdiv",22,(void*)divsum,9,"GVI"}, {"suminf",27,(void*)suminf,9,"V=GIp"}, {"sumpos",99,(void*)sumpos0,9,"V=GID0,L,p"}, {"tan",1,(void*)gtan,3,"Gp"}, {"tanh",1,(void*)gth,3,"Gp"}, {"taylor",12,(void*)tayl,7,"GnP"}, {"teichmuller",1,(void*)teich,3,"Gp"}, {"theta",29,(void*)theta,3,"GGp"}, {"thetanullk",99,(void*)thetanullk,3,"GL"}, {"thue",99,(void*)thue,7,"GGDG"}, {"thueinit",99,(void*)thueinit,7,"GD0,L,p"}, {"trace",1,(void*)gtrace,8,"Gp"}, {"truncate",99,(void*)trunc0,2,"GD&"}, {"until",82,NULL,11,NULL}, {"valuation",20,(void*)ggval,2,"lGG"}, {"variable",18,(void*)gpolvar,2,"G"}, {"vecextract",99,(void*)extract0,8,"GGDG"}, {"vecmax",1,(void*)vecmax,1,"Gp"}, {"vecmin",1,(void*)vecmin,1,"Gp"}, {"vecsort",99,(void*)vecsort0,8,"GDGD0,L,"}, {"vector",28,(void*)vecteur,8,"GDVDI"}, {"vectorv",28,(void*)vvecteur,8,"GDVDI"}, {"weber",99,(void*)weber0,3,"GD0,L,p"}, {"while",81,NULL,11,NULL}, {"zeta",1,(void*)gzeta,3,"Gp"}, {"zetak",99,(void*)gzetakall,6,"GGD0,L,p"}, {"zetakinit",1,(void*)initzeta,6,"Gp"}, {"znlog",2,(void*)znlog,4,"GG"}, {"znorder",18,(void*)order,4,"G"}, {"znprimroot",18,(void*)ggener,4,"G"}, {"znstar",1,(void*)znstar,4,"Gp"}, /* DO NOT REMOVE THIS BLANK LINE: chname & helpsynchro depend on it */ {NULL,0,NULL,0,NULL} /* sentinel */ };