OpenXM_contrib2/asir2000/builtin/gr.c - diff

Return to gr.c CVS log

Up to [local] / OpenXM_contrib2 / asir2000 / builtin

Diff for /OpenXM_contrib2/asir2000/builtin/gr.c between version 1.36 and 1.37

version 1.36, 2001/10/01 01:58:02

version 1.37, 2001/10/09 01:36:06

Line 45

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

* PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.

* $OpenXM: OpenXM_contrib2/asir2000/builtin/gr.c,v 1.35 2001/09/18 00:56:05 noro Exp $

* $OpenXM: OpenXM_contrib2/asir2000/builtin/gr.c,v 1.36 2001/10/01 01:58:02 noro Exp $

#include "ca.h"

#include "parse.h"

Line 60

#define INLINE

#endif

#define NEXTVL(r,c) \

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

#define HMAG(p) (p_mag(BDY(p)->c))

struct dp_pairs {

#define NEWDP_pairs ((DP_pairs)MALLOC(sizeof(struct dp_pairs)))

int dp1, dp2;

DL lcm;

int sugar;

struct dp_pairs *next;

};

typedef struct dp_pairs *DP_pairs;

static DP_pairs collect_pairs_of_hdlcm( DP_pairs d1, DP_pairs *prest );

double get_rtime();

#define NEWDPP(a) ((a)=(DP_pairs)MALLOC(sizeof(struct dp_pairs)))

#define NEXTDPP(r,c) \

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

struct oEGT eg_nf,eg_nfm;

struct oEGT eg_znfm,eg_pz,eg_np,eg_ra,eg_mc,eg_gc;

int TP,NBP,NMP,NFP,NDP,ZR,NZR;

#define NEWDP_pairs ((DP_pairs)MALLOC(sizeof(struct dp_pairs)))

extern int (*cmpdl)();

extern int do_weyl;

extern DP_Print;

void dptoca(DP,unsigned int **);

void _tf_to_vect_compress(NODE,DL *,CDP *);

NODE mul_dllist(DL,DP);

void dp_imul_d(DP,Q,DP *);

void print_stat(void);

void init_stat(void);

int dp_load_t(int,DP *);

void dp_load(int,DP *);

void dp_save(int,Obj,char *);

void dp_make_flaglist(LIST *);

void dp_set_flag(Obj,Obj);

int membercheck(NODE,NODE);

int gbcheck(NODE);

int dl_redble(DL,DL);

NODE remove_reducibles(NODE,int);

NODE updbase(NODE,int);

DP_pairs criterion_F(DP_pairs);

int criterion_2(int,int);

static DP_pairs collect_pairs_of_hdlcm(DP_pairs,DP_pairs *);

DP_pairs criterion_M(DP_pairs);

DP_pairs criterion_B(DP_pairs,int);

DP_pairs newpairs(NODE,int);

DP_pairs updpairs(DP_pairs,NODE,int);

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

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

NODE gb_mod(NODE,int);

NODE gbd(NODE,int,NODE,NODE);

NODE gb(NODE,int,NODE);

NODE gb_f4(NODE);

NODE gb_f4_mod(NODE,int);

NODE gb_f4_mod_old(NODE,int);

DP_pairs minp(DP_pairs, DP_pairs *);

void minsugar(DP_pairs,DP_pairs *,DP_pairs *);

NODE append_one(NODE,int);

void reducebase_dehomo(NODE,NODE *);

int newps_mod(DP,int);

int newps_nosave(DP,int,NODE);

int newps(DP,int,NODE);

void reduceall_mod(NODE,int,NODE *);

void reduceall(NODE,NODE *);

NODE NODE_sortbi(NODE,int);

NODE NODE_sortbi_insert(int, NODE,int);

NODE NODE_sortb(NODE,int);

NODE NODE_sortb_insert(DP,NODE,int);

void prim_part(DP,int,DP *);

void setup_arrays(NODE,int,NODE *);

int validhc(P,int,NODE);

void vlminus(VL,VL,VL *);

void printsubst(NODE);

void makesubst(VL,NODE *);

void pltovl(LIST,VL *);

void printdl(DL);

int DPPlength(DP_pairs);

void dp_gr_mod_main(LIST,LIST,Num,int,struct order_spec *,LIST *);

void dp_gr_main(LIST,LIST,Num,int,int,struct order_spec *,LIST *);

void dp_f4_main(LIST,LIST,struct order_spec *,LIST *);

void dp_f4_mod_main(LIST,LIST,int,struct order_spec *,LIST *);

double get_rtime();

void _dpmod_to_vect(DP,DL *,int *);

void dp_to_vect(DP,DL *,Q *);

NODE dp_dllist(DP f);

NODE symb_merge(NODE,NODE,int),_symb_merge(NODE,NODE,int);

extern int dp_nelim;

extern int dp_fcoeffs;

static DP *ps,*psm;

Line 191 int doing_f4;

Line 115 int doing_f4;

NODE TraceList;

NODE AllTraceList;

INLINE int eqdl(nv,dl1,dl2)

void Pox_cmo_rpc(NODE,Obj *);

int nv;

void Pox_rpc(NODE,Obj *);

DL dl1,dl2;

void Pox_pop_local(NODE,Obj *);

INLINE int eqdl(int nv,DL dl1,DL dl2)

{

int i;

int *b1,*b2;

Line 211 DL dl1,dl2;

Line 137 DL dl1,dl2;

/* b[] should be cleared */

void _dpmod_to_vect(f,at,b)

void _dpmod_to_vect(DP f,DL *at,int *b)

DP f;

DL *at;

int *b;

{

int i,nv;

MP m;

Line 228 int *b;

Line 151 int *b;

/* [t,findex] -> tf -> compressed vector */

void _tf_to_vect_compress(tf,at,b)

void _tf_to_vect_compress(NODE tf,DL *at,CDP *b)

NODE tf;

DL *at;

CDP *b;

{

int i,j,k,nv,len;

DL t,s,d1;

Line 261 CDP *b;

Line 181 CDP *b;

*b = r;

}

void dp_to_vect(f,at,b)

void dp_to_vect(DP f,DL *at,Q *b)

DP f;

DL *at;

Q *b;

{

int i,nv;

MP m;

Line 276 Q *b;

Line 193 Q *b;

}

NODE dp_dllist(f)

NODE dp_dllist(DP f)

DP f;

{

MP m;

NODE mp,mp0;

Line 292 DP f;

Line 208 DP f;

return mp0;

}

NODE mul_dllist(d,f)

NODE mul_dllist(DL d,DP f)

DL d;

DP f;

{

MP m;

NODE mp,mp0;

Line 318 DP f;

Line 232 DP f;

return mp0;

}

void pdl(f)

void pdl(NODE f)

NODE f;

{

while ( f ) {

printdl(BDY(f)); f = NEXT(f);

Line 328 NODE f;

Line 241 NODE f;

printf("\n");

}

void dp_gr_main(f,v,homo,modular,field,ord,rp)

void dp_gr_main(LIST f,LIST v,Num homo,int modular,int field,struct order_spec *ord,LIST *rp)

LIST f,v;

Num homo;

int modular,field;

struct order_spec *ord;

LIST *rp;

{

int i,mindex,m,nochk;

struct order_spec ord1;

Line 433 LIST *rp;

Line 341 LIST *rp;

fprintf(asir_out,"\nMax_mag=%d\n",Max_mag);

}

void dp_gr_mod_main(f,v,homo,m,ord,rp)

void dp_gr_mod_main(LIST f,LIST v,Num homo,int m,struct order_spec *ord,LIST *rp)

LIST f,v;

Num homo;

int m;

struct order_spec *ord;

LIST *rp;

{

struct order_spec ord1;

VL fv,vv,vc;

Line 503 extern struct oEGT eg_red_mod;

Line 406 extern struct oEGT eg_red_mod;

MKLIST(*rp,r0);

}

void dp_f4_main(f,v,ord,rp)

void dp_f4_main(LIST f,LIST v,struct order_spec *ord,LIST *rp)

LIST f,v;

struct order_spec *ord;

LIST *rp;

{

int i,mindex,m,nochk,homogen;

int homogen;

struct order_spec ord1;

VL fv,vv,vc;

NODE fd,fd0,fi,fi0,r,r0,t,subst,x,s,xx;

NODE fd,fd0,r,r0,t,x,s,xx;

dp_fcoeffs = 0;

get_vars((Obj)f,&fv); pltovl(v,&vv); vlminus(fv,vv,&vc);

Line 539 LIST *rp;

Line 438 LIST *rp;

MKLIST(*rp,r0);

}

void dp_f4_mod_main(f,v,m,ord,rp)

void dp_f4_mod_main(LIST f,LIST v,int m,struct order_spec *ord,LIST *rp)

LIST f,v;

int m;

struct order_spec *ord;

LIST *rp;

{

int i,homogen;

int homogen;

struct order_spec ord1;

VL fv,vv,vc;

DP b,c,c1;

NODE fd,fd0,fi,fi0,r,r0,t,subst,x,s,xx;

NODE fd,fd0,r,r0,t,x,s,xx;

dp_fcoeffs = 0;

get_vars((Obj)f,&fv); pltovl(v,&vv); vlminus(fv,vv,&vc);

Line 586 LIST *rp;

Line 480 LIST *rp;

print_stat();

}

NODE gb_f4(f)

NODE gb_f4(NODE f)

NODE f;

{

int i,j,k,nh,row,col,nv;

int i,k,nh,row,col,nv;

NODE r,g,gall;

NODE s,s0;

DP_pairs d,dm,dr,t;

DP h,nf,nf1,f1,f2,f21,f21r,sp,sp1,sd,sdm,tdp;

DP nf,nf1,f2,sp,sd,tdp;

MP mp,mp0;

NODE blist,bt,nt;

NODE blist,bt;

DL *ht,*at;

MAT mat,nm;

int *colstat;

int *rind,*cind;

int rank,nred;

Q dn;

struct oEGT tmp0,tmp1,tmp2,eg_split_symb,eg_split_elim;

struct oEGT tmp0,tmp1,eg_split_symb;

extern struct oEGT eg_mod,eg_elim,eg_chrem,eg_gschk,eg_intrat,eg_symb;

init_eg(&eg_mod); init_eg(&eg_elim); init_eg(&eg_chrem);

Line 709 NODE f;

Line 601 NODE f;

unsigned int **psca;

NODE gb_f4_mod(f,m)

NODE gb_f4_mod(NODE f,int m)

NODE f;

int m;

{

int i,j,k,nh,row,col,nv;

NODE r,g,gall;

NODE s,s0;

DP_pairs d,dm,dr,t;

DP h,nf,f1,f2,f21,f21r,sp,sp1,sd,sdm,tdp;

DP nf,sp,sd,tdp;

MP mp,mp0;

NODE blist,bt,nt,bt1,dt,rhtlist;

NODE blist,bt,bt1,dt;

DL *ht,*at,*st;

DL *at,*st;

int **spmat;

CDP *redmat;

int *colstat,*w,*w1;

Line 728 int m;

Line 618 int m;

int *indred,*isred;

CDP ri;

int pscalen;

struct oEGT tmp0,tmp1,tmp2,eg_split_symb,eg_split_elim1,eg_split_elim2;

struct oEGT tmp0,tmp1,eg_split_symb,eg_split_elim1,eg_split_elim2;

extern struct oEGT eg_symb,eg_elim1,eg_elim2;

/* initialize coeffcient array list of ps[] */

Line 930 int m;

Line 820 int m;

return g;

}

NODE gb_f4_mod_old(f,m)

NODE gb_f4_mod_old(NODE f,int m)

NODE f;

int m;

{

int i,j,k,nh,row,col,nv;

NODE r,g,gall;

NODE s,s0;

DP_pairs d,dm,dr,t;

DP h,nf,f1,f2,f21,f21r,sp,sp1,sd,sdm,tdp;

DP nf,f2,sp,sd,sdm,tdp;

MP mp,mp0;

NODE blist,bt,nt;

NODE blist,bt;

DL *ht,*at,*st;

int **spmat,**redmat;

int *colstat,*w;

int rank,nred,nsp,nonzero,spcol;

int *indred,*isred,*ri;

struct oEGT tmp0,tmp1,tmp2,eg_split_symb,eg_split_elim1,eg_split_elim2;

struct oEGT tmp0,tmp1,eg_split_symb,eg_split_elim1,eg_split_elim2;

extern struct oEGT eg_symb,eg_elim1,eg_elim2;

init_eg(&eg_symb); init_eg(&eg_elim1); init_eg(&eg_elim2);

Line 1100 int m;

Line 988 int m;

return g;

}

int DPPlength(n)

int DPPlength(DP_pairs n)

DP_pairs n;

{

int i;

Line 1109 DP_pairs n;

Line 996 DP_pairs n;

return i;

}

void printdl(dl)

void printdl(DL dl)

DL dl;

{

int i;

Line 1120 DL dl;

Line 1006 DL dl;

fprintf(asir_out,"%d>>",dl->d[i]);

}

void pltovl(l,vl)

void pltovl(LIST l,VL *vl)

LIST l;

VL *vl;

{

NODE n;

VL r,r0;

Line 1135 VL *vl;

Line 1019 VL *vl;

*vl = r0;

}

void makesubst(v,s)

void makesubst(VL v,NODE *s)

VL v;

NODE *s;

{

NODE r,r0;

Q q;

Line 1156 NODE *s;

Line 1038 NODE *s;

*s = r0;

}

void printsubst(s)

void printsubst(NODE s)

NODE s;

{

fputc('[',asir_out);

while ( s ) {

Line 1171 NODE s;

Line 1052 NODE s;

fprintf(asir_out,"]\n"); return;

}

void vlminus(v,w,d)

void vlminus(VL v,VL w,VL *d)

VL v,w,*d;

{

int i,j,n,m;

V *va,*wa;

Line 1202 VL v,w,*d;

Line 1082 VL v,w,*d;

*d = r0;

}

int validhc(a,m,s)

int validhc(P a,int m,NODE s)

P a;

int m;

NODE s;

{

P c,c1;

V v;

Line 1220 NODE s;

Line 1097 NODE s;

return c1 ? 1 : 0;

}

void setup_arrays(f,m,r)

void setup_arrays(NODE f,int m,NODE *r)

NODE f,*r;

int m;

{

int i;

NODE s,s0,f0;

Line 1250 int m;

Line 1125 int m;

STRING fname;

LIST input;

NODE arg,t,t1;

Obj dmy;

Obj obj;

t = 0;

for ( i = psn-1; i >= 0; i-- ) {

Line 1263 int m;

Line 1138 int m;

STOQ(OXCheck,q);

MKSTR(fname,"register_input");

arg = mknode(3,q,fname,input);

Pox_cmo_rpc(arg,&dmy);

Pox_cmo_rpc(arg,&obj);

} else if ( OXCheck < 0 ) {

MKNODE(AllTraceList,input,0);

}

Line 1275 int m;

Line 1150 int m;

*r = s0;

}

void prim_part(f,m,r)

void prim_part(DP f,int m,DP *r)

DP f,*r;

int m;

{

P d,t;

Line 1303 int m;

Line 1176 int m;

}

NODE /* of DP */ NODE_sortb_insert( newdp, nd, dec )

NODE /* of DP */ NODE_sortb_insert( DP newdp, NODE /* of DP */ nd, int dec )

DP newdp;

NODE /* of DP */ nd;

int dec;

{

Line 1325 int dec;

Line 1195 int dec;

return nd;

}

NODE NODE_sortb( node, dec )

NODE NODE_sortb( NODE node, int dec )

NODE node;

int dec;

{

Line 1336 int dec;

Line 1204 int dec;

return ans;

}

NODE /* of index */ NODE_sortbi_insert( newdpi, nd, dec )

NODE /* of index */ NODE_sortbi_insert( int newdpi, NODE /* of index */ nd, int dec )

int newdpi;

NODE /* of index */ nd;

int dec;

{

Line 1358 int dec;

Line 1223 int dec;

return nd;

}

NODE NODE_sortbi( node, dec )

NODE NODE_sortbi( NODE node, int dec )

NODE node;

int dec;

{

Line 1369 int dec;

Line 1232 int dec;

return ans;

}

void reduceall(in,h)

void reduceall(NODE in,NODE *h)

NODE in;

NODE *h;

{

NODE r,t,top;

int n,i,j;

Line 1424 NODE *h;

Line 1285 NODE *h;

fprintf(asir_out,"\n");

}

void reduceall_mod(in,m,h)

void reduceall_mod(NODE in,int m,NODE *h)

NODE in;

int m;

NODE *h;

{

NODE r,t,top;

int n,i,j;

Line 1472 NODE *h;

Line 1330 NODE *h;

fprintf(asir_out,"\n");

}

int newps(a,m,subst)

int newps(DP a,int m,NODE subst)

DP a;

int m;

NODE subst;

{

if ( m && !validhc(!a?0:BDY(a)->c,m,subst) )

return -1;

Line 1507 NODE subst;

Line 1362 NODE subst;

NODE arg;

Q q1,q2;

STRING fname;

Obj dmy;

Obj obj;

/* reverse the TraceList */

tn = TraceList;

Line 1520 NODE subst;

Line 1375 NODE subst;

MKSTR(fname,"check_trace");

STOQ(psn,q2);

arg = mknode(5,q1,fname,a,q2,trace);

Pox_cmo_rpc(arg,&dmy);

Pox_cmo_rpc(arg,&obj);

} else if ( OXCheck < 0 ) {

STOQ(psn,q1);

tn = mknode(2,q1,trace);

Line 1534 NODE subst;

Line 1389 NODE subst;

return psn++;

}

int newps_nosave(a,m,subst)

int newps_nosave(DP a,int m,NODE subst)

DP a;

int m;

NODE subst;

{

if ( m && !validhc(!a?0:BDY(a)->c,m,subst) )

return -1;

Line 1559 NODE subst;

Line 1411 NODE subst;

return psn++;

}

int newps_mod(a,m)

int newps_mod(DP a,int m)

DP a;

int m;

{

if ( psn == pslen ) {

pslen *= 2;

Line 1576 int m;

Line 1426 int m;

return psn++;

}

void reducebase_dehomo(f,g)

void reducebase_dehomo(NODE f,NODE *g)

NODE f,*g;

{

int n,i,j,k;

int *r;

Line 1623 NODE f,*g;

Line 1472 NODE f,*g;

*g = top;

}

NODE append_one(f,n)

NODE append_one(NODE f,int n)

NODE f;

int n;

{

NODE t;

Line 1638 int n;

Line 1485 int n;

}

DP_pairs minp( d, prest )

DP_pairs minp( DP_pairs d, DP_pairs *prest )

DP_pairs d, *prest;

{

Line 1664 DP_pairs d, *prest;

Line 1510 DP_pairs d, *prest;

return m;

}

void minsugar(d,dm,dr)

void minsugar(DP_pairs d,DP_pairs *dm,DP_pairs *dr)

DP_pairs d;

DP_pairs *dm,*dr;

{

int msugar;

DP_pairs t,dm0,dr0,dmt,drt;

Line 1691 DP_pairs *dm,*dr;

Line 1535 DP_pairs *dm,*dr;

*dm = dm0; *dr = dr0;

}

NODE gb(f,m,subst)

NODE gb(NODE f,int m,NODE subst)

NODE f;

int m;

NODE subst;

{

int i,nh,prev,mag;

NODE r,g,gall;

DP_pairs d,d1;

DP_pairs d;

DP_pairs l;

DP h,nf,nfm,dp1,dp2;

MP mp;

struct oEGT tnf0,tnf1,tnfm0,tnfm1,tpz0,tpz1,tsp0,tsp1,tspm0,tspm1,tnp0,tnp1,tmp0,tmp1;

struct oEGT tnf0,tnf1,tnfm0,tnfm1,tpz0,tpz1,tnp0,tnp1;

int skip_nf_flag;

double t_0;

Q q;

Line 1741 NODE subst;

Line 1582 NODE subst;

if ( Demand ) {

if ( dp_load_t(psn,&nf) ) {

skip_nf_flag = 1;

tnf1=tsp1;

goto skip_nf;

} else {

skip_nf_flag = 0;

Line 1822 skip_nf:

Line 1662 skip_nf:

return g;

}

NODE gb_mod(f,m)

NODE gb_mod(NODE f,int m)

NODE f;

int m;

{

int i,nh,prev;

NODE r,g,gall;

DP_pairs d,d1;

DP_pairs d;

DP_pairs l;

DP h,nf;

struct oEGT tnfm0,tnfm1,tspm0,tspm1,tmp0,tmp1,tpz0,tpz1;

struct oEGT tnfm0,tnfm1,tpz0,tpz1;

prev = 1;

for ( gall = g = 0, d = 0, r = f; r; r = NEXT(r) ) {

Line 1886 int m;

Line 1724 int m;

return g;

}

DP_pairs updpairs( d, g, t)

DP_pairs updpairs( DP_pairs d, NODE /* of index */ g, int t)

DP_pairs d;

NODE /* of index */ g;

int t;

{

struct oEGT tup0,tup1;

int dl,dl1;

if ( !g ) return d;

Line 1927 int t;

Line 1761 int t;

return d;

}

DP_pairs newpairs( g, t )

DP_pairs newpairs( NODE /* of index */ g, int t )

NODE /* of index */ g;

{

Line 1955 register int t;

Line 1787 register int t;

return last;

}

DP_pairs criterion_B( d, s )

DP_pairs criterion_B( DP_pairs d, int s )

int s;

{

Line 1980 int s;

Line 1810 int s;

return dd;

}

DP_pairs criterion_M( d1 )

DP_pairs criterion_M( DP_pairs d1 )

DP_pairs d1;

{

Line 2023 DP_pairs d1;

Line 1852 DP_pairs d1;

return dd;

}

static DP_pairs collect_pairs_of_hdlcm( d1, prest )

static DP_pairs collect_pairs_of_hdlcm( DP_pairs d1, DP_pairs *prest )

DP_pairs d1, *prest;

{

Line 2048 DP_pairs d1, *prest;

Line 1876 DP_pairs d1, *prest;

return w;

}

int criterion_2( dp1, dp2 )

int criterion_2( int dp1, int dp2 )

int dp1, dp2;

{

Line 2059 int dp1, dp2;

Line 1886 int dp1, dp2;

return 1;

}

DP_pairs criterion_F( d1 )

DP_pairs criterion_F( DP_pairs d1 )

DP_pairs d1;

{

DP_pairs rest, head;

Line 2083 DP_pairs d1;

Line 1909 DP_pairs d1;

return head;

}

NODE updbase(g,t)

NODE updbase(NODE g,int t)

NODE g;

int t;

{

g = remove_reducibles(g,t);

g = append_one(g,t);

return g;

}

NODE /* of index */ remove_reducibles( nd, newdp )

NODE /* of index */ remove_reducibles(NODE /* of index */ nd, int newdp )

NODE /* of index */ nd;

int newdp;

{

Line 2115 int newdp;

Line 1937 int newdp;

return head;

}

int dl_redble( dl1, dl2 )

int dl_redble(DL dl1,DL dl2)

DL dl1, dl2;

{

Line 2125 DL dl1, dl2;

Line 1946 DL dl1, dl2;

return 1;

}

int dl_weight(dl)

int dl_weight(DL dl)

DL dl;

{

int n,w,i;

Line 2136 DL dl;

Line 1956 DL dl;

return w;

}

int gbcheck(f)

int gbcheck(NODE f)

NODE f;

{

int i;

NODE r,g,gall;

Line 2175 NODE f;

Line 1994 NODE f;

return 1;

}

int membercheck(f,x)

int membercheck(NODE f,NODE x)

NODE f,x;

{

DP g;

struct oEGT tmp0,tmp1;

Line 2203 NODE f,x;

Line 2021 NODE f,x;

return 1;

}

void dp_set_flag(name,value)

void dp_set_flag(Obj name,Obj value)

Obj name,value;

{

char *n;

int v;

Line 2259 Obj name,value;

Line 2076 Obj name,value;

OXCheck = v;

}

void dp_make_flaglist(list)

void dp_make_flaglist(LIST *list)

LIST *list;

{

Q v;

STRING name,path;

Line 2295 LIST *list;

Line 2111 LIST *list;

#define DELIM '/'

void dp_save(index,p,prefix)

void dp_save(int index,Obj p,char *prefix)

int index;

Obj p;

char *prefix;

{

FILE *fp;

char path[BUFSIZ];

Line 2312 char *prefix;

Line 2125 char *prefix;

savevl(fp,VC); saveobj(fp,p); fclose(fp);

}

void dp_load(index,p)

void dp_load(int index,DP *p)

int index;

DP *p;

{

FILE *fp;

char path[BUFSIZ];

Line 2329 DP *p;

Line 2140 DP *p;

}

int dp_load_t(index,p)

int dp_load_t(int index,DP *p)

int index;

DP *p;

{

FILE *fp;

char path[BUFSIZ];

Line 2371 extern int GenTrace;

Line 2180 extern int GenTrace;

extern NODE TraceList;

extern int mpi_mag;

void dp_mulc_d(p,c,r)

void dp_mulc_d(DP p,P c,DP *r)

DP p;

P c;

DP *r;

{

if ( Dist && BDY(Dist)

&& HMAG(p) > mpi_mag

Line 2387 DP *r;

Line 2193 DP *r;

}

void _dp_nf(b,g,ps,full,rp)

void _dp_nf(NODE b,DP g,DP *ps,int full,DP *rp)

NODE b;

DP g;

DP *ps;

int full;

DP *rp;

{

DP u,p,d,s,t,mult;

P coef;

Line 2450 DP *rp;

Line 2251 DP *rp;

*rp = d;

}

void _dp_nf_z(b,g,ps,full,multiple,r)

void _dp_nf_z(NODE b,DP g,DP *ps,int full,int multiple,DP *r)

NODE b;

DP g;

DP *ps;

int full,multiple;

DP *r;

{

DP u,dp,rp,t,t1,t2,red,shift;

DP u,dp,rp,t,t1,red,shift;

Q dc,rc,dcq,rcq,cont,hr,hred,cr,cred,mcred,c,gcd,cq;

N gn,tn,cn;

NODE l;

MP m,mr;

int hmag,denom;

int sugar,psugar;

NODE dist;

STRING imul;

int kara_bit;

double t_0,tt,t_p,t_m,t_g,t_a;

double get_rtime();

double t_0,t_00,tt,ttt,t_p,t_m,t_g,t_a;

LIST hist;

NODE node;

Q rcred,mrcred;

Line 2497 DP *r;

Line 2288 DP *r;

tt = get_rtime(); t_p += tt-t_0;

dp_subd(rp,red,&shift);

dp_mulc_d(rp,cr,&t);

dp_mulc_d(rp,(P)cr,&t);

chsgnp((P)cred,(P *)&mcred);

dp_mulc_d(red,mcred,&t1);

dp_mulc_d(red,(P)mcred,&t1);

muld(CO,shift,t1,&t1);

addd(CO,t,t1,&u);

t_m += get_rtime()-tt;

Line 2594 final:

Line 2385 final:

void imulv();

void dp_imul_d(p,q,rp)

void dp_imul_d(DP p,Q q,DP *rp)

DP p;

Q q;

DP *rp;

{

int nsep,ndist,i,j,k,l,n;

double t0,t1,t2;

Line 2606 DP *rp;

Line 2394 DP *rp;

VECT c,cs,ri;

VECT *r;

MP m;

NODE tn,dist,n0,n1,n2;

NODE tn,dist,n0;

Obj dmy;

Obj obj;

STRING imul;

extern LIST Dist;

Line 2628 DP *rp;

Line 2416 DP *rp;

r = (VECT *)CALLOC(nsep,sizeof(VECT *));

for ( i = 0, tn = dist, b = BDY(cs); i < ndist; i++, tn = NEXT(tn) ) {

n0 = mknode(4,BDY(tn),imul,b[i],q);

Pox_rpc(n0,&dmy);

Pox_rpc(n0,&obj);

}

t1 = get_rtime();

im_t_s += t1 - t0;

Line 2636 DP *rp;

Line 2424 DP *rp;

t1 = get_rtime();

for ( i = 0, tn = dist; i < ndist; i++, tn = NEXT(tn) ) {

MKNODE(n0,BDY(tn),0);

Pox_pop_local(n0,&r[i]);

Pox_pop_local(n0,&obj); r[i] = (VECT)obj;

if ( OID(r[i]) == O_ERR ) {

printexpr(CO,(Obj)r[i]);

error("dp_imul_d : aborted");

Line 2653 DP *rp;

Line 2441 DP *rp;

dp_vtod(s,p,rp);

}

void imulv(w,c,rp)

void imulv(VECT w,Q c,VECT *rp)

VECT w;

Q c;

VECT *rp;

{

int n,i;

VECT r;

Line 2667 VECT *rp;

Line 2452 VECT *rp;

mulq((Q)BDY(w)[i],(Q)c,(Q *)&BDY(r)[i]);

}

void dptoca(p,rp)

void dptoca(DP p,unsigned int **rp)

DP p;

unsigned int **rp;

{

int i;

MP m;

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