OpenXM_contrib2/asir2000/include/ca.h - diff

Return to ca.h CVS log

Up to [local] / OpenXM_contrib2 / asir2000 / include

Diff for /OpenXM_contrib2/asir2000/include/ca.h between version 1.46 and 1.98

version 1.46, 2004/03/03 09:25:30

version 1.98, 2017/01/08 03:05:40

Line 45

* DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,

* PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.

* $OpenXM: OpenXM_contrib2/asir2000/include/ca.h,v 1.45 2004/02/09 08:23:29 noro Exp $

* $OpenXM: OpenXM_contrib2/asir2000/include/ca.h,v 1.97 2016/08/24 05:33:58 ohara Exp $

#include <stdio.h>

#include <stdlib.h>

#include <gmp.h>

#include <mpc.h>

#include <limits.h>

/* from mpfr-impl.h */

#define MPFR_PREC(x) ((x)->_mpfr_prec)

#define MPFR_EXP(x) ((x)->_mpfr_exp)

#define MPFR_MANT(x) ((x)->_mpfr_d)

#define MPFR_LAST_LIMB(x) ((MPFR_PREC (x) - 1) / GMP_NUMB_BITS)

#define MPFR_LIMB_SIZE(x) (MPFR_LAST_LIMB (x) + 1)

#define RAT_CEIL(nm,dn) (((nm)+(dn)-1)/((dn)))

#define MPFR_LIMB_SIZE_REAL(x) (RAT_CEIL(MPFR_PREC((x)),sizeof(mp_limb_t)*CHAR_BIT) * (sizeof(mp_limb_t)/sizeof(int)) )

#define MPFR_LIMB_SIZE_BODY(x) (RAT_CEIL(MPFR_PREC((x)),sizeof(unsigned int)*CHAR_BIT))

#if defined(hpux)

#include <netinet/in.h>

# define setbuffer(FP,buf,siz) setvbuf(FP,buf,_IOFBF,siz)

#endif

#if !defined(VISUAL)

#if !defined(VISUAL) && !defined(__MINGW32__)

#include <unistd.h>

#endif

#if !defined(VISUAL)

#include <sys/param.h>

#endif

Line 71

Line 82

#define alloca(x) __builtin_alloca(x)

#endif

#if defined(VISUAL)

#if defined(VISUAL) || defined(__MINGW32__)

#include <limits.h>

#include <malloc.h>

#endif

Line 80

Line 92

typedef caddr_t pointer;

#endif

typedef void * pointer;

#if defined(sun)

#include <strings.h>

#else

#include <string.h>

#if defined(VISUAL)

#if defined(VISUAL) || defined(__MINGW32__)

#define index(s,c) strchr(s,c)

#define bzero(s,len) memset(s,0,len)

#define bcopy(x,y,len) memcpy(y,x,len)

#endif

#define NULLP ((void *)0)

#define TODO printf("%s: not implemented!\n", __func__)

#define COPY(a,b) ((b)=(a))

#define FREEN(p)

#define FREEQ(p)

Line 122 typedef void * pointer;

Line 139 typedef void * pointer;

#define O_SYMBOL 19

#define O_RANGE 20

#define O_TB 21

#define O_DPV 22

#define O_QUOTEARG 23

#define O_VOID -1

/* IMAT */

#define O_IMAT 24

/* IMAT */

#define O_NBP 25

#define N_Q 0

#define N_R 1

#define N_A 2

#define N_B 3

#define N_C 4

#define N_NEXT_B (N_B)

#define N_M 5

#if defined(INTERVAL)

#define N_LM 6

#define N_Quad (N_NEXT_B+1)

#define N_GF2N 7

#define N_IP (N_NEXT_B+2)

#define N_GFPN 8

#define N_IntervalDouble (N_NEXT_B+3)

#define N_GFS 9

#define N_IntervalQuad (N_NEXT_B+4)

#define N_GFSN 10

#define N_IntervalBigFloat (N_NEXT_B+5)

#define N_PRE_C N_IntervalBigFloat

#define N_BASE (N_NEXT_B+5)

#else

#define N_BASE N_NEXT_B

#endif

#define N_C (N_BASE+1)

#define N_M (N_BASE+2)

#define N_LM (N_BASE+3)

#define N_GF2N (N_BASE+4)

#define N_GFPN (N_BASE+5)

#define N_GFS (N_BASE+6)

#define N_GFSN (N_BASE+7)

#define N_DA (N_BASE+8)

#define N_GZ (N_BASE+9)

#define N_GQ (N_BASE+10)

#define N_PARIB (N_BASE+11)

#define ORD_REVGRADLEX 0

#define ORD_GRADLEX 1

#define ORD_LEX 2

#if defined(LONG_IS_32BIT)

typedef enum {

#if defined(VISUAL)

A_end=0,A_fnode,A_arf,A_int,A_str,A_internal,A_node,A_notimpl,A_func

typedef _int64 L;

} farg_type;

typedef unsigned _int64 UL;

#else

#if SIZEOF_LONG == 8

typedef long L;

typedef unsigned long UL;

#elif defined(HAVE_UNSIGNED_LONG_LONG)

typedef long long L;

typedef unsigned long long UL;

#elif defined(_MSC_VER)

typedef _int64 L;

typedef unsigned _int64 UL;

#endif

#else

typedef long L;

typedef unsigned long UL;

#endif

typedef struct oN {

int p;

unsigned int b[1];

} *N;

typedef struct oZ {

int p;

unsigned int b[1];

} *Z;

typedef struct oUP2 {

int w;

unsigned int b[1];

Line 209 typedef struct oBF {

Line 255 typedef struct oBF {

short id;

char nid;

char pad;

long body[1];

mpfr_t body;

} *BF;

typedef struct oC {

Line 240 typedef struct oGFPN {

Line 286 typedef struct oGFPN {

struct oUP *body;

} *GFPN;

typedef struct oDAlg {

short id;

char nid;

char pad;

struct oDP *nm;

struct oQ *dn;

} *DAlg;

typedef struct oGZ {

short id;

char nid;

char pad;

mpz_t body;

} *GZ;

typedef struct oGQ {

short id;

char nid;

char pad;

mpq_t body;

} *GQ;

typedef struct oNum {

short id;

char nid;

Line 302 typedef struct oGF2MAT {

Line 370 typedef struct oGF2MAT {

unsigned int **body;

} *GF2MAT, *GFMMAT;

/* IMAT */

#define IMATCH 64

typedef struct oIENT {

int cr;

int row, col;

pointer *body;

} IENT;

typedef struct oIMATC {

pointer *fore;

pointer *next;

IENT ient[IMATCH];

} *IMATC;

typedef struct oIMAT {

short id;

int row, col, clen;

pointer *root;

pointer *toor;

} *IMAT;

/* IMAT */

typedef struct oLIST {

short id;

short pad;

Line 327 typedef struct oDP {

Line 417 typedef struct oDP {

struct oMP *body;

} *DP;

typedef struct oDPV {

short id;

int len;

int sugar;

struct oDP **body;

} *DPV;

typedef struct oUSINT {

short id;

short pad;

Line 358 typedef struct oQUOTE {

Line 455 typedef struct oQUOTE {

pointer body;

} *QUOTE;

typedef struct oQUOTEARG {

short id;

short pad;

farg_type type;

pointer body;

} *QUOTEARG;

typedef struct oOPTLIST {

short id;

short pad;

Line 384 typedef struct oTB {

Line 488 typedef struct oTB {

char **body;

} *TB;

typedef struct oNBP {

short id;

short pad;

struct oNODE *body;

} *NBP;

/* non-commutative bivariate monomial */

typedef struct oNBM {

int d;

P c;

unsigned int *b;

} *NBM;

#define NEWNBM(p) ((p)=(NBM)MALLOC(sizeof(struct oNBM)))

#define NEWNBMBDY(p,d) \

((p)->b=(unsigned int *)MALLOC((((d)+31)/32)*sizeof(unsigned int)))

#define NEWNBP(p) ((p)=(NBP)MALLOC(sizeof(struct oNBP)),OID(p)=O_NBP)

#define MKNBP(p,b) (NEWNBP(p),BDY(p)=(b))

#define NBM_GET(a,j) (((a)[(j)>>5]&(1<<((j)&31)))?1:0)

#define NBM_SET(a,j) ((a)[(j)>>5]|=(1<<((j)&31)))

#define NBM_CLR(a,j) ((a)[(j)>>5]&=(~(1<<((j)&31))))

typedef struct oObj {

short id;

short pad;

Line 538 struct order_spec {

Line 666 struct order_spec {

int id;

Obj obj;

int nv;

int ispot; /* 1 means Position over Term (Pos then Term) */

int pot_nelim; /* size of positions for pot-elimination order */

int *top_weight;

int module_rank;

int *module_top_weight;

union {

int simple;

struct {

Line 555 struct order_spec {

Line 688 struct order_spec {

} ord;

};

struct modorder_spec {

/* id : ORD_REVGRADLEX, ORD_GRADLEX, ORD_LEX */

int id;

Obj obj;

int len;

int *degree_shift;

};

typedef struct oNumberField {

int n;

int psn;

int dim;

VL vl;

P *defpoly;

DP *mb;

DP *ps;

struct oDAlg *one;

NODE ind;

struct order_spec *spec;

} *NumberField;

/* structure for cputime */

struct oEGT {

Line 619 typedef unsigned int ModNum;

Line 773 typedef unsigned int ModNum;

/* memory allocators (W_... : uses alloca) */

#if 0

#define MALLOC(d) Risa_GC_malloc(d)

#define MALLOC_ATOMIC(d) Risa_GC_malloc_atomic(d)

#define MALLOC_ATOMIC_IGNORE_OFF_PAGE(d) Risa_GC_malloc_atomic_ignore_off_page(d)

#define REALLOC(p,d) Risa_GC_realloc(p,d)

#else

#define GCFREE(p) Risa_GC_free(p)

#define MALLOC(d) GC_malloc(d)

#define MALLOC_ATOMIC(d) GC_malloc_atomic(d)

#define REALLOC(p,d) GC_realloc(p,d)

#endif

#define CALLOC(d,e) MALLOC((d)*(e))

#if !defined(__CYGWIN__) && (defined(__GNUC__) || defined(vax) || defined(apollo) || defined(alloca) || defined(VISUAL))

#if !defined(__CYGWIN__) && (defined(__GNUC__) || defined(vax) || defined(apollo) || defined(alloca) || defined(VISUAL) || defined(__MINGW32__))

#define ALLOCA(d) alloca(d)

#else

#define ALLOCA(d) MALLOC(d)

#endif

/* for handling signals */

#if defined(HAVE_SIGACTION) /* POSIX */

void (*set_signal(int sig, void (*handler)(int)))(int);

#define set_signal_for_restart(x,y) (0)

#else

#define set_signal(x,y) (signal(x,y))

#define set_signal_for_restart(x,y) (signal(x,y))

#endif

/* for setjmp/longjmp compatibility */

#if defined(__CYGWIN__) || defined(__x86_64)

#if defined(__CYGWIN__) || defined(HAVE_SIGACTION) || (defined(__x86_64) && !defined(__MINGW32__))

#define JMP_BUF sigjmp_buf

#define SETJMP(x) sigsetjmp(x,~0)

#define LONGJMP(x,y) siglongjmp(x,y)

Line 699 bzero((char *)(q)->b,(w)*sizeof(unsigned int)))

Line 858 bzero((char *)(q)->b,(w)*sizeof(unsigned int)))

((q).b=(unsigned int *)ALLOCA((w)*sizeof(unsigned int)))

/* cell allocators */

#define NEWGZ(q) ((q)=(GZ)MALLOC(sizeof(struct oGZ)),OID(q)=O_N,NID(q)=N_GZ)

#define NEWGQ(q) ((q)=(GQ)MALLOC(sizeof(struct oGQ)),OID(q)=O_N,NID(q)=N_GQ)

#define NEWQ(q) ((q)=(Q)MALLOC(sizeof(struct oQ)),OID(q)=O_N,NID(q)=N_Q)

#define NEWMQ(q) ((q)=(MQ)MALLOC_ATOMIC(sizeof(struct oMQ)),OID(q)=O_N,NID(q)=N_M)

#define NEWGFS(q) ((q)=(GFS)MALLOC_ATOMIC(sizeof(struct oGFS)),OID(q)=O_N,NID(q)=N_GFS)

Line 710 bzero((char *)(q)->b,(w)*sizeof(unsigned int)))

Line 871 bzero((char *)(q)->b,(w)*sizeof(unsigned int)))

#define NEWSTR(l) ((l)=(STRING)MALLOC(sizeof(struct oSTRING)),OID(l)=O_STR)

#define NEWCOMP(c,n) ((c)=(COMP)MALLOC(sizeof(struct oCOMP)+((n)-1)*sizeof(Obj)),OID(c)=O_COMP)

#define NEWDP(d) ((d)=(DP)MALLOC(sizeof(struct oDP)),OID(d)=O_DP)

#define NEWDPV(d) ((d)=(DPV)MALLOC(sizeof(struct oDPV)),OID(d)=O_DPV)

#define NEWUSINT(u) ((u)=(USINT)MALLOC_ATOMIC(sizeof(struct oUSINT)),OID(u)=O_USINT)

#define NEWERR(e) ((e)=(ERR)MALLOC(sizeof(struct oERR)),OID(e)=O_ERR)

#define NEWMATHCAP(e) ((e)=(MATHCAP)MALLOC(sizeof(struct oMATHCAP)),OID(e)=O_MATHCAP)

#define NEWBYTEARRAY(e) ((e)=(BYTEARRAY)MALLOC(sizeof(struct oBYTEARRAY)),OID(e)=O_BYTEARRAY)

#define NEWQUOTE(e) ((e)=(QUOTE)MALLOC(sizeof(struct oQUOTE)),OID(e)=O_QUOTE)

#define NEWQUOTEARG(e) ((e)=(QUOTEARG)MALLOC(sizeof(struct oQUOTEARG)),OID(e)=O_QUOTEARG)

#define NEWOPTLIST(l) ((l)=(OPTLIST)MALLOC(sizeof(struct oOPTLIST)),OID(l)=O_OPTLIST)

#define NEWSYMBOL(l) ((l)=(SYMBOL)MALLOC(sizeof(struct oSYMBOL)),OID(l)=O_SYMBOL)

#define NEWRANGE(l) ((l)=(RANGE)MALLOC(sizeof(struct oRANGE)),OID(l)=O_RANGE)

Line 731 bzero((char *)(q)->b,(w)*sizeof(unsigned int)))

Line 894 bzero((char *)(q)->b,(w)*sizeof(unsigned int)))

#define NEWMAT(l) ((l)=(MAT)MALLOC(sizeof(struct oMAT)),OID(l)=O_MAT)

#define NEWGF2MAT(l) ((l)=(GF2MAT)MALLOC(sizeof(struct oGF2MAT)),OID(l)=O_GF2MAT)

#define NEWGFMMAT(l) ((l)=(GFMMAT)MALLOC(sizeof(struct oGF2MAT)),OID(l)=O_GFMMAT)

/* IMAT */

#define NEWIMAT(l) ((l)=(IMAT)MALLOC(sizeof(struct oIMAT)),OID(l)=O_IMAT,l->clen=0,l->root=0,l->toor=0)

#define NEWIENT(l) ((l)=(IMATC)MALLOC(sizeof(struct oIMATC)),l->fore=0,l->next=0)

/* IMAT */

#define NEWReal(q) ((q)=(Real)MALLOC_ATOMIC(sizeof(struct oReal)),OID(q)=O_N,NID(q)=N_R)

#define NEWAlg(r) ((r)=(Alg)MALLOC(sizeof(struct oAlg)),OID(r)=O_N,NID(r)=N_A)

#define NEWBF(q,l) ((q)=(BF)MALLOC_ATOMIC(TRUESIZE(oBF,(l)-1,long)),OID(q)=O_N,NID(q)=N_B)

#define NEWDAlg(r) ((r)=(DAlg)MALLOC(sizeof(struct oDAlg)),OID(r)=O_N,NID(r)=N_DA)

#define NEWBF(q) ((q)=(BF)MALLOC(sizeof(struct oBF)),OID(q)=O_N,NID(q)=N_B)

#define NEWPARIBF(q,l) ((q)=(BF)MALLOC_ATOMIC(TRUESIZE(oBF,(l)-1,long)),OID(q)=O_N,NID(q)=N_PARIB)

#define NEWC(r) ((r)=(C)MALLOC(sizeof(struct oC)),OID(r)=O_N,NID(r)=N_C)

#define NEWLM(r) ((r)=(LM)MALLOC(sizeof(struct oLM)),OID(r)=O_N,NID(r)=N_LM)

#define NEWGF2N(r) ((r)=(GF2N)MALLOC(sizeof(struct oGF2N)),OID(r)=O_N,NID(r)=N_GF2N)

Line 744 bzero((char *)(q)->b,(w)*sizeof(unsigned int)))

Line 913 bzero((char *)(q)->b,(w)*sizeof(unsigned int)))

((d)=(DL)MALLOC_ATOMIC(TRUESIZE(oDL,(n)-1,int)))

#define MKP(v,dc,p) \

(!DEG(dc)?((p)=COEF(dc)):(NEWP(p),VR(p)=(v),DC(p)=(dc),(p)))

((!DEG(dc)&&!NEXT(dc))?((p)=COEF(dc)):(NEWP(p),VR(p)=(v),DC(p)=(dc),(p)))

#define MKV(v,p) \

(NEWP(p),VR(p)=(v),NEWDC(DC(p)),\

DEG(DC(p))=ONE,COEF(DC(p))=(P)ONE,NEXT(DC(p))=0)

Line 764 DEG(DC(p))=ONE,COEF(DC(p))=(P)ONEM,NEXT(DC(p))=0)

Line 933 DEG(DC(p))=ONE,COEF(DC(p))=(P)ONEM,NEXT(DC(p))=0)

#define TOGFMMAT(r,c,b,m) (NEWGFMMAT(m),(m)->row=(r),(m)->col=(c),(m)->body=(b))

#define MKSTR(a,b) (NEWSTR(a),(a)->body=(char *)(b))

#define MKDP(n,m,d) (NEWDP(d),(d)->nv=(n),BDY(d)=(m))

#define MKDPV(len,m,d) (NEWDPV(d),(d)->len=(len),BDY(d)=(m))

#define MKLM(b,l) (!(b)?(l)=0:(NEWLM(l),(l)->body=(b),(l)))

#define MKGF2N(b,l) (!(b)?(l)=0:(NEWGF2N(l),(l)->body=(b),(l)))

#define MKGFPN(b,l) (!(b)?(l)=0:(NEWGFPN(l),(l)->body=(b),(l)))

Line 771 DEG(DC(p))=ONE,COEF(DC(p))=(P)ONEM,NEXT(DC(p))=0)

Line 941 DEG(DC(p))=ONE,COEF(DC(p))=(P)ONEM,NEXT(DC(p))=0)

#define MKERR(e,b) (NEWERR(e),(e)->body=(Obj)(b))

#define MKMATHCAP(e,b) (NEWMATHCAP(e),(e)->body=(LIST)(b))

#define MKBYTEARRAY(m,l) \

(NEWBYTEARRAY(m),(m)->len=(l),(m)->body=(char *)MALLOC_ATOMIC((l)),bzero((m)->body,(l)))

(NEWBYTEARRAY(m),(m)->len=(l),(m)->body=(unsigned char *)MALLOC_ATOMIC((l)),bzero((m)->body,(l)))

#define MKQUOTE(q,b) (NEWQUOTE(q),(q)->body=(pointer)(b))

#define MKQUOTEARG(q,t,b) (NEWQUOTEARG(q),(q)->type=(t),(q)->body=(pointer)(b))

#define NEXTDC(r,c) \

if(!(r)){NEWDC(r);(c)=(r);}else{NEWDC(NEXT(c));(c)=NEXT(c);}

Line 823 PL(NM(q))=1,BD(NM(q))[0]=(unsigned int)(n),DN(q)=0,(q)

Line 994 PL(NM(q))=1,BD(NM(q))[0]=(unsigned int)(n),DN(q)=0,(q)

#define MKReal(a,b) (!(a)?((b)=0):(NEWReal(b),BDY(b)=(a),(b)))

#define MKAlg(b,r) \

(!(b)?((r)=0):NUM(b)?((r)=(Alg)(b)):(NEWAlg(r),BDY(r)=(Obj)(b),(r)))

#define MKDAlg(dp,den,r) (!(dp)?(void *)((r)=0):(void *)(NEWDAlg(r),(r)->nm = (dp),(r)->dn=(den)))

#if defined(PARI)

#define IMM_MAX 1073741823

#define ToReal(a) (!(a)?(double)0.0:REAL(a)?BDY((Real)a):RATN(a)?RatnToReal((Q)a):BIGFLOAT(a)?rtodbl(BDY((BF)a)):0)

#define IMM_MIN -1073741823

#else

#define ToReal(a) (!(a)?(double)0.0:REAL(a)?BDY((Real)a):RATN(a)?RatnToReal((Q)a):0.0)

#endif

#define SL(n) ((n)->p)

#define ZALLOC(d) ((Z)MALLOC_ATOMIC(TRUESIZE(oZ,(d)-1,int)))

#define ToReal(a) (!(a)?(double)0.0:REAL(a)?BDY((Real)a):RATN(a)?RatnToReal((Q)a):BIGFLOAT(a)?mpfrtodbl(BDY((BF)a)):0)

/* predicates */

#define NUM(p) (OID(p)==O_N)

#define RAT(p) (OID(p)==O_R)

#define RATN(a) (NID(a)==N_Q)

#define POLY(a) (!(a) ||(OID(a)<=O_P))

#define INT(q) (!(q)||(NUM(q)&&RATN((Num)q)&&!DN((Q)q)))

#define REAL(a) (NID(a)==N_R)

#define BIGFLOAT(a) (NID(a)==N_B)

Line 842 PL(NM(q))=1,BD(NM(q))[0]=(unsigned int)(n),DN(q)=0,(q)

Line 1017 PL(NM(q))=1,BD(NM(q))[0]=(unsigned int)(n),DN(q)=0,(q)

#define UNIMQ(q) ((q)&&NUM(q)&&SFF(q)&&(CONT((MQ)q)==1))

#define MUNIQ(q) ((q)&&NUM(q)&&RATN(q)&&(SGN((Q)q)==-1)&&UNIN(NM((Q)q))&&(!DN((Q)q)))

#define MUNIMQ(q) ((q)&&NUM(q)&&SFF(q)&&(CONT((MQ)q)==-1))

#define UNILM(n) ((n)&&UNIN(BDY(n)))

#define UNIN(n) ((n)&&(PL(n)==1)&&(BD(n)[0]==1))

#define EVENN(n) ((!(n))||(!(BD(n)[0]%2)))

Line 926 extern const int sprime[];

Line 1102 extern const int sprime[];

extern int sprime[];

#endif

extern int lprime_size;

extern int *lprime;

extern void (*addnumt[])();

extern void (*subnumt[])();

extern void (*mulnumt[])();

Line 1068 void dtop(VL,VL,DP,P *);

Line 1241 void dtop(VL,VL,DP,P *);

void ptod(VL,VL,P,DP *);

void initd(struct order_spec *);

void adddv(VL,DPV,DPV,DPV *);

void subdv(VL,DPV,DPV,DPV *);

void muldv(VL,DP,DPV,DPV *);

void chsgndv(DPV,DPV *);

int compdv(VL,DPV,DPV);

void _printdp(DP);

void _dp_sp_mod(DP,DP,int,DP *);

void _dp_mod(DP,int,NODE,DP *);

Line 1096 void rtime_init(void);

Line 1275 void rtime_init(void);

void setmod_gf2n(P);

void mt_sgenrand(unsigned long);

unsigned long mt_genrand(void);

#if defined(VISUAL)

#if defined(VISUAL) || defined(__MINGW32__)

void srandom(unsigned int);

unsigned int random(void);

#endif

Line 1193 void copyn(N,int,int *);

Line 1372 void copyn(N,int,int *);

void kmulnmain(N,N,N *);

int qcoefp(Obj);

int qcoefr(Obj);

int get_allocwords(void);

size_t get_allocwords(void);

double get_clock(void);

void get_eg(struct oEGT *);

void printtime(struct oEGT *,struct oEGT *,double);

Line 1298 LUM LUMALLOC(int, int);

Line 1477 LUM LUMALLOC(int, int);

BM BMALLOC(int, int);

Obj ToAlg(Num);

UM *berlemain(register int, UM, UM *);

void Risa_GC_set_adj(int,int);

void Risa_GC_get_adj(int *,int *);

void *Risa_GC_malloc(size_t);

void *Risa_GC_malloc_atomic(size_t);

void *Risa_GC_realloc(void *,size_t);

void Risa_GC_free(void *);

void *Risa_GC_malloc_atomic_ignore_off_page(size_t);

void *GC_malloc(size_t);

void *GC_malloc_atomic(size_t);

void *GC_realloc(void *,size_t);

Line 1308 double NatToReal(N,int *);

Line 1491 double NatToReal(N,int *);

double RatnToReal(Q);

double pwrreal0(double,int);

double rtodbl(); /* XXX */

double mpfrtodbl(mpfr_t a);

int **almat(int,int);

pointer **almat_pointer(int,int);

int berlecnt(register int,UM);

Line 1401 void chsgngfsn(GFSN,GFSN *);

Line 1585 void chsgngfsn(GFSN,GFSN *);

void pwrgfsn(GFSN,Q, GFSN *);

int cmpgfsn(GFSN,GFSN);

void adddalg(DAlg,DAlg,DAlg *);

void subdalg(DAlg,DAlg,DAlg *);

void muldalg(DAlg,DAlg,DAlg *);

void divdalg(DAlg,DAlg,DAlg *);

void chsgndalg(DAlg,DAlg *);

void pwrdalg(DAlg,Q, DAlg *);

int cmpdalg(DAlg,DAlg);

void addalg(Num,Num,Num *);

void addbf(Num,Num,Num *);

void addcplx(Num,Num,Num *);

Line 1722 void savep(FILE *,P);

Line 1914 void savep(FILE *,P);

void savegf2n(FILE *,GF2N);

void savegfpn(FILE *,GFPN);

void savegfs(FILE *,GFS);

void savedalg(FILE *,DAlg);

void savelm(FILE *,LM);

void savemi(FILE *,MQ);

void savecplx(FILE *,C);

Line 1747 void loadgf2n(FILE *,GF2N *);

Line 1940 void loadgf2n(FILE *,GF2N *);

void loadgfpn(FILE *,GFPN *);

void loadgfs(FILE *,GFS *);

void loadgfsn(FILE *,GFSN *);

void loaddalg(FILE *,DAlg *);

void loadlm(FILE *,LM *);

void loadmi(FILE *,MQ *);

void loadcplx(FILE *,C *);

Line 2337 void resume_timer() ;

Line 2531 void resume_timer() ;

void reset_engine() ;

unsigned int get_asir_version() ;

char *get_asir_distribution();

void create_error(ERR *err,unsigned int serial,char *msg);

void create_error(ERR *err,unsigned int serial,char *msg,LIST trace);

void init_lprime();

int get_lprime(int index);

void create_new_lprimes(int index);

Line 2449 int divtmp(VL vl,int mod,P p1,P p2,P *q);

Line 2643 int divtmp(VL vl,int mod,P p1,P p2,P *q);

int divtdcmp(VL vl,int mod,P p1,P p2,P *q);

void GC_gcollect();

#if 0 && !defined(VISUAL)

/* IMAT */

void Pnewimat(NODE, IMAT *);

void PChsgnI(NODE, IMAT *);

void Pm2Im(NODE, IMAT *);

void PIm2m(NODE, MAT *);

void AddMatI(VL, IMAT, IMAT, IMAT *);

void MulMatI(VL, IMAT, IMAT, IMAT *);

void MulMatG(VL, Obj, Obj, Obj *);

void MulrMatI(VL, Obj, Obj, Obj *);

void MulMatS(VL, IMAT, IMAT, IMAT *);

void PutIent(IMAT, int, int, Obj);

void GetIent(IMAT, int, int, Obj);

void GetIbody(IMAT, int, int, Obj *);

void ChsgnI(IMAT, IMAT *c);

void AppendIent(IMAT, int, int, Obj);

void MEnt(int, int, int, Obj, IENT *);

void GetForeIent(IMATC *, IENT *, int *);

void GetNextIent(IMATC *, IENT *, int *);

void SubMatI(VL, IMAT, IMAT, IMAT *);

/* IMAT */

Z stoz(int c);

Z utoz(unsigned int c);

Z qtoz(Q n);

Q ztoq(Z n);

Z chsgnz(Z n);

Z simpz(Z n);

Z dupz(Z n);

Z absz(Z n);

Z addz(Z n1,Z n2);

Z subz(Z n1,Z n2);

Z mulz(Z n1,Z n2);

Z divsz(Z n1,Z n2);

Z divz(Z n1,Z n2,Z *rem);

Z gcdz(Z n1,Z n2);

Z gcdz_cofactor(Z n1,Z n2,Z *c1,Z *c2);

Z estimate_array_gcdz(Z *a,int n);

Z array_gcdz(Z *a,int n);

void mkwcz(int k,int l,Z *t);

int remzi(Z n,int m);

#if 0 && !defined(VISUAL) && !defined(__MINGW32__)

void bzero(const void *,int);

void bcopy(const void *,void *,int);

char *index(char *,int);

#endif

void chsgnnbp(NBP p,NBP *rp);

void subnbp(VL vl,NBP p1,NBP p2, NBP *rp);

void addnbp(VL vl,NBP p1,NBP p2, NBP *rp);

void mulnbp(VL vl,NBP p1,NBP p2, NBP *rp);

void pwrnbp(VL vl,NBP p1,Q n, NBP *rp);

int compnbp(VL vl,NBP p1,NBP p2);

#define WORDSIZE_IN_N(a) (ABS((a)->_mp_size)*GMP_LIMB_BITS/32)

#define MPZTOGZ(g,q) \

(!mpz_sgn(g)?((q)=0):(NEWGZ(q),BDY(q)[0]=(g)[0],(q)))

#define MPQTOGQ(g,q) \

(!mpq_sgn(g)?((q)=0):(NEWGQ(q),BDY(q)[0]=(g)[0],(q)))

#define INTMPQ(a) (!mpz_cmp_ui(mpq_numref(a),1))

#define UNIGZ(a) ((a)&&NID(a)==N_GZ&&!mpz_cmp_ui(BDY(a),1))

#define MUNIGZ(a) ((a)&&NID(a)==N_GZ&&!mpz_cmp_si(BDY(a),-1))

#define INTGQ(a) ((a)&&NID(a)==N_GQ&&!mpz_cmp_ui(mpq_denref(BDY(a)),1))

#define UNIGQ(a) \

((a)&&NID(a)==N_GQ&&!mpz_cmp_ui(mpq_numref(BDY(a)),1)&&!mpz_cmp_ui(mpq_denref(BDY(a)),1))

#define MUNIGQ(a) \

((a)&&NID(a)==N_GQ&&!mpz_cmp_si(mpq_numref(BDY(a)),-1)&&!mpz_cmp_ui(mpq_denref(BDY(a)),1))

#define MPZTOMPQ(z,q) \

(mpq_init(q),mpq_numref(q)[0] = (z)[0],mpz_set_ui(mpq_denref(q),1))

#define MPFRTOBF(g,q) \

(NEWBF(q),BDY(q)[0]=(g)[0],(q))

extern mpz_t ONEMPZ;

extern GZ ONEGZ;

void *gc_realloc(void *p,size_t osize,size_t nsize);

void gc_free(void *p,size_t size);

void init_gmpq();

GQ mpqtogzq(mpq_t a);

GQ qtogq(Q a);

Q gqtoq(GQ a);

GZ ztogz(Q a);

Q gztoz(GZ a);

P ptogp(P a);

P gptop(P a);

void addgz(GZ n1,GZ n2,GZ *nr);

void subgz(GZ n1,GZ n2,GZ *nr);

void mulgz(GZ n1,GZ n2,GZ *nr);

void mul1gz(GZ n1,int n2,GZ *nr);

void divgz(GZ n1,GZ n2,GZ *nq);

void chsgngz(GZ n,GZ *nr);

void pwrgz(GZ n1,Q n,GZ *nr);

int cmpgz(GZ q1,GZ q2);

void gcdgz(GZ n1,GZ n2,GZ *nq);

void gcdvgz(VECT v,GZ *q);

void addgq(GQ n1,GQ n2,GQ *nr);

void subgq(GQ n1,GQ n2,GQ *nr);

void mulgq(GQ n1,GQ n2,GQ *nr);

void divgq(GQ n1,GQ n2,GQ *nq);

void chsgngq(GQ n,GQ *nr);

void pwrgq(GQ n1,Q n,GQ *nr);

int cmpgq(GQ n1,GQ n2);

void mkgwc(int k,int l,GZ *t);

void gz_ptozp(P p,int sgn,GQ *c,P *pr);

void gz_lgp(P p,GZ *g,GZ *l);

void gz_qltozl(GQ *w,int n,GZ *dvr);

void _mdtodp(DP p,DP *pr);

void add_denomlist(P f);

void algobjtorat(Obj f,Obj *r);

void algtodalg(Alg a,DAlg *r);

void appenduflist(NODE n);

void arf_add(VL,Obj,Obj,Obj *);

void arf_chsgn(Obj,Obj *);

void arf_div(VL,Obj,Obj,Obj *);

void arf_mul(VL,Obj,Obj,Obj *);

void arf_sub(VL,Obj,Obj,Obj *);

void asir_terminate(int);

void check_intr();

void clctalg(P,VL *);

void comm_muld_trunc(VL vl,DP p1,DP p2,DL dl,DP *pr);

void comm_quod(VL vl,DP p1,DP p2,DP *pr);

void create_modorder_spec(int id,LIST shift,struct modorder_spec **s);

void dalgtoalg(DAlg da,Alg *r);

void divsgz(GZ n1,GZ n2,GZ *nq);

void dp_ht(DP p,DP *rp);

void dp_interreduce(LIST f,LIST v,int field,struct order_spec *ord,LIST *rp);

void dp_mbase(NODE,NODE *);

void dp_nf_tab_f(DP p,LIST *tab,DP *rp);

void dp_ptozp(DP,DP *);

void dp_sort(DP p,DP *rp);

void dp_subd(DP,DP,DP *);

void dp_true_nf(NODE,DP,DP *,int,DP *,P *);

void dp_true_nf_marked(NODE b,DP g,DP *ps,DP *hps,DP *rp,P *nmp,P *dnp);

void dp_true_nf_marked_mod(NODE b,DP g,DP *ps,DP *hps,int mod,DP *rp,P *dnp);

void gbcheck_list(NODE f,int n,VECT *gp,LIST *pp);

void gcdsf(VL vl,P *pa,int k,P *r);

void get_algtree(Obj f,VL *r);

void get_vars(Obj,VL *);

void gfstopgfs(GFS a,V v,P *c);

void henmain_incremental(LUM f,LUM *bqlist,ML cqlist, int np, int mod, int start, int bound);

void iftogfs(int n,GFS *c);

void indextogfs(int index,GFS *c);

void init_denomlist();

void inva_chrem(P p0,P p,NODE *pr);

void itogfs(int n,GFS *c);

void lcmn(N n1,N n2,N *nr);

void makevar(char *,P *);

void mdtodp(DP p,DP *pr);

void mfctrsf(VL vl,P f,DCP *dcp);

void mulp_trunc(VL vl,P p1,P p2,VN vn,P *pr);

void nd_det(int mod,MAT f,P *rp);

void nd_gr(LIST f,LIST v,int m,int homo,int retdp,int f4,struct order_spec *ord,LIST *rp);

void nd_gr_postproc(LIST f,LIST v,int m,struct order_spec *ord,int do_check,LIST *rp);

void nd_gr_recompute_trace(LIST f,LIST v,int m,struct order_spec *ord,LIST tlist,LIST *rp);

void nd_gr_trace(LIST f,LIST v,int trace,int homo,int f4,struct order_spec *ord,LIST *rp);

void nd_nf_p(Obj f,LIST g,LIST v,int m,struct order_spec *ord,Obj *rp);

void obj_algtodalg(Obj obj,Obj *r);

void obj_dalgtoalg(Obj obj,Obj *r);

void ox_bcast_102(int root);

void ox_reduce_102(int root,void (*func)());

void print_to_wfep(Obj obj);

void printn(N);

void printz(Z n);

void pthrootgfs(GFS a,GFS *b);

void quop_trunc(VL vl,P p1,P p2,VN vn,P *pr);

void red_by_vect_sf(int m,unsigned int *p,unsigned int *r,unsigned int hc,int len);

void removecont_array(P *c,int n,int full);

void reset_top_weight();

void setfield_dalg(NODE alist);

void setfield_gb(NODE gb,VL vl,struct order_spec *spec);

void setsecuremode(int value);

void sfbfctr_shift(P f,V x,V y,int degbound,GFS *evp,P *sfp,DCP *dcp);

void sfexgcd_by_hensel(BM g,BM h,int dy,BM *ap,BM *bp);

void sfptopsfp(P f,V v,P *gp);

void simpdalg(DAlg da,DAlg *r);

void simple_derivr(VL vl,Obj a,V v,Obj *b);

void substpp(VL vl,P p,V *vvect,P *svect,int nv,P *pr);

void ufctrsf(P p,DCP *dcp);

void vltopl(VL vl,LIST *l);

int arf_comp(VL, Obj, Obj);

int available_mcindex(int ind);

int compare_zero(int n,int *u,int row,int **w);

int create_composite_order_spec(VL vl,LIST order,struct order_spec **specp);

int create_order_spec(VL,Obj,struct order_spec **);

int dalgtoup(DAlg da,P *up,Q *dn);

int dl_equal(int nv,DL dl1,DL dl2);

int dp_redble(DP,DP);

int dpv_hp(DPV p);

int generic_gauss_elim_hensel(MAT mat,MAT *nmmat,Q *dn,int **rindp,int **cindp);

int generic_gauss_elim_hensel_dalg(MAT mat,DP *mb,MAT *nmmat,Q *dn,int **rindp,int **cindp);

int generic_gauss_elim_mod(int **mat0,int row,int col,int md,int *colstat);

int generic_gauss_elim_mod2(int **mat0,int row,int col,int md,int *colstat,int *rowstat);

int get_field_type(P p);

int get_ox_server_id(int index);

int getsecuremode();

int gz_generic_gauss_elim(MAT mat,MAT *nm,GZ *dn,int **rindp,int **cindp);

int gz_generic_gauss_elim_full(MAT mat,MAT *nm,GZ *dn,int **rindp,int **cindp);

int gz_gensolve_check(MAT mat,MAT nm,GZ dn,int *rind,int *cind);

int gz_gensolve_check2(MAT mat,MAT nm,GZ *dn,int *rind,int *cind);

int gz_intmtoratm(MAT mat,GZ md,MAT nm,GZ *dn);

int gz_intmtoratm2(MAT mat,GZ md,MAT nm,GZ *dn,int *stat);

int gz_inttorat(GZ c,GZ m,GZ b,int *sgnp,GZ *nmp,GZ *dnp);

int gz_intvtoratv(GZ *v,int n,GZ md,GZ b,GZ *nm,GZ *dn);

int invdalg(DAlg a,DAlg *c);

int is_eq(Obj a0,Obj a1);

int length(NODE);

int lu_mod(unsigned int **a,int n,unsigned int md,int **rinfo);

int n_bits_gz(GZ a);

int nd_gauss_elim_gz(GZ **mat0,int *sugar,int row,int col,int *colstat);

int poly_is_dependent(P p,V v);

int setsecureflag(char *name,int value);

int sfdegtest(int dy,int bound,UM *d1c,int k,int *in);

int sgnz(Z n);

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>