version 1.38, 2001/11/16 10:35:07 |
version 1.53, 2003/07/18 10:13:12 |
|
|
* 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.37 2001/10/09 01:36:06 noro Exp $ |
* $OpenXM: OpenXM_contrib2/asir2000/builtin/gr.c,v 1.52 2003/07/16 05:31:21 noro Exp $ |
*/ |
*/ |
#include "ca.h" |
#include "ca.h" |
#include "parse.h" |
#include "parse.h" |
|
|
|
|
int PCoeffs; |
int PCoeffs; |
int DP_Print = 0; |
int DP_Print = 0; |
|
int DP_PrintShort = 0; |
int DP_Multiple = 0; |
int DP_Multiple = 0; |
int DP_NFStat = 0; |
int DP_NFStat = 0; |
LIST Dist = 0; |
LIST Dist = 0; |
Line 101 static int NoCriB = 0; |
|
Line 102 static int NoCriB = 0; |
|
static int NoGC = 0; |
static int NoGC = 0; |
static int NoMC = 0; |
static int NoMC = 0; |
static int NoRA = 0; |
static int NoRA = 0; |
static int DP_PrintShort = 0; |
|
static int ShowMag = 0; |
static int ShowMag = 0; |
static int Stat = 0; |
static int Stat = 0; |
static int Denominator = 1; |
static int Denominator = 1; |
static int Top = 0; |
int Top = 0; |
static int Reverse = 0; |
int Reverse = 0; |
static int Max_mag = 0; |
static int Max_mag = 0; |
|
static int Max_coef = 0; |
static char *Demand = 0; |
static char *Demand = 0; |
static int PtozpRA = 0; |
static int PtozpRA = 0; |
|
|
Line 122 void Pox_pop_local(NODE,Obj *); |
|
Line 123 void Pox_pop_local(NODE,Obj *); |
|
INLINE int eqdl(int nv,DL dl1,DL dl2) |
INLINE int eqdl(int nv,DL dl1,DL dl2) |
{ |
{ |
int i; |
int i; |
int *b1,*b2; |
int *p1,*p2; |
|
|
if ( dl1->td != dl2->td ) |
if ( dl1->td != dl2->td ) |
return 0; |
return 0; |
for ( i = 0, b1 = dl1->d, b2 = dl2->d; i < nv; i++ ) |
i = nv-1; |
if ( b1[i] != b2[i] ) |
p1 = dl1->d; |
break; |
p2 = dl2->d; |
if ( i == nv ) |
while ( i >= 7 ) { |
return 1; |
if ( *p1++ != *p2++ ) return 0; |
else |
if ( *p1++ != *p2++ ) return 0; |
return 0; |
if ( *p1++ != *p2++ ) return 0; |
|
if ( *p1++ != *p2++ ) return 0; |
|
if ( *p1++ != *p2++ ) return 0; |
|
if ( *p1++ != *p2++ ) return 0; |
|
if ( *p1++ != *p2++ ) return 0; |
|
if ( *p1++ != *p2++ ) return 0; |
|
i -= 8; |
|
} |
|
switch ( i ) { |
|
case 6: |
|
if ( *p1++ != *p2++ ) return 0; |
|
if ( *p1++ != *p2++ ) return 0; |
|
if ( *p1++ != *p2++ ) return 0; |
|
if ( *p1++ != *p2++ ) return 0; |
|
if ( *p1++ != *p2++ ) return 0; |
|
if ( *p1++ != *p2++ ) return 0; |
|
if ( *p1++ != *p2++ ) return 0; |
|
return 1; |
|
case 5: |
|
if ( *p1++ != *p2++ ) return 0; |
|
if ( *p1++ != *p2++ ) return 0; |
|
if ( *p1++ != *p2++ ) return 0; |
|
if ( *p1++ != *p2++ ) return 0; |
|
if ( *p1++ != *p2++ ) return 0; |
|
if ( *p1++ != *p2++ ) return 0; |
|
return 1; |
|
case 4: |
|
if ( *p1++ != *p2++ ) return 0; |
|
if ( *p1++ != *p2++ ) return 0; |
|
if ( *p1++ != *p2++ ) return 0; |
|
if ( *p1++ != *p2++ ) return 0; |
|
if ( *p1++ != *p2++ ) return 0; |
|
return 1; |
|
case 3: |
|
if ( *p1++ != *p2++ ) return 0; |
|
if ( *p1++ != *p2++ ) return 0; |
|
if ( *p1++ != *p2++ ) return 0; |
|
if ( *p1++ != *p2++ ) return 0; |
|
return 1; |
|
case 2: |
|
if ( *p1++ != *p2++ ) return 0; |
|
if ( *p1++ != *p2++ ) return 0; |
|
if ( *p1++ != *p2++ ) return 0; |
|
return 1; |
|
case 1: |
|
if ( *p1++ != *p2++ ) return 0; |
|
if ( *p1++ != *p2++ ) return 0; |
|
return 1; |
|
case 0: |
|
if ( *p1++ != *p2++ ) return 0; |
|
return 1; |
|
default: |
|
return 1; |
|
} |
} |
} |
|
|
/* b[] should be cleared */ |
/* b[] should be cleared */ |
Line 338 void dp_gr_main(LIST f,LIST v,Num homo,int modular,int |
|
Line 392 void dp_gr_main(LIST f,LIST v,Num homo,int modular,int |
|
} |
} |
print_stat(); |
print_stat(); |
if ( ShowMag ) |
if ( ShowMag ) |
fprintf(asir_out,"\nMax_mag=%d\n",Max_mag); |
fprintf(asir_out,"\nMax_mag=%d, Max_coef=%d\n",Max_mag, Max_coef); |
} |
} |
|
|
void dp_gr_mod_main(LIST f,LIST v,Num homo,int m,struct order_spec *ord,LIST *rp) |
void dp_gr_mod_main(LIST f,LIST v,Num homo,int m,struct order_spec *ord,LIST *rp) |
Line 600 NODE gb_f4(NODE f) |
|
Line 654 NODE gb_f4(NODE f) |
|
/* initial bases are monic */ |
/* initial bases are monic */ |
|
|
unsigned int **psca; |
unsigned int **psca; |
|
GeoBucket create_bucket(); |
|
DL remove_head_bucket(GeoBucket,int); |
|
|
NODE gb_f4_mod(NODE f,int m) |
NODE gb_f4_mod(NODE f,int m) |
{ |
{ |
Line 618 NODE gb_f4_mod(NODE f,int m) |
|
Line 674 NODE gb_f4_mod(NODE f,int m) |
|
int *indred,*isred; |
int *indred,*isred; |
CDP ri; |
CDP ri; |
int pscalen; |
int pscalen; |
struct oEGT tmp0,tmp1,eg_split_symb,eg_split_elim1,eg_split_elim2; |
GeoBucket bucket; |
extern struct oEGT eg_symb,eg_elim1,eg_elim2; |
DL head; |
|
struct oEGT tmp0,tmp1,eg_split_symb,eg_split_conv,eg_split_elim1,eg_split_elim2; |
|
extern struct oEGT eg_symb,eg_conv,eg_elim1,eg_elim2; |
|
|
/* initialize coeffcient array list of ps[] */ |
/* initialize coeffcient array list of ps[] */ |
pscalen = pslen; |
pscalen = pslen; |
psca = (unsigned int **)MALLOC(pscalen*sizeof(unsigned int *)); |
psca = (unsigned int **)MALLOC(pscalen*sizeof(unsigned int *)); |
|
|
init_eg(&eg_symb); init_eg(&eg_elim1); init_eg(&eg_elim2); |
init_eg(&eg_symb); init_eg(&eg_conv); init_eg(&eg_elim1); init_eg(&eg_elim2); |
for ( gall = g = 0, d = 0, r = f; r; r = NEXT(r) ) { |
for ( gall = g = 0, d = 0, r = f; r; r = NEXT(r) ) { |
i = (int)BDY(r); |
i = (int)BDY(r); |
d = updpairs(d,g,i); |
d = updpairs(d,g,i); |
Line 640 NODE gb_f4_mod(NODE f,int m) |
|
Line 698 NODE gb_f4_mod(NODE f,int m) |
|
minsugar(d,&dm,&dr); d = dr; |
minsugar(d,&dm,&dr); d = dr; |
if ( DP_Print ) |
if ( DP_Print ) |
fprintf(asir_out,"sugar=%d\n",dm->sugar); |
fprintf(asir_out,"sugar=%d\n",dm->sugar); |
blist = 0; s0 = 0; |
blist = 0; |
|
bucket = create_bucket(); |
/* asph : sum of all head terms of spoly */ |
/* asph : sum of all head terms of spoly */ |
for ( t = dm; t; t = NEXT(t) ) { |
for ( t = dm; t; t = NEXT(t) ) { |
_dp_sp_mod(ps[t->dp1],ps[t->dp2],m,&sp); |
_dp_sp_mod(ps[t->dp1],ps[t->dp2],m,&sp); |
/* fprintf(stderr,"splen=%d-",dp_nt(sp)); */ |
/* fprintf(stderr,"splen=%d-",dp_nt(sp)); */ |
if ( sp ) { |
if ( sp ) { |
MKNODE(bt,sp,blist); blist = bt; |
MKNODE(bt,sp,blist); blist = bt; |
s0 = symb_merge(s0,dp_dllist(sp),nv); |
add_bucket(bucket,dp_dllist(sp),nv); |
/* fprintf(stderr,"%d-",length(s0)); */ |
/* fprintf(stderr,"%d-",length(s0)); */ |
} |
} |
} |
} |
|
#if 0 |
if ( DP_Print ) |
if ( DP_Print ) |
fprintf(asir_out,"initial spmat : %d x %d ",length(blist),length(s0)); |
fprintf(asir_out,"initial spmat : %d x %d ",length(blist),length(s0)); |
|
#endif |
/* s0 : all the terms appeared in symbolic reduction */ |
/* s0 : all the terms appeared in symbolic reduction */ |
for ( s = s0, nred = 0; s; s = NEXT(s) ) { |
nred = 0; |
|
s0 = 0; |
|
while ( 1 ) { |
|
head = remove_head_bucket(bucket,nv); |
|
if ( !head ) break; |
|
else { |
|
NEXTNODE(s0,s); |
|
BDY(s) = (pointer)head; |
|
} |
for ( r = gall; r; r = NEXT(r) ) |
for ( r = gall; r; r = NEXT(r) ) |
if ( _dl_redble(BDY(ps[(int)BDY(r)])->dl,BDY(s),nv) ) |
if ( _dl_redble(BDY(ps[(int)BDY(r)])->dl,head,nv) ) |
break; |
break; |
if ( r ) { |
if ( r ) { |
dltod(BDY(s),nv,&tdp); |
dltod(head,nv,&tdp); |
dp_subd(tdp,ps[(int)BDY(r)],&sd); |
dp_subd(tdp,ps[(int)BDY(r)],&sd); |
dt = mul_dllist(BDY(sd)->dl,ps[(int)BDY(r)]); |
dt = mul_dllist(BDY(sd)->dl,ps[(int)BDY(r)]); |
|
add_bucket(bucket,NEXT(dt),nv); |
/* fprintf(stderr,"[%d]",length(dt)); */ |
/* fprintf(stderr,"[%d]",length(dt)); */ |
/* list of [t,f] */ |
/* list of [t,f] */ |
bt1 = mknode(2,BDY(sd)->dl,BDY(r)); |
bt1 = mknode(2,BDY(sd)->dl,BDY(r)); |
MKNODE(bt,bt1,blist); blist = bt; |
MKNODE(bt,bt1,blist); blist = bt; |
symb_merge(s,dt,nv); |
/* fprintf(stderr,"%d-",length(s0)); */ |
/* fprintf(stderr,"%d-",length(s)); */ |
|
nred++; |
nred++; |
} |
} |
} |
} |
|
if ( s0 ) NEXT(s) = 0; |
/* fprintf(stderr,"\n"); */ |
/* fprintf(stderr,"\n"); */ |
|
get_eg(&tmp1); add_eg(&eg_symb,&tmp0,&tmp1); |
|
init_eg(&eg_split_symb); add_eg(&eg_split_symb,&tmp0,&tmp1); |
|
|
if ( DP_Print ) |
if ( DP_Print ) |
fprintf(asir_out,"number of reducers : %d\n",nred); |
fprintf(asir_out,"number of reducers : %d\n",nred); |
|
|
|
get_eg(&tmp0); |
/* the first nred polys in blist are reducers */ |
/* the first nred polys in blist are reducers */ |
/* row = the number of all the polys */ |
/* row = the number of all the polys */ |
for ( r = blist, row = 0; r; r = NEXT(r), row++ ); |
for ( r = blist, row = 0; r; r = NEXT(r), row++ ); |
Line 713 NODE gb_f4_mod(NODE f,int m) |
|
Line 787 NODE gb_f4_mod(NODE f,int m) |
|
for ( j = 0, k = 0; j < col; j++ ) |
for ( j = 0, k = 0; j < col; j++ ) |
if ( !isred[j] ) |
if ( !isred[j] ) |
st[k++] = at[j]; |
st[k++] = at[j]; |
get_eg(&tmp1); add_eg(&eg_symb,&tmp0,&tmp1); |
get_eg(&tmp1); add_eg(&eg_conv,&tmp0,&tmp1); |
init_eg(&eg_split_symb); add_eg(&eg_split_symb,&tmp0,&tmp1); |
init_eg(&eg_split_conv); add_eg(&eg_split_conv,&tmp0,&tmp1); |
|
|
get_eg(&tmp1); |
get_eg(&tmp1); |
/* spoly matrix; stored in reduced form; terms in ht[] are omitted */ |
/* spoly matrix; stored in reduced form; terms in ht[] are omitted */ |
Line 771 NODE gb_f4_mod(NODE f,int m) |
|
Line 845 NODE gb_f4_mod(NODE f,int m) |
|
if ( DP_Print ) { |
if ( DP_Print ) { |
fprintf(asir_out,"done rank = %d\n",rank,row,col); |
fprintf(asir_out,"done rank = %d\n",rank,row,col); |
print_eg("Symb",&eg_split_symb); |
print_eg("Symb",&eg_split_symb); |
|
print_eg("Conv",&eg_split_conv); |
print_eg("Elim1",&eg_split_elim1); |
print_eg("Elim1",&eg_split_elim1); |
print_eg("Elim2",&eg_split_elim2); |
print_eg("Elim2",&eg_split_elim2); |
fprintf(asir_out,"\n"); |
fprintf(asir_out,"\n"); |
Line 813 NODE gb_f4_mod(NODE f,int m) |
|
Line 888 NODE gb_f4_mod(NODE f,int m) |
|
} |
} |
if ( DP_Print ) { |
if ( DP_Print ) { |
print_eg("Symb",&eg_symb); |
print_eg("Symb",&eg_symb); |
|
print_eg("Conv",&eg_conv); |
print_eg("Elim1",&eg_elim1); |
print_eg("Elim1",&eg_elim1); |
print_eg("Elim2",&eg_elim2); |
print_eg("Elim2",&eg_elim2); |
fflush(asir_out); |
fflush(asir_out); |
Line 1158 void prim_part(DP f,int m,DP *r) |
|
Line 1234 void prim_part(DP f,int m,DP *r) |
|
if ( PCoeffs ) |
if ( PCoeffs ) |
dp_prim_mod(f,m,r); |
dp_prim_mod(f,m,r); |
else |
else |
*r = f; |
_dp_monic(f,m,r); |
} else { |
} else { |
if ( dp_fcoeffs ) |
if ( dp_fcoeffs || PCoeffs ) |
*r = f; |
|
else if ( PCoeffs ) |
|
dp_prim(f,r); |
dp_prim(f,r); |
else |
else |
dp_ptozp(f,r); |
dp_ptozp(f,r); |
Line 1537 void minsugar(DP_pairs d,DP_pairs *dm,DP_pairs *dr) |
|
Line 1611 void minsugar(DP_pairs d,DP_pairs *dm,DP_pairs *dr) |
|
|
|
NODE gb(NODE f,int m,NODE subst) |
NODE gb(NODE f,int m,NODE subst) |
{ |
{ |
int i,nh,prev,mag; |
int i,nh,prev,mag,mag0,magt; |
NODE r,g,gall; |
NODE r,g,gall; |
DP_pairs d; |
DP_pairs d; |
DP_pairs l; |
DP_pairs l; |
Line 1551 NODE gb(NODE f,int m,NODE subst) |
|
Line 1625 NODE gb(NODE f,int m,NODE subst) |
|
static prev_sugar = -1; |
static prev_sugar = -1; |
|
|
Max_mag = 0; |
Max_mag = 0; |
|
Max_coef = 0; |
prev = 1; |
prev = 1; |
doing_f4 = 0; |
doing_f4 = 0; |
if ( m ) { |
if ( m ) { |
Line 1602 NODE gb(NODE f,int m,NODE subst) |
|
Line 1677 NODE gb(NODE f,int m,NODE subst) |
|
_dp_nf(gall,h,ps,!Top,&nf); |
_dp_nf(gall,h,ps,!Top,&nf); |
else |
else |
_dp_nf_z(gall,h,ps,!Top,DP_Multiple,&nf); |
_dp_nf_z(gall,h,ps,!Top,DP_Multiple,&nf); |
if ( DP_Print ) |
if ( DP_Print && nf ) |
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); |
} else |
} else |
|
|
g = updbase(g,nh); |
g = updbase(g,nh); |
gall = append_one(gall,nh); |
gall = append_one(gall,nh); |
if ( !dp_fcoeffs && ShowMag ) { |
if ( !dp_fcoeffs && ShowMag ) { |
for ( mag = 0, mp = BDY(h); mp; mp = NEXT(mp) ) |
for ( mag = 0, mag0 = 0, mp = BDY(h); mp; mp = NEXT(mp) ) { |
mag += p_mag((P)mp->c); |
magt = p_mag((P)mp->c); |
|
mag0 = MAX(mag0,magt); |
|
mag += magt; |
|
} |
|
Max_coef = MAX(Max_coef,mag0); |
Max_mag = MAX(Max_mag,mag); |
Max_mag = MAX(Max_mag,mag); |
} |
} |
if ( DP_Print ) { |
if ( DP_Print ) { |
|
|
l->dp1,l->dp2,length(g),length(gall),DPPlength(d), |
l->dp1,l->dp2,length(g),length(gall),DPPlength(d), |
pss[nh]); |
pss[nh]); |
if ( ShowMag ) |
if ( ShowMag ) |
fprintf(asir_out,",mag=%d",mag); |
fprintf(asir_out,",mag=(%d,%d)",mag,mag0); |
fprintf(asir_out,"\n"); fflush(asir_out); |
fprintf(asir_out,"\n"); fflush(asir_out); |
} else if ( DP_PrintShort ) { |
} else if ( DP_PrintShort ) { |
fprintf(asir_out,"+"); fflush(asir_out); |
fprintf(asir_out,"+"); fflush(asir_out); |
Line 1779 DP_pairs newpairs( NODE /* of index */ g, int t ) |
|
Line 1858 DP_pairs newpairs( NODE /* of index */ g, int t ) |
|
p->lcm = lcm_of_DL(CNVars, dl = psh[dp], tdl, (DL)0 ); |
p->lcm = lcm_of_DL(CNVars, dl = psh[dp], tdl, (DL)0 ); |
#if 0 |
#if 0 |
if ( do_weyl ) |
if ( do_weyl ) |
p->sugar = dl_weight(p->lcm); |
p->sugar = dl_weyl_weight(p->lcm); |
else |
else |
#endif |
#endif |
p->sugar = (ts > (s = pss[dp] - dl->td) ? ts : s) + p->lcm->td; |
p->sugar = (ts > (s = pss[dp] - dl->td) ? ts : s) + p->lcm->td; |
Line 1895 DP_pairs criterion_F( DP_pairs d1 ) |
|
Line 1974 DP_pairs criterion_F( DP_pairs d1 ) |
|
for ( head = last = 0, p = d1; NEXT(p); ) { |
for ( head = last = 0, p = d1; NEXT(p); ) { |
s = (r = w = collect_pairs_of_hdlcm( p, &rest ))->sugar; |
s = (r = w = collect_pairs_of_hdlcm( p, &rest ))->sugar; |
while ( w = NEXT(w) ) |
while ( w = NEXT(w) ) |
if ( criterion_2( w->dp1, w->dp2 ) ) { |
if ( !do_weyl && criterion_2( w->dp1, w->dp2 ) ) { |
r = w; |
r = w; |
break; |
break; |
} else if ( w->sugar < s ) s = (r = w)->sugar; |
} else if ( w->sugar < s ) s = (r = w)->sugar; |
Line 1946 int dl_redble(DL dl1,DL dl2) |
|
Line 2025 int dl_redble(DL dl1,DL dl2) |
|
return 1; |
return 1; |
} |
} |
|
|
int dl_weight(DL dl) |
#if 0 |
|
int dl_weyl_weight(DL dl) |
{ |
{ |
int n,w,i; |
int n,w,i; |
|
|
Line 1955 int dl_weight(DL dl) |
|
Line 2035 int dl_weight(DL dl) |
|
w += (-dl->d[i]+dl->d[n+i]); |
w += (-dl->d[i]+dl->d[n+i]); |
return w; |
return w; |
} |
} |
|
#endif |
|
|
int gbcheck(NODE f) |
int gbcheck(NODE f) |
{ |
{ |
Line 1994 int gbcheck(NODE f) |
|
Line 2075 int gbcheck(NODE f) |
|
return 1; |
return 1; |
} |
} |
|
|
void gbcheck_list(NODE f,LIST *gp,LIST *pp) |
void gbcheck_list(NODE f,int n,VECT *gp,LIST *pp) |
{ |
{ |
int i; |
int i; |
NODE r,g,gall,u,u0,t; |
NODE r,g,gall,u,u0,t; |
|
VECT vect; |
LIST pair; |
LIST pair; |
DP_pairs d,l; |
DP_pairs d,l; |
Q q1,q2; |
Q q1,q2; |
|
|
for ( gall = g = 0, d = 0, r = f; r; r = NEXT(r) ) { |
/* we need the following settings */ |
|
NVars = CNVars = n; |
|
setup_arrays(f,0,&r); |
|
for ( gall = g = 0, d = 0; r; r = NEXT(r) ) { |
i = (int)BDY(r); |
i = (int)BDY(r); |
d = updpairs(d,g,i); |
d = updpairs(d,g,i); |
g = updbase(g,i); |
g = updbase(g,i); |
gall = append_one(gall,i); |
gall = append_one(gall,i); |
} |
} |
for ( u0 = 0, t = gall; t; t = NEXT(t) ) { |
NEWVECT(vect); vect->len = psn; vect->body = (pointer)ps; |
NEXTNODE(u0,u); |
*gp = vect; |
BDY(u) = ps[(int)BDY(t)]; |
|
} |
|
if ( u0 ) |
|
NEXT(u) = 0; |
|
MKLIST(*gp,u); |
|
for ( u0 = 0, l = d; l; l = NEXT(l) ) { |
for ( u0 = 0, l = d; l; l = NEXT(l) ) { |
NEXTNODE(u0,u); |
NEXTNODE(u0,u); |
STOQ(l->dp1,q1); |
STOQ(l->dp1,q1); |
Line 2025 void gbcheck_list(NODE f,LIST *gp,LIST *pp) |
|
Line 2106 void gbcheck_list(NODE f,LIST *gp,LIST *pp) |
|
} |
} |
if ( u0 ) |
if ( u0 ) |
NEXT(u) = 0; |
NEXT(u) = 0; |
MKLIST(*pp,u); |
MKLIST(*pp,u0); |
} |
} |
|
|
int membercheck(NODE f,NODE x) |
int membercheck(NODE f,NODE x) |
Line 2059 void dp_set_flag(Obj name,Obj value) |
|
Line 2140 void dp_set_flag(Obj name,Obj value) |
|
{ |
{ |
char *n; |
char *n; |
int v; |
int v; |
|
Q ratio; |
|
|
if ( OID(name) != O_STR ) |
if ( OID(name) != O_STR ) |
return; |
return; |
Line 2069 void dp_set_flag(Obj name,Obj value) |
|
Line 2151 void dp_set_flag(Obj name,Obj value) |
|
if ( !strcmp(n,"Dist") ) { |
if ( !strcmp(n,"Dist") ) { |
Dist = (LIST)value; return; |
Dist = (LIST)value; return; |
} |
} |
|
if ( !strcmp(n,"Content") ) { |
|
ratio = (Q)value; |
|
if ( ratio ) { |
|
DP_Multiple = BD(NM(ratio))[0]; |
|
Denominator = INT(ratio) ? 1 : BD(DN(ratio))[0]; |
|
} else { |
|
DP_Multiple = 0; |
|
Denominator = 1; |
|
} |
|
} |
if ( value && OID(value) != O_N ) |
if ( value && OID(value) != O_N ) |
return; |
return; |
v = QTOS((Q)value); |
v = QTOS((Q)value); |
Line 2112 void dp_set_flag(Obj name,Obj value) |
|
Line 2204 void dp_set_flag(Obj name,Obj value) |
|
|
|
void dp_make_flaglist(LIST *list) |
void dp_make_flaglist(LIST *list) |
{ |
{ |
Q v; |
Q v,nm,dn; |
STRING name,path; |
STRING name,path; |
NODE n,n1; |
NODE n,n1; |
|
|
|
#if 0 |
STOQ(DP_Multiple,v); MKNODE(n,v,0); MKSTR(name,"DP_Multiple"); MKNODE(n1,name,n); n = n1; |
STOQ(DP_Multiple,v); MKNODE(n,v,0); MKSTR(name,"DP_Multiple"); MKNODE(n1,name,n); n = n1; |
STOQ(Denominator,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"Denominator"); MKNODE(n1,name,n); n = n1; |
STOQ(Denominator,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"Denominator"); MKNODE(n1,name,n); n = n1; |
|
#else |
|
if ( DP_Multiple ) { |
|
STOQ(DP_Multiple,nm); STOQ(Denominator,dn); divq(nm,dn,&v); |
|
} else |
|
v = 0; |
|
MKNODE(n,v,0); MKSTR(name,"Content"); MKNODE(n1,name,n); n = n1; |
|
#endif |
MKNODE(n1,Dist,n); n = n1; MKSTR(name,"Dist"); MKNODE(n1,name,n); n = n1; |
MKNODE(n1,Dist,n); n = n1; MKSTR(name,"Dist"); 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(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; |
Line 2170 void dp_load(int index,DP *p) |
|
Line 2270 void dp_load(int index,DP *p) |
|
sprintf(path,"%s%c%d",Demand,DELIM,index); |
sprintf(path,"%s%c%d",Demand,DELIM,index); |
if ( !(fp = fopen(path,"rb") ) ) |
if ( !(fp = fopen(path,"rb") ) ) |
error("dp_load : cannot open a file"); |
error("dp_load : cannot open a file"); |
skipvl(fp); loadobj(fp,(Obj *)p); fclose(fp); |
if ( PCoeffs ) |
|
loadvl(fp); |
|
else |
|
skipvl(fp); |
|
loadobj(fp,(Obj *)p); fclose(fp); |
} |
} |
} |
} |
|
|
Line 2183 int dp_load_t(int index,DP *p) |
|
Line 2287 int dp_load_t(int index,DP *p) |
|
if ( !(fp = fopen(path,"rb") ) ) |
if ( !(fp = fopen(path,"rb") ) ) |
return 0; |
return 0; |
else { |
else { |
skipvl(fp); loadobj(fp,(Obj *)p); fclose(fp); return 1; |
if ( PCoeffs ) |
|
loadvl(fp); |
|
else |
|
skipvl(fp); |
|
loadobj(fp,(Obj *)p); fclose(fp); return 1; |
} |
} |
} |
} |
|
|