![]() ![]() | ![]() |
version 1.31, 2004/03/09 09:40:46 | version 1.36, 2004/05/14 09:20:56 | ||
---|---|---|---|
|
|
||
* 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.30 2004/03/05 02:26:52 noro Exp $ | * $OpenXM: OpenXM_contrib2/asir2000/builtin/dp-supp.c,v 1.35 2004/05/14 06:02:54 noro Exp $ | ||
*/ | */ | ||
#include "ca.h" | #include "ca.h" | ||
#include "base.h" | #include "base.h" | ||
|
|
||
w_or_b[n].body.block.order = 0; | w_or_b[n].body.block.order = 0; | ||
spec->ord.composite.length = n+1; | spec->ord.composite.length = n+1; | ||
} | } | ||
if ( 1 ) print_composite_order_spec(spec); | |||
} | } | ||
/* module order spec */ | |||
void create_modorder_spec(int id,LIST shift,struct modorder_spec **s) | |||
{ | |||
struct modorder_spec *spec; | |||
NODE n,t; | |||
LIST list; | |||
int *ds; | |||
int i,l; | |||
Q q; | |||
*s = spec = (struct modorder_spec *)MALLOC(sizeof(struct modorder_spec)); | |||
spec->id = id; | |||
if ( shift ) { | |||
n = BDY(shift); | |||
spec->len = l = length(n); | |||
spec->degree_shift = ds = (int *)MALLOC_ATOMIC(l*sizeof(int)); | |||
for ( t = n, i = 0; t; t = NEXT(t), i++ ) | |||
ds[i] = QTOS((Q)BDY(t)); | |||
} else { | |||
spec->len = 0; | |||
spec->degree_shift = 0; | |||
} | |||
STOQ(id,q); | |||
n = mknode(2,q,shift); | |||
MKLIST(list,n); | |||
spec->obj = (Obj)list; | |||
} | |||
/* | /* | ||
* converters | * converters | ||
* | * | ||
|
|
||
} | } | ||
} | } | ||
void dp_ht(DP p,DP *rp) | |||
{ | |||
MP m,mr; | |||
if ( !p ) | |||
*rp = 0; | |||
else { | |||
m = BDY(p); | |||
NEWMP(mr); mr->dl = m->dl; mr->c = (P)ONE; NEXT(mr) = 0; | |||
MKDP(p->nv,mr,*rp); (*rp)->sugar = mr->dl->td; /* XXX */ | |||
} | |||
} | |||
void dp_rest(DP p,DP *rp) | void dp_rest(DP p,DP *rp) | ||
{ | { | ||
MP m; | MP m; | ||
|
|
||
*rp = r; | *rp = r; | ||
} | } | ||
DP extract_initial_term_from_dp(DP p,int *weight,int n); | |||
LIST extract_initial_term(LIST f,int *weight,int n); | |||
DP extract_initial_term_from_dp(DP p,int *weight,int n) | |||
{ | |||
int w,t,i,top; | |||
MP m,r0,r; | |||
DP dp; | |||
if ( !p ) return 0; | |||
top = 1; | |||
for ( m = BDY(p); m; m = NEXT(m) ) { | |||
for ( i = 0, t = 0; i < n; i++ ) | |||
t += weight[i]*m->dl->d[i]; | |||
if ( top || t > w ) { | |||
r0 = 0; | |||
w = t; | |||
top = 0; | |||
} | |||
if ( t == w ) { | |||
NEXTMP(r0,r); | |||
r->dl = m->dl; | |||
r->c = m->c; | |||
} | |||
} | |||
NEXT(r) = 0; | |||
MKDP(p->nv,r0,dp); | |||
return dp; | |||
} | |||
LIST extract_initial_term(LIST f,int *weight,int n) | |||
{ | |||
NODE nd,r0,r; | |||
Obj p; | |||
LIST l; | |||
nd = BDY(f); | |||
for ( r0 = 0; nd; nd = NEXT(nd) ) { | |||
NEXTNODE(r0,r); | |||
p = (Obj)BDY(nd); | |||
BDY(r) = (pointer)extract_initial_term_from_dp((DP)p,weight,n); | |||
} | |||
if ( r0 ) NEXT(r) = 0; | |||
MKLIST(l,r0); | |||
return l; | |||
} | |||
LIST dp_initial_term(LIST f,struct order_spec *ord) | |||
{ | |||
int n,l,i; | |||
struct weight_or_block *worb; | |||
int *weight; | |||
switch ( ord->id ) { | |||
case 2: /* matrix order */ | |||
/* extract the first row */ | |||
n = ord->nv; | |||
weight = ord->ord.matrix.matrix[0]; | |||
return extract_initial_term(f,weight,n); | |||
case 3: /* composite order */ | |||
/* the first w_or_b */ | |||
worb = ord->ord.composite.w_or_b; | |||
switch ( worb->type ) { | |||
case IS_DENSE_WEIGHT: | |||
n = worb->length; | |||
weight = worb->body.dense_weight; | |||
return extract_initial_term(f,weight,n); | |||
case IS_SPARSE_WEIGHT: | |||
n = ord->nv; | |||
weight = (int *)ALLOCA(n*sizeof(int)); | |||
for ( i = 0; i < n; i++ ) weight[i] = 0; | |||
l = worb->length; | |||
for ( i = 0; i < l; i++ ) | |||
weight[worb->body.sparse_weight[i].pos] | |||
= worb->body.sparse_weight[i].value; | |||
return extract_initial_term(f,weight,n); | |||
default: | |||
error("dp_initial_term : unsupported order"); | |||
} | |||
default: | |||
error("dp_initial_term : unsupported order"); | |||
} | |||
} | |||
int highest_order_dp(DP p,int *weight,int n); | |||
LIST highest_order(LIST f,int *weight,int n); | |||
int highest_order_dp(DP p,int *weight,int n) | |||
{ | |||
int w,t,i,top; | |||
MP m; | |||
if ( !p ) return -1; | |||
top = 1; | |||
for ( m = BDY(p); m; m = NEXT(m) ) { | |||
for ( i = 0, t = 0; i < n; i++ ) | |||
t += weight[i]*m->dl->d[i]; | |||
if ( top || t > w ) { | |||
w = t; | |||
top = 0; | |||
} | |||
} | |||
return w; | |||
} | |||
LIST highest_order(LIST f,int *weight,int n) | |||
{ | |||
int h; | |||
NODE nd,r0,r; | |||
Obj p; | |||
LIST l; | |||
Q q; | |||
nd = BDY(f); | |||
for ( r0 = 0; nd; nd = NEXT(nd) ) { | |||
NEXTNODE(r0,r); | |||
p = (Obj)BDY(nd); | |||
h = highest_order_dp((DP)p,weight,n); | |||
STOQ(h,q); | |||
BDY(r) = (pointer)q; | |||
} | |||
if ( r0 ) NEXT(r) = 0; | |||
MKLIST(l,r0); | |||
return l; | |||
} | |||
LIST dp_order(LIST f,struct order_spec *ord) | |||
{ | |||
int n,l,i; | |||
struct weight_or_block *worb; | |||
int *weight; | |||
switch ( ord->id ) { | |||
case 2: /* matrix order */ | |||
/* extract the first row */ | |||
n = ord->nv; | |||
weight = ord->ord.matrix.matrix[0]; | |||
return highest_order(f,weight,n); | |||
case 3: /* composite order */ | |||
/* the first w_or_b */ | |||
worb = ord->ord.composite.w_or_b; | |||
switch ( worb->type ) { | |||
case IS_DENSE_WEIGHT: | |||
n = worb->length; | |||
weight = worb->body.dense_weight; | |||
return highest_order(f,weight,n); | |||
case IS_SPARSE_WEIGHT: | |||
n = ord->nv; | |||
weight = (int *)ALLOCA(n*sizeof(int)); | |||
for ( i = 0; i < n; i++ ) weight[i] = 0; | |||
l = worb->length; | |||
for ( i = 0; i < l; i++ ) | |||
weight[worb->body.sparse_weight[i].pos] | |||
= worb->body.sparse_weight[i].value; | |||
return highest_order(f,weight,n); | |||
default: | |||
error("dp_initial_term : unsupported order"); | |||
} | |||
default: | |||
error("dp_initial_term : unsupported order"); | |||
} | |||
} | |||
int dpv_ht(DPV p,DP *h) | |||
{ | |||
int len,max,maxi,i,t; | |||
DP *e; | |||
MP m,mr; | |||
len = p->len; | |||
e = p->body; | |||
max = -1; | |||
maxi = -1; | |||
for ( i = 0; i < len; i++ ) | |||
if ( e[i] && (t = BDY(e[i])->dl->td) > max ) { | |||
max = t; | |||
maxi = i; | |||
} | |||
if ( max < 0 ) { | |||
*h = 0; | |||
return -1; | |||
} else { | |||
m = BDY(e[maxi]); | |||
NEWMP(mr); mr->dl = m->dl; mr->c = (P)ONE; NEXT(mr) = 0; | |||
MKDP(e[maxi]->nv,mr,*h); (*h)->sugar = mr->dl->td; /* XXX */ | |||
return maxi; | |||
} | |||
} |