version 1.15, 2000/12/08 04:35:30 |
version 1.23, 2001/09/05 08:09:10 |
|
|
* DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE, |
* DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE, |
* PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE. |
* PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE. |
* |
* |
* $OpenXM: OpenXM_contrib2/asir2000/builtin/gr.c,v 1.14 2000/12/08 02:39:05 noro Exp $ |
* $OpenXM: OpenXM_contrib2/asir2000/builtin/gr.c,v 1.22 2001/09/05 01:57:32 noro Exp $ |
*/ |
*/ |
#include "ca.h" |
#include "ca.h" |
#include "parse.h" |
#include "parse.h" |
Line 105 DP_pairs criterion_M(DP_pairs); |
|
Line 105 DP_pairs criterion_M(DP_pairs); |
|
DP_pairs criterion_B(DP_pairs,int); |
DP_pairs criterion_B(DP_pairs,int); |
DP_pairs newpairs(NODE,int); |
DP_pairs newpairs(NODE,int); |
DP_pairs updpairs(DP_pairs,NODE,int); |
DP_pairs updpairs(DP_pairs,NODE,int); |
void _dp_nf(NODE,DP,DP *,int,int,DP *); |
void _dp_nf(NODE,DP,DP *,int,DP *); |
|
void _dp_nf_z(NODE,DP,DP *,int,int,DP *); |
NODE gb_mod(NODE,int); |
NODE gb_mod(NODE,int); |
NODE gbd(NODE,int,NODE,NODE); |
NODE gbd(NODE,int,NODE,NODE); |
NODE gb(NODE,int,NODE); |
NODE gb(NODE,int,NODE); |
Line 134 void pltovl(LIST,VL *); |
|
Line 135 void pltovl(LIST,VL *); |
|
void printdl(DL); |
void printdl(DL); |
int DPPlength(DP_pairs); |
int DPPlength(DP_pairs); |
void dp_gr_mod_main(LIST,LIST,Num,int,struct order_spec *,LIST *); |
void dp_gr_mod_main(LIST,LIST,Num,int,struct order_spec *,LIST *); |
void dp_gr_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_main(LIST,LIST,struct order_spec *,LIST *); |
void dp_f4_mod_main(LIST,LIST,int,struct order_spec *,LIST *); |
void dp_f4_mod_main(LIST,LIST,int,struct order_spec *,LIST *); |
double get_rtime(); |
double get_rtime(); |
|
|
|
|
static int *pss; |
static int *pss; |
static int psn,pslen; |
static int psn,pslen; |
static int NVars,CNVars,PCoeffs; |
static int NVars,CNVars; |
static VL VC; |
static VL VC; |
|
|
|
int PCoeffs; |
int DP_Print = 0; |
int DP_Print = 0; |
int DP_Multiple = 0; |
int DP_Multiple = 0; |
|
int DP_NFStat = 0; |
LIST Dist = 0; |
LIST Dist = 0; |
int NoGCD = 0; |
int NoGCD = 0; |
int GenTrace = 0; |
int GenTrace = 0; |
int OXCheck = -1; |
int OXCheck = -1; |
|
|
static DP_NFStat = 0; |
|
static int NoSugar = 0; |
static int NoSugar = 0; |
static int NoCriB = 0; |
static int NoCriB = 0; |
static int NoGC = 0; |
static int NoGC = 0; |
Line 178 static int PtozpRA = 0; |
|
Line 180 static int PtozpRA = 0; |
|
|
|
int doing_f4; |
int doing_f4; |
NODE TraceList; |
NODE TraceList; |
|
NODE AllTraceList; |
|
|
int eqdl(nv,dl1,dl2) |
int eqdl(nv,dl1,dl2) |
int nv; |
int nv; |
|
|
printf("\n"); |
printf("\n"); |
} |
} |
|
|
void dp_gr_main(f,v,homo,modular,ord,rp) |
void dp_gr_main(f,v,homo,modular,field,ord,rp) |
LIST f,v; |
LIST f,v; |
Num homo; |
Num homo; |
int modular; |
int modular,field; |
struct order_spec *ord; |
struct order_spec *ord; |
LIST *rp; |
LIST *rp; |
{ |
{ |
int i,mindex,m,nochk; |
int i,mindex,m,nochk; |
struct order_spec ord1; |
struct order_spec ord1; |
|
Q q; |
VL fv,vv,vc; |
VL fv,vv,vc; |
NODE fd,fd0,fi,fi0,r,r0,t,subst,x,s,xx; |
NODE fd,fd0,fi,fi0,r,r0,t,subst,x,s,xx; |
|
NODE ind,ind0; |
|
LIST trace,gbindex; |
|
|
mindex = 0; nochk = 0; dp_fcoeffs = 0; |
mindex = 0; nochk = 0; dp_fcoeffs = field; |
get_vars((Obj)f,&fv); pltovl(v,&vv); vlminus(fv,vv,&vc); |
get_vars((Obj)f,&fv); pltovl(v,&vv); vlminus(fv,vv,&vc); |
NVars = length((NODE)vv); PCoeffs = vc ? 1 : 0; VC = vc; |
NVars = length((NODE)vv); PCoeffs = vc ? 1 : 0; VC = vc; |
CNVars = homo ? NVars+1 : NVars; |
CNVars = homo ? NVars+1 : NVars; |
|
|
modular = -modular; nochk = 1; |
modular = -modular; nochk = 1; |
} |
} |
if ( modular ) |
if ( modular ) |
m = modular > 1 ? modular : lprime[mindex]; |
m = modular > 1 ? modular : get_lprime(mindex); |
else |
else |
m = 0; |
m = 0; |
makesubst(vc,&subst); |
makesubst(vc,&subst); |
|
|
if ( modular > 1 ) { |
if ( modular > 1 ) { |
*rp = 0; return; |
*rp = 0; return; |
} else |
} else |
m = lprime[++mindex]; |
m = get_lprime(++mindex); |
makesubst(vc,&subst); |
makesubst(vc,&subst); |
psn = length(s); |
psn = length(s); |
for ( i = psn; i < pslen; i++ ) { |
for ( i = psn; i < pslen; i++ ) { |
pss[i] = 0; psh[i] = 0; psc[i] = 0; ps[i] = 0; |
pss[i] = 0; psh[i] = 0; psc[i] = 0; ps[i] = 0; |
} |
} |
} |
} |
for ( r0 = 0; x; x = NEXT(x) ) { |
for ( r0 = 0, ind0 = 0; x; x = NEXT(x) ) { |
NEXTNODE(r0,r); dp_load((int)BDY(x),&ps[(int)BDY(x)]); |
NEXTNODE(r0,r); dp_load((int)BDY(x),&ps[(int)BDY(x)]); |
dtop(CO,vv,ps[(int)BDY(x)],(P *)&BDY(r)); |
dtop(CO,vv,ps[(int)BDY(x)],(P *)&BDY(r)); |
|
NEXTNODE(ind0,ind); |
|
STOQ((int)BDY(x),q); BDY(ind) = q; |
} |
} |
if ( r0 ) NEXT(r) = 0; |
if ( r0 ) NEXT(r) = 0; |
|
if ( ind0 ) NEXT(ind) = 0; |
MKLIST(*rp,r0); |
MKLIST(*rp,r0); |
|
MKLIST(gbindex,ind0); |
|
|
|
if ( GenTrace && OXCheck < 0 ) { |
|
|
|
x = AllTraceList; |
|
for ( r = 0; x; x = NEXT(x) ) { |
|
MKNODE(r0,BDY(x),r); r = r0; |
|
} |
|
MKLIST(trace,r); |
|
r0 = mknode(3,*rp,gbindex,trace); |
|
MKLIST(*rp,r0); |
|
} |
print_stat(); |
print_stat(); |
if ( ShowMag ) |
if ( ShowMag ) |
fprintf(asir_out,"\nMax_mag=%d\n",Max_mag); |
fprintf(asir_out,"\nMax_mag=%d\n",Max_mag); |
|
|
VL fv,vv,vc; |
VL fv,vv,vc; |
NODE fd,fd0,r,r0,t,x,s,xx; |
NODE fd,fd0,r,r0,t,x,s,xx; |
DP a,b,c; |
DP a,b,c; |
|
extern struct oEGT eg_red_mod; |
|
|
get_vars((Obj)f,&fv); pltovl(v,&vv); vlminus(fv,vv,&vc); |
get_vars((Obj)f,&fv); pltovl(v,&vv); vlminus(fv,vv,&vc); |
NVars = length((NODE)vv); PCoeffs = vc ? 1 : 0; VC = vc; |
NVars = length((NODE)vv); PCoeffs = vc ? 1 : 0; VC = vc; |
|
|
if ( homo ) { |
if ( homo ) { |
initd(&ord1); CNVars = NVars+1; |
initd(&ord1); CNVars = NVars+1; |
} |
} |
|
/* init_eg(&eg_red_mod); */ |
x = gb_mod(s,m); |
x = gb_mod(s,m); |
|
/* print_eg("Red_mod",&eg_red_mod); */ |
if ( homo ) { |
if ( homo ) { |
reducebase_dehomo(x,&xx); x = xx; |
reducebase_dehomo(x,&xx); x = xx; |
initd(ord); CNVars = NVars; |
initd(ord); CNVars = NVars; |
|
|
for ( j = 0; j < spcol; j++ ) |
for ( j = 0; j < spcol; j++ ) |
if ( spmat[i][j] ) |
if ( spmat[i][j] ) |
nonzero++; |
nonzero++; |
if ( DP_Print ) |
if ( DP_Print && nsp ) |
fprintf(asir_out,"spmat : %d x %d (nonzero=%f%%)...", |
fprintf(asir_out,"spmat : %d x %d (nonzero=%f%%)...", |
nsp,spcol,((double)nonzero*100)/(nsp*spcol)); |
nsp,spcol,((double)nonzero*100)/(nsp*spcol)); |
rank = generic_gauss_elim_mod(spmat,nsp,spcol,m,colstat); |
if ( nsp ) |
|
rank = generic_gauss_elim_mod(spmat,nsp,spcol,m,colstat); |
|
else |
|
rank = 0; |
get_eg(&tmp1); add_eg(&eg_elim2,&tmp0,&tmp1); |
get_eg(&tmp1); add_eg(&eg_elim2,&tmp0,&tmp1); |
init_eg(&eg_split_elim2); add_eg(&eg_split_elim2,&tmp0,&tmp1); |
init_eg(&eg_split_elim2); add_eg(&eg_split_elim2,&tmp0,&tmp1); |
|
|
|
|
int i; |
int i; |
NODE s,s0,f0; |
NODE s,s0,f0; |
|
|
|
#if 1 |
f0 = f = NODE_sortb(f,1); |
f0 = f = NODE_sortb(f,1); |
|
#else |
|
f0 = f; |
|
#endif |
psn = length(f); pslen = 2*psn; |
psn = length(f); pslen = 2*psn; |
ps = (DP *)MALLOC(pslen*sizeof(DP)); |
ps = (DP *)MALLOC(pslen*sizeof(DP)); |
psh = (DL *)MALLOC(pslen*sizeof(DL)); |
psh = (DL *)MALLOC(pslen*sizeof(DL)); |
|
|
pss[i] = ps[i]->sugar; |
pss[i] = ps[i]->sugar; |
psc[i] = BDY(ps[i])->c; |
psc[i] = BDY(ps[i])->c; |
} |
} |
if ( GenTrace && (OXCheck >= 0) ) { |
if ( GenTrace ) { |
Q q; |
Q q; |
STRING fname; |
STRING fname; |
LIST input; |
LIST input; |
NODE arg; |
NODE arg,t,t1; |
Obj dmy; |
Obj dmy; |
|
|
|
t = 0; |
|
for ( i = psn-1; i >= 0; i-- ) { |
|
MKNODE(t1,ps[i],t); |
|
t = t1; |
|
} |
|
MKLIST(input,t); |
|
|
STOQ(OXCheck,q); |
if ( OXCheck >= 0 ) { |
MKSTR(fname,"register_input"); |
STOQ(OXCheck,q); |
MKLIST(input,f0); |
MKSTR(fname,"register_input"); |
arg = mknode(3,q,fname,input); |
arg = mknode(3,q,fname,input); |
Pox_cmo_rpc(arg,&dmy); |
Pox_cmo_rpc(arg,&dmy); |
|
} else if ( OXCheck < 0 ) { |
|
MKNODE(AllTraceList,input,0); |
|
} |
} |
} |
for ( s0 = 0, i = 0; i < psn; i++ ) { |
for ( s0 = 0, i = 0; i < psn; i++ ) { |
NEXTNODE(s0,s); BDY(s) = (pointer)i; |
NEXTNODE(s0,s); BDY(s) = (pointer)i; |
|
|
else |
else |
dp_ptozp(f,r); |
dp_ptozp(f,r); |
if ( GenTrace && TraceList ) { |
if ( GenTrace && TraceList ) { |
|
/* adust the denominator according to the final |
|
content reduction */ |
divsp(CO,BDY(f)->c,BDY(*r)->c,&d); |
divsp(CO,BDY(f)->c,BDY(*r)->c,&d); |
mulp(CO,(P)ARG3(BDY((LIST)BDY(TraceList))),d,&t); |
mulp(CO,(P)ARG3(BDY((LIST)BDY(TraceList))),d,&t); |
ARG3(BDY((LIST)BDY(TraceList))) = t; |
ARG3(BDY((LIST)BDY(TraceList))) = t; |
|
|
MKLIST(hist,node); |
MKLIST(hist,node); |
MKNODE(TraceList,hist,0); |
MKNODE(TraceList,hist,0); |
} |
} |
_dp_nf(top,ps[w[i]],ps,1,PtozpRA?DP_Multiple:0,&g); |
_dp_nf(top,ps[w[i]],ps,1,&g); |
prim_part(g,0,&g1); |
prim_part(g,0,&g1); |
get_eg(&tmp1); add_eg(&eg_ra,&tmp0,&tmp1); |
get_eg(&tmp1); add_eg(&eg_ra,&tmp0,&tmp1); |
if ( DP_Print || DP_PrintShort ) { |
if ( DP_Print || DP_PrintShort ) { |
|
|
_dp_mod(a,m,subst,&psm[psn]); |
_dp_mod(a,m,subst,&psm[psn]); |
if ( GenTrace ) { |
if ( GenTrace ) { |
NODE tn,tr,tr1; |
NODE tn,tr,tr1; |
LIST trace; |
LIST trace,trace1; |
|
NODE arg; |
|
Q q1,q2; |
|
STRING fname; |
|
Obj dmy; |
|
|
/* reverse the TraceList */ |
/* reverse the TraceList */ |
tn = TraceList; |
tn = TraceList; |
|
|
} |
} |
MKLIST(trace,tr); |
MKLIST(trace,tr); |
if ( OXCheck >= 0 ) { |
if ( OXCheck >= 0 ) { |
NODE arg; |
|
Q q1,q2; |
|
STRING fname; |
|
Obj dmy; |
|
|
|
STOQ(OXCheck,q1); |
STOQ(OXCheck,q1); |
MKSTR(fname,"check_trace"); |
MKSTR(fname,"check_trace"); |
STOQ(psn,q2); |
STOQ(psn,q2); |
arg = mknode(5,q1,fname,a,q2,trace); |
arg = mknode(5,q1,fname,a,q2,trace); |
Pox_cmo_rpc(arg,&dmy); |
Pox_cmo_rpc(arg,&dmy); |
|
} else if ( OXCheck < 0 ) { |
|
STOQ(psn,q1); |
|
tn = mknode(2,q1,trace); |
|
MKLIST(trace1,tn); |
|
MKNODE(tr,trace1,AllTraceList); |
|
AllTraceList = tr; |
} else |
} else |
dp_save(psn,(Obj)trace,"t"); |
dp_save(psn,(Obj)trace,"t"); |
TraceList = 0; |
TraceList = 0; |
|
|
new_sugar = h->sugar; |
new_sugar = h->sugar; |
get_eg(&tnf0); |
get_eg(&tnf0); |
t_0 = get_rtime(); |
t_0 = get_rtime(); |
_dp_nf(gall,h,ps,!Top,DP_Multiple,&nf); |
if ( PCoeffs || dp_fcoeffs ) |
|
_dp_nf(gall,h,ps,!Top,&nf); |
|
else |
|
_dp_nf_z(gall,h,ps,!Top,DP_Multiple,&nf); |
if ( DP_Print ) |
if ( DP_Print ) |
fprintf(asir_out,"(%.3g)",get_rtime()-t_0); |
fprintf(asir_out,"(%.3g)",get_rtime()-t_0); |
get_eg(&tnf1); add_eg(&eg_nf,&tnf0,&tnf1); |
get_eg(&tnf1); add_eg(&eg_nf,&tnf0,&tnf1); |
|
|
while ( d ) { |
while ( d ) { |
l = d; d = NEXT(d); |
l = d; d = NEXT(d); |
get_eg(&tmp0); |
get_eg(&tmp0); |
dp_load(l->dp1,&dp1); dp_load(l->dp2,&dp2); dp_sp(dp1,dp2,&h); |
dp_load(l->dp1,&dp1); dp_load(l->dp2,&dp2); |
_dp_nf(gall,h,ps,1,0,&nf); |
dp_sp(dp1,dp2,&h); |
|
/* fprintf(stderr,"{%d,%d}",l->dp1,l->dp2); */ |
|
_dp_nf(gall,h,ps,1,&nf); |
get_eg(&tmp1); add_eg(&eg_gc,&tmp0,&tmp1); |
get_eg(&tmp1); add_eg(&eg_gc,&tmp0,&tmp1); |
if ( DP_Print || DP_PrintShort ) { |
if ( DP_Print || DP_PrintShort ) { |
fprintf(asir_out,"."); fflush(asir_out); |
fprintf(asir_out,"."); fflush(asir_out); |
|
|
} |
} |
for ( ; f; f = NEXT(f) ) { |
for ( ; f; f = NEXT(f) ) { |
get_eg(&tmp0); |
get_eg(&tmp0); |
_dp_nf(x,(DP)BDY(f),ps,1,0,&g); |
_dp_nf(x,(DP)BDY(f),ps,1,&g); |
get_eg(&tmp1); add_eg(&eg_mc,&tmp0,&tmp1); |
get_eg(&tmp1); add_eg(&eg_mc,&tmp0,&tmp1); |
if ( DP_Print ) { |
if ( DP_Print ) { |
print_split_eg(&tmp0,&tmp1); fflush(asir_out); |
print_split_eg(&tmp0,&tmp1); fflush(asir_out); |
|
|
STOQ(Reverse,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"Reverse"); MKNODE(n1,name,n); n = n1; |
STOQ(Reverse,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"Reverse"); MKNODE(n1,name,n); n = n1; |
STOQ(Stat,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"Stat"); MKNODE(n1,name,n); n = n1; |
STOQ(Stat,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"Stat"); MKNODE(n1,name,n); n = n1; |
STOQ(DP_Print,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"Print"); MKNODE(n1,name,n); n = n1; |
STOQ(DP_Print,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"Print"); MKNODE(n1,name,n); n = n1; |
|
STOQ(DP_PrintShort,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"PrintShort"); MKNODE(n1,name,n); n = n1; |
STOQ(DP_NFStat,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"NFStat"); MKNODE(n1,name,n); n = n1; |
STOQ(DP_NFStat,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"NFStat"); MKNODE(n1,name,n); n = n1; |
STOQ(OXCheck,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"OXCheck"); MKNODE(n1,name,n); n = n1; |
STOQ(OXCheck,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"OXCheck"); MKNODE(n1,name,n); n = n1; |
STOQ(GenTrace,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"GenTrace"); MKNODE(n1,name,n); n = n1; |
STOQ(GenTrace,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"GenTrace"); MKNODE(n1,name,n); n = n1; |
|
|
} |
} |
} |
} |
|
|
void _dp_nf(b,g,ps,full,multiple,r) |
void _dp_nf(b,g,ps,full,rp) |
NODE b; |
NODE b; |
DP g; |
DP g; |
DP *ps; |
DP *ps; |
|
int full; |
|
DP *rp; |
|
{ |
|
DP u,p,d,s,t,mult; |
|
P coef; |
|
NODE l; |
|
MP m,mr; |
|
int sugar,psugar; |
|
|
|
if ( !g ) { |
|
*rp = 0; return; |
|
} |
|
sugar = g->sugar; |
|
for ( d = 0; g; ) { |
|
for ( u = 0, l = b; l; l = NEXT(l) ) { |
|
if ( dl_redble(BDY(g)->dl,psh[(int)BDY(l)]) ) { |
|
dp_load((int)BDY(l),&p); |
|
/* t+u = coef*(d+g) - mult*p (t = coef*d) */ |
|
dp_red(d,g,p,&t,&u,&coef,&mult); |
|
psugar = (BDY(g)->dl->td - BDY(p)->dl->td) + p->sugar; |
|
sugar = MAX(sugar,psugar); |
|
if ( GenTrace ) { |
|
LIST hist; |
|
Q cq; |
|
NODE node,node0; |
|
|
|
STOQ((int)BDY(l),cq); |
|
node0 = mknode(4,coef,cq,mult,ONE); |
|
MKLIST(hist,node0); |
|
MKNODE(node,hist,TraceList); TraceList = node; |
|
} |
|
if ( !u ) { |
|
if ( d ) |
|
d->sugar = sugar; |
|
*rp = d; return; |
|
} |
|
d = t; |
|
break; |
|
} |
|
} |
|
if ( u ) |
|
g = u; |
|
else if ( !full ) { |
|
if ( g ) { |
|
MKDP(g->nv,BDY(g),t); t->sugar = sugar; g = t; |
|
} |
|
*rp = g; return; |
|
} else { |
|
m = BDY(g); NEWMP(mr); mr->dl = m->dl; mr->c = m->c; |
|
NEXT(mr) = 0; MKDP(g->nv,mr,t); t->sugar = mr->dl->td; |
|
addd(CO,d,t,&s); d = s; |
|
dp_rest(g,&t); g = t; |
|
} |
|
} |
|
if ( d ) |
|
d->sugar = sugar; |
|
*rp = d; |
|
} |
|
|
|
void _dp_nf_z(b,g,ps,full,multiple,r) |
|
NODE b; |
|
DP g; |
|
DP *ps; |
int full,multiple; |
int full,multiple; |
DP *r; |
DP *r; |
{ |
{ |
|
|
int sugar,psugar; |
int sugar,psugar; |
NODE dist; |
NODE dist; |
STRING imul; |
STRING imul; |
int ndist; |
|
int kara_bit; |
int kara_bit; |
double get_rtime(); |
double get_rtime(); |
double t_0,t_00,tt,ttt,t_p,t_m,t_g,t_a; |
double t_0,t_00,tt,ttt,t_p,t_m,t_g,t_a; |
|
|
|
|
denom = Denominator?Denominator:1; |
denom = Denominator?Denominator:1; |
hmag = multiple*HMAG(g)/denom; |
hmag = multiple*HMAG(g)/denom; |
if ( Dist ) { |
|
dist = BDY(Dist); |
|
ndist = length(dist); |
|
} |
|
sugar = g->sugar; |
sugar = g->sugar; |
|
|
dc = 0; dp = 0; rc = ONE; rp = g; |
dc = 0; dp = 0; rc = ONE; rp = g; |
|
|
if ( u ) { |
if ( u ) { |
if ( multiple && HMAG(u) > hmag ) { |
if ( multiple && HMAG(u) > hmag ) { |
t_0 = get_rtime(); |
t_0 = get_rtime(); |
if ( Dist && HMAG(u) > mpi_mag ) { |
dp_ptozp_d(u,&rp); |
if ( DP_NFStat ) |
|
fprintf(asir_out,"D"); |
|
dp_ptozp_d(dist,ndist,u,&rp); |
|
} else { |
|
if ( DP_NFStat ) |
|
fprintf(asir_out,"L"); |
|
dp_ptozp_d(0,0,u,&rp); |
|
} |
|
tt = get_rtime(); t_g += tt-t_0; |
tt = get_rtime(); t_g += tt-t_0; |
|
|
divsq((Q)BDY(u)->c,(Q)BDY(rp)->c,&cont); |
divsq((Q)BDY(u)->c,(Q)BDY(rp)->c,&cont); |
|
|
NODE tn,dist,n0,n1,n2; |
NODE tn,dist,n0,n1,n2; |
Obj dmy; |
Obj dmy; |
STRING imul; |
STRING imul; |
|
|
extern LIST Dist; |
extern LIST Dist; |
|
|
if ( !p || !q ) { |
if ( !p || !q ) { |