version 1.44, 2007/09/15 10:17:08 |
version 1.46, 2007/09/19 05:42:59 |
|
|
* 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/dp-supp.c,v 1.43 2007/09/07 00:45:50 noro Exp $ |
* $OpenXM: OpenXM_contrib2/asir2000/builtin/dp-supp.c,v 1.45 2007/09/16 09:08:25 noro Exp $ |
*/ |
*/ |
#include "ca.h" |
#include "ca.h" |
#include "base.h" |
#include "base.h" |
Line 71 void print_composite_order_spec(struct order_spec *spe |
|
Line 71 void print_composite_order_spec(struct order_spec *spe |
|
* |
* |
*/ |
*/ |
|
|
|
static NODE RatDenomList; |
|
|
|
void init_denomlist() |
|
{ |
|
RatDenomList = 0; |
|
} |
|
|
|
void add_denomlist(P f) |
|
{ |
|
NODE n; |
|
|
|
if ( OID(f)==O_P ) { |
|
MKNODE(n,f,RatDenomList); RatDenomList = n; |
|
} |
|
} |
|
|
|
LIST get_denomlist() |
|
{ |
|
LIST l; |
|
|
|
MKLIST(l,RatDenomList); RatDenomList = 0; |
|
return l; |
|
} |
|
|
void dp_ptozp(DP p,DP *rp) |
void dp_ptozp(DP p,DP *rp) |
{ |
{ |
MP m,mr,mr0; |
MP m,mr,mr0; |
Line 448 void dp_prim(DP p,DP *rp) |
|
Line 472 void dp_prim(DP p,DP *rp) |
|
P *w; |
P *w; |
Q *c; |
Q *c; |
Q dvr; |
Q dvr; |
|
NODE tn; |
|
|
if ( !p ) |
if ( !p ) |
*rp = 0; |
*rp = 0; |
Line 502 void dp_prim(DP p,DP *rp) |
|
Line 527 void dp_prim(DP p,DP *rp) |
|
NEXTMP(mr0,mr); divsp(CO,m->c,g,&mr->c); mr->dl = m->dl; |
NEXTMP(mr0,mr); divsp(CO,m->c,g,&mr->c); mr->dl = m->dl; |
} |
} |
NEXT(mr) = 0; MKDP(p->nv,mr0,*rp); (*rp)->sugar = p->sugar; |
NEXT(mr) = 0; MKDP(p->nv,mr0,*rp); (*rp)->sugar = p->sugar; |
|
add_denomlist(g); |
} |
} |
} |
} |
} |
} |
Line 805 void dp_red(DP p0,DP p1,DP p2,DP *head,DP *rest,P *dnp |
|
Line 831 void dp_red(DP p0,DP p1,DP p2,DP *head,DP *rest,P *dnp |
|
} else { |
} else { |
ezgcdpz(CO,(P)c1,(P)c2,&g); |
ezgcdpz(CO,(P)c1,(P)c2,&g); |
divsp(CO,(P)c1,g,&a); c1 = (Q)a; divsp(CO,(P)c2,g,&a); c2 = (Q)a; |
divsp(CO,(P)c1,g,&a); c1 = (Q)a; divsp(CO,(P)c2,g,&a); c2 = (Q)a; |
|
add_denomlist(g); |
} |
} |
NEWMP(m); m->dl = d; chsgnp((P)c1,&m->c); NEXT(m) = 0; MKDP(n,m,s); s->sugar = d->td; |
NEWMP(m); m->dl = d; chsgnp((P)c1,&m->c); NEXT(m) = 0; MKDP(n,m,s); s->sugar = d->td; |
*multp = s; |
*multp = s; |
Line 2708 NODE compute_last_w(NODE g,NODE gh,int n,int **w, |
|
Line 2735 NODE compute_last_w(NODE g,NODE gh,int n,int **w, |
|
} |
} |
|
|
/* compute a sufficient set of d(f)=u-v */ |
/* compute a sufficient set of d(f)=u-v */ |
static int comp_vector_lex_nv; |
|
|
|
int comp_vector_lex(int **a,int **b) |
|
{ |
|
int i; |
|
int *pa,*pb; |
|
|
|
pa = *a; pb = *b; |
|
for ( i = 0; i < comp_vector_lex_nv; i++ ) |
|
if ( pa[i] < pb[i] ) return -1; |
|
else if ( pa[i] > pb[i] ) return 1; |
|
return 0; |
|
} |
|
|
|
NODE compute_essential_df(DP *g,DP *gh,int ng) |
NODE compute_essential_df(DP *g,DP *gh,int ng) |
{ |
{ |
VECT v; |
int nv,i,j,k,t,lj; |
Q q; |
NODE r,r1,ri,rt,r0; |
MP m; |
MP m; |
NODE r,r1; |
MP *mj; |
int nv,len,i,j,k; |
DL di,hj,dl,dlt; |
int *p,*dm,*mi,*mj,*h; |
int *d,*dt; |
int **mat; |
LIST l; |
|
Q q; |
|
|
nv = comp_vector_lex_nv = g[0]->nv; |
nv = g[0]->nv; |
for ( len = 0, j = 0; j < ng; j++ ) { |
r = 0; |
for ( m = BDY(g[j]); m; m = NEXT(m), len++ ); |
for ( j = 0; j < ng; j++ ) { |
} |
for ( m = BDY(g[j]), lj = 0; m; m = NEXT(m), lj++ ); |
mat = almat(len,nv); |
mj = (MP *)ALLOCA(lj*sizeof(MP)); |
for ( i = 0, j = 0; j < ng; j++ ) { |
for ( m = BDY(g[j]), k = 0; m; m = NEXT(m), k++ ) |
h = BDY(gh[j])->dl->d; |
mj[k] = m; |
for ( m = BDY(g[j]); m; m = NEXT(m) ) { |
for ( i = 0; i < lj; i++ ) { |
dm = m->dl->d; |
for ( di = mj[i]->dl, k = i+1; k < lj; k++ ) |
for ( k = 0; k < nv; k++ ) |
if ( _dl_redble(di,mj[k]->dl,nv) ) break; |
if ( dm[k] ) break; |
if ( k < lj ) mj[i] = 0; |
if ( k == nv ) continue; |
} |
else { |
hj = BDY(gh[j])->dl; |
p = mat[i]; |
_NEWDL(dl,nv); d = dl->d; |
for ( k = 0; k < nv; k++ ) |
r0 = r; |
p[k] = h[k]-dm[k]; |
for ( i = 0; i < lj; i++ ) { |
i++; |
if ( mj[i] && !dl_equal(nv,di=mj[i]->dl,hj) ) { |
|
for ( k = 0, t = 0; k < nv; k++ ) { |
|
d[k] = hj->d[k]-di->d[k]; |
|
t += d[k]; |
|
} |
|
dl->td = t; |
|
#if 1 |
|
for ( rt = r0; rt; rt = NEXT(rt) ) { |
|
dlt = (DL)BDY(rt); |
|
if ( dlt->td != dl->td ) continue; |
|
for ( dt = dlt->d, k = 0; k < nv; k++ ) |
|
if ( d[k] != dt[k] ) break; |
|
if ( k == nv ) break; |
|
} |
|
#else |
|
rt = 0; |
|
#endif |
|
if ( !rt ) { |
|
MKNODE(r1,dl,r); r = r1; |
|
_NEWDL(dl,nv); d = dl->d; |
|
} |
} |
} |
} |
} |
} |
} |
len = i; |
for ( rt = r; rt; rt = NEXT(rt) ) { |
qsort(mat,len,sizeof(int *), |
dl = (DL)BDY(rt); d = dl->d; |
(int (*)(const void *,const void *))comp_vector_lex); |
ri = 0; |
for ( i = 0; i < len; i++ ) { |
for ( k = nv-1; k >= 0; k-- ) { |
for ( j = 0; j < nv; j++ ) |
STOQ(d[k],q); |
printf("%d ",mat[i][j]); |
MKNODE(r1,q,ri); ri = r1; |
printf("\n"); |
|
} |
|
for ( i = 0; i < len; i++ ) { |
|
mi = mat[i]; |
|
if ( !mi ) continue; |
|
for ( j = i+1; j < len; j++ ) { |
|
mj = mat[j]; |
|
if ( !mj ) continue; |
|
for ( k = 0; k < nv; k++ ) |
|
if ( mi[k] > mj[k] ) break; |
|
if ( k == nv ) mat[j] = 0; |
|
} |
} |
} |
MKNODE(r1,0,ri); MKLIST(l,r1); |
for ( i = 0; i < len; i++ ) { |
BDY(rt) = (pointer)l; |
if ( mat[i] ) { |
|
for ( j = 0; j < nv; j++ ) |
|
printf("%d ",mat[i][j]); |
|
printf("\n"); |
|
} |
|
} |
|
r = 0; |
|
for ( i = 0; i < len; i++ ) { |
|
if ( mi = mat[i] ) { |
|
MKVECT(v,nv); |
|
for ( k = 0; k < nv; k++ ) { |
|
STOQ(mi[k],q); |
|
v->body[k] = (pointer)q; |
|
} |
|
MKNODE(r1,v,r); r = r1; |
|
} |
|
} |
} |
return r; |
return r; |
} |
} |