OpenXM_contrib2/asir2000/engine/nd.c - diff

Return to nd.c CVS log

Up to [local] / OpenXM_contrib2 / asir2000 / engine

Diff for /OpenXM_contrib2/asir2000/engine/nd.c between version 1.56 and 1.57

version 1.56, 2003/09/04 08:35:09

version 1.57, 2003/09/05 05:02:53

Line 1

/* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.55 2003/09/03 07:33:35 noro Exp $ */

/* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.56 2003/09/04 08:35:09 noro Exp $ */

#include "ca.h"

#include "inline.h"

Line 226 NODE nd_gb_trace(int m);

/* ndl functions */

int ndl_weight(unsigned int *d);

int ndl_weight_mask(unsigned int *d,int i);

void ndl_set_blockweight(unsigned int *d);

void ndl_dehomogenize(unsigned int *p);

void ndl_reconstruct(int obpe,EPOS oepos,unsigned int *d,unsigned int *r);

INLINE int ndl_reducible(unsigned int *d1,unsigned int *d2);

Line 273 void nd_reconstruct_direct(int mod,NDV *ps,int len);

Line 274 void nd_reconstruct_direct(int mod,NDV *ps,int len);

void nd_setup(int mod,int trace,NODE f);

void nd_setup_parameters();

BlockMask nd_create_blockmask(struct order_spec *ord);

EPOS nd_create_epos(struct order_spec *ord);

int nd_get_exporigin(struct order_spec *ord);

/* ND functions */

Line 283 ND nd_remove_head(ND p);

Line 285 ND nd_remove_head(ND p);

int nd_length(ND p);

void nd_append_red(unsigned int *d,int i);

unsigned int *ndv_compute_bound(NDV p);

unsigned int *dp_compute_bound(DP p);

ND nd_copy(ND p);

ND nd_add(int mod,ND p1,ND p2);

ND nd_add_q(ND p1,ND p2);

Line 540 void ndl_lcm(unsigned int *d1,unsigned *d2,unsigned in

Line 541 void ndl_lcm(unsigned int *d1,unsigned *d2,unsigned in

}

void ndl_set_blockweight(unsigned int *d) {

int l,j;

if ( nd_blockmask ) {

l = nd_blockmask->n;

for ( j = 0; j < l; j++ )

d[j+1] = ndl_weight_mask(d,j);

}

int ndl_weight(unsigned int *d)

{

unsigned int t,u;

Line 1958 void nd_setup(int mod,int trace,NODE f)

Line 1969 void nd_setup(int mod,int trace,NODE f)

unsigned int *d;

RHist r;

NDV a;

MP t;

nd_found = 0; nd_notfirst = 0; nd_create = 0;

Line 1966 void nd_setup(int mod,int trace,NODE f)

Line 1978 void nd_setup(int mod,int trace,NODE f)

nd_ps_trace = (NDV *)MALLOC(nd_pslen*sizeof(NDV));

nd_psh = (RHist *)MALLOC(nd_pslen*sizeof(RHist));

nd_bound = (unsigned int **)MALLOC(nd_pslen*sizeof(unsigned int *));

for ( max = 0, i = 0, s = f; i < nd_psn; i++, s = NEXT(s) ) {

nd_bound[i] = d = dp_compute_bound((DP)BDY(s));

for ( j = 0; j < nd_nvar; j++ )

max = MAX(d[j],max);

}

if ( !nd_red )

nd_red = (RHist *)MALLOC(REDTAB_LEN*sizeof(RHist));

bzero(nd_red,REDTAB_LEN*sizeof(RHist));

for ( max = 0, s = f; s; s = NEXT(s) )

for ( t = BDY((DP)BDY(s)); t; t = NEXT(t) ) {

d = t->dl->d;

for ( j = 0; j < nd_nvar; j++ ) max = MAX(d[j],max);

}

if ( max < 2 ) nd_bpe = 2;

else if ( max < 4 ) nd_bpe = 4;

else if ( max < 64 ) nd_bpe = 6;

Line 1988 void nd_setup(int mod,int trace,NODE f)

Line 2002 void nd_setup(int mod,int trace,NODE f)

NEWRHist(r);

a = dptondv(mod,(DP)BDY(f)); ndv_removecont(mod,a);

SG(r) = HTD(a); ndl_copy(HDL(a),DL(r));

nd_ps[i] = a;

if ( trace ) {

a = dptondv(0,(DP)BDY(f)); ndv_removecont(0,a);

nd_ps_trace[i] = a;

}

nd_bound[i] = ndv_compute_bound(a);

nd_psh[i] = r;

}

Line 2139 void nd_gr_trace(LIST f,LIST v,int trace,int homo,stru

Line 2153 void nd_gr_trace(LIST f,LIST v,int trace,int homo,stru

void dltondl(int n,DL dl,unsigned int *r)

{

unsigned int *d;

int i,j,l,s,ord_l,ord_o;

int i,j,l,s,ord_l;

struct order_pair *op;

d = dl->d;

Line 2148 void dltondl(int n,DL dl,unsigned int *r)

Line 2162 void dltondl(int n,DL dl,unsigned int *r)

l = nd_blockmask->n;

op = nd_blockmask->order_pair;

for ( j = 0, s = 0; j < l; j++ ) {

ord_o = op[j].order;

ord_l = op[j].length;

if ( !ord_o )

for ( i = 0; i < ord_l; i++, s++ ) PUT_EXP(r,s,d[s]);

for ( i = 0; i < ord_l; i++ )

PUT_EXP(r,s+ord_l-i-1,d[s+i]);

else

for ( i = 0; i < ord_l; i++ )

PUT_EXP(r,s+i,d[s+i]);

s += ord_l;

}

TD(r) = ndl_weight(r);

for ( j = 0; j < l; j++ )

Line 2171 DL ndltodl(int n,unsigned int *ndl)

Line 2178 DL ndltodl(int n,unsigned int *ndl)

{

DL dl;

int *d;

int i,j,l,s,ord_l,ord_o;

int i,j,l,s,ord_l;

struct order_pair *op;

NEWDL(dl,n);

Line 2181 DL ndltodl(int n,unsigned int *ndl)

Line 2188 DL ndltodl(int n,unsigned int *ndl)

l = nd_blockmask->n;

op = nd_blockmask->order_pair;

for ( j = 0, s = 0; j < l; j++ ) {

ord_o = op[j].order;

ord_l = op[j].length;

if ( !ord_o )

for ( i = 0; i < ord_l; i++, s++ ) d[s] = GET_EXP(ndl,s);

for ( i = 0; i < ord_l; i++ )

d[s+i] = GET_EXP(ndl,s+ord_l-i-1);

else

for ( i = 0; i < ord_l; i++ )

d[s+i] = GET_EXP(ndl,s+i);

s += ord_l;

}

} else {

for ( i = 0; i < n; i++ ) d[i] = GET_EXP(ndl,i);

Line 2246 DP ndtodp(int mod,ND p)

void ndl_print(unsigned int *dl)

{

int n;

int i,j,l,ord_o,ord_l,s,s0;

int i,j,l,ord_l,s,s0;

struct order_pair *op;

n = nd_nvar;

Line 2255 void ndl_print(unsigned int *dl)

l = nd_blockmask->n;

op = nd_blockmask->order_pair;

for ( j = 0, s = s0 = 0; j < l; j++ ) {

ord_o = op[j].order;

ord_l = op[j].length;

if ( !ord_o )

for ( i = 0; i < ord_l; i++, s++ )

for ( i = 0, s0 += ord_l; i < ord_l; i++, s++ )

printf(s==n-1?"%d":"%d,",GET_EXP(dl,s));

printf(s==n-1?"%d":"%d,",GET_EXP(dl,s0-i-1));

else

for ( i = 0; i < ord_l; i++, s++ )

printf(s==n-1?"%d":"%d,",GET_EXP(dl,s));

}

} else {

for ( i = 0; i < n; i++ ) printf(i==n-1?"%d":"%d,",GET_EXP(dl,i));

Line 2496 void nd_append_red(unsigned int *d,int i)

Line 2491 void nd_append_red(unsigned int *d,int i)

nd_red[h] = m;

}

unsigned int *dp_compute_bound(DP p)

{

unsigned int *d,*d1,*d2,*t;

MP m;

int i,l;

if ( !p )

return 0;

d1 = (unsigned int *)ALLOCA(nd_nvar*sizeof(unsigned int));

d2 = (unsigned int *)ALLOCA(nd_nvar*sizeof(unsigned int));

m = BDY(p);

d = DL(m)->d;

for ( i = 0; i < nd_nvar; i++ ) d1[i] = d[i];

for ( m = NEXT(BDY(p)); m; m = NEXT(m) ) {

d = DL(m)->d;

for ( i = 0; i < nd_nvar; i++ )

d2[i] = d[i] > d1[i] ? d[i] : d1[i];

t = d1; d1 = d2; d2 = t;

}

l = (nd_nvar+31);

t = (unsigned int *)MALLOC_ATOMIC(l*sizeof(unsigned int));

for ( i = 0; i < nd_nvar; i++ ) t[i] = d1[i];

for ( ; i < l; i++ ) t[i] = 0;

return t;

}

unsigned int *ndv_compute_bound(NDV p)

{

unsigned int *d1,*d2,*t;

int i,l,len;

unsigned int u;

int i,j,k,l,len,ind;

NMV m;

if ( !p )

Line 2540 unsigned int *ndv_compute_bound(NDV p)

Line 2510 unsigned int *ndv_compute_bound(NDV p)

}

l = nd_nvar+31;

t = (unsigned int *)MALLOC_ATOMIC(l*sizeof(unsigned int));

for ( i = 0; i < nd_nvar; i++ ) t[i] = GET_EXP(d1,i);

for ( i = nd_exporigin, ind = 0; i < nd_wpd; i++ ) {

for ( ; i < l; i++ ) t[i] = 0;

u = d1[i];

k = (nd_epw-1)*nd_bpe;

for ( j = 0; j < nd_epw; j++, k -= nd_bpe, ind++ )

t[ind] = (u>>k)&nd_mask0;

}

for ( ; ind < l; ind++ ) t[ind] = 0;

return t;

}

Line 2560 int nd_get_exporigin(struct order_spec *ord)

Line 2535 int nd_get_exporigin(struct order_spec *ord)

}

void nd_setup_parameters() {

int i,n,elen;

int i,j,n,elen,ord_o,ord_l,l,s;

struct order_pair *op;

nd_epw = (sizeof(unsigned int)*8)/nd_bpe;

elen = nd_nvar/nd_epw+(nd_nvar%nd_epw?1:0);

nd_exporigin = nd_get_exporigin(nd_ord);

nd_wpd = nd_exporigin+elen;

nd_epos = (EPOS)MALLOC_ATOMIC(nd_nvar*sizeof(struct oEPOS));

if ( nd_isrlex ) {

for ( i = 0; i < nd_nvar; i++ ) {

nd_epos[i].i = nd_exporigin + (nd_nvar-1-i)/nd_epw;

nd_epos[i].s = (nd_epw-((nd_nvar-1-i)%nd_epw)-1)*nd_bpe;

}

} else {

for ( i = 0; i < nd_nvar; i++ ) {

nd_epos[i].i = nd_exporigin + i/nd_epw;

nd_epos[i].s = (nd_epw-(i%nd_epw)-1)*nd_bpe;

}

if ( nd_bpe < 32 ) {

nd_mask0 = (1<<nd_bpe)-1;

} else {

Line 2592 void nd_setup_parameters() {

Line 2557 void nd_setup_parameters() {

}

nm_adv = sizeof(struct oNM)+(nd_wpd-1)*sizeof(unsigned int);

nmv_adv = sizeof(struct oNMV)+(nd_wpd-1)*sizeof(unsigned int);

nd_epos = nd_create_epos(nd_ord);

nd_blockmask = nd_create_blockmask(nd_ord);

}

Line 2695 void nd_reconstruct_direct(int mod,NDV *ps,int len)

Line 2661 void nd_reconstruct_direct(int mod,NDV *ps,int len)

void ndl_reconstruct(int obpe,EPOS oepos,unsigned int *d,unsigned int *r)

{

int n,i,ei,oepw,omask0,j,s,ord_l,ord_o,l;

int n,i,ei,oepw,omask0,j,s,ord_l,l;

struct order_pair *op;

#define GET_EXP_OLD(d,a) (((d)[oepos[a].i]>>oepos[a].s)&omask0)

#define PUT_EXP_OLD(r,a,e) ((r)[oepos[a].i] |= ((e)<<oepos[a].s))

Line 2711 void ndl_reconstruct(int obpe,EPOS oepos,unsigned int

Line 2677 void ndl_reconstruct(int obpe,EPOS oepos,unsigned int

for ( i = 1; i < nd_exporigin; i++ )

r[i] = d[i];

for ( j = 0, s = 0; j < l; j++ ) {

ord_o = op[j].order;

ord_l = op[j].length;

if ( !ord_o )

for ( i = 0; i < ord_l; i++, s++ ) {

for ( i = 0; i < ord_l; i++ ) {

ei = GET_EXP_OLD(d,s);

ei = GET_EXP_OLD(d,s+ord_l-i-1);

PUT_EXP(r,s,ei);

PUT_EXP(r,s+ord_l-i-1,ei);

}

else

for ( i = 0; i < ord_l; i++ ) {

ei = GET_EXP_OLD(d,s+i);

PUT_EXP(r,s+i,ei);

}

s += ord_l;

}

} else {

for ( i = 0; i < n; i++ ) {

Line 2876 void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta

Line 2834 void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta

h = GET_EXP(d0,n-1)+GET_EXP(d1,n-1);

PUT_EXP(DL(m),n-1,h);

TD(DL(m)) = h;

/* XXX other weights */

if ( nd_blockmask ) ndl_set_blockweight(DL(m));

}

tab[0] = m;

curlen = 1;

NEWNM(m); d = DL(m);

for ( i = 0; i < n2; i++ ) {

for ( i = 0, curlen = 1; i < n2; i++ ) {

a = GET_EXP(d0,i); b = GET_EXP(d1,n2+i);

k = GET_EXP(d0,n2+i); l = GET_EXP(d1,i);

/* xi^a*(Di^k*xi^l)*Di^b */

Line 2892 void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta

Line 2849 void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta

if ( t = tab[j] ) {

dt = DL(t);

PUT_EXP(dt,i,a); PUT_EXP(dt,n2+i,b); TD(dt) += s;

/* XXX other weights */

if ( nd_blockmask ) ndl_set_blockweight(dt);

}

curlen *= k+1;

continue;

Line 2905 void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta

Line 2862 void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta

ctab_q = (Q *)ALLOCA((min+1)*sizeof(Q));

mkwc(k,l,ctab_q);

}

p = tab+curlen;

for ( j = min; j >= 0; j-- ) {

for ( j = 1; j <= min; j++ ) {

for ( u = 0; u < nd_wpd; u++ ) d[u] = 0;

PUT_EXP(d,i,a-j); PUT_EXP(d,n2+i,b-j);

h = MUL_WEIGHT(a-j,i)+MUL_WEIGHT(b-j,n2+i);

Line 2914 void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta

Line 2870 void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta

TD(d) = s;

PUT_EXP(d,n-1,s-h);

} else TD(d) = h;

/* XXX other weights */

if ( nd_blockmask ) ndl_set_blockweight(d);

if ( mod ) c = ctab[j];

else q = ctab_q[j];

for ( u = 0; u < curlen; u++, p++ ) {

p = tab+curlen*j;

if ( tab[u] ) {

if ( j == 0 ) {

NEWNM(t);

for ( u = 0; u < curlen; u++, p++ ) {

ndl_add(DL(tab[u]),d,DL(t));

if ( tab[u] ) {

if ( mod ) {

ndl_addto(DL(tab[u]),d);

c0 = CM(tab[u]); DMAR(c0,c,0,mod,c1); CM(t) = c1;

if ( mod ) {

} else

c0 = CM(tab[u]); DMAR(c0,c,0,mod,c1); CM(tab[u]) = c1;

mulq(CQ(tab[u]),q,&CQ(t));

} else {

*p = t;

mulq(CQ(tab[u]),q,&q1); CQ(tab[u]) = q1;

}

} else {

}

for ( u = 0; u < curlen; u++, p++ ) {

/* destructive for j = 0 */

if ( tab[u] ) {

for ( u = 0; u < nd_wpd; u++ ) d[u] = 0;

NEWNM(t);

PUT_EXP(d,i,a); PUT_EXP(d,n2+i,b);

ndl_add(DL(tab[u]),d,DL(t));

h = MUL_WEIGHT(a,i)+MUL_WEIGHT(b,n2+i);

if ( mod ) {

if ( homo ) {

c0 = CM(tab[u]); DMAR(c0,c,0,mod,c1); CM(t) = c1;

TD(d) = s;

} else

PUT_EXP(d,n-1,s-h);

mulq(CQ(tab[u]),q,&CQ(t));

} else TD(d) = h;

*p = t;

/* XXX other weights */

}

if ( mod ) c = ctab[0];

else q = ctab_q[0];

p = tab;

for ( u = 0; u < curlen; u++, p++ ) {

if ( tab[u] ) {

ndl_addto(DL(tab[u]),d);

if ( mod ) {

c0 = CM(tab[u]); DMAR(c0,c,0,mod,c1); CM(tab[u]) = c1;

} else {

mulq(CQ(tab[u]),q,&q1); CQ(tab[u]) = q1;

}

Line 3228 BlockMask nd_create_blockmask(struct order_spec *ord)

Line 3176 BlockMask nd_create_blockmask(struct order_spec *ord)

for ( j = 0; j < l; j++, s++ ) PUT_EXP(t,s,nd_mask0);

}

return bm;

}

EPOS nd_create_epos(struct order_spec *ord)

{

int i,j,l,s,ord_l,ord_o;

EPOS epos;

struct order_pair *op;

epos = (EPOS)MALLOC_ATOMIC(nd_nvar*sizeof(struct oEPOS));

switch ( ord->id ) {

case 0:

if ( nd_isrlex ) {

for ( i = 0; i < nd_nvar; i++ ) {

epos[i].i = nd_exporigin + (nd_nvar-1-i)/nd_epw;

epos[i].s = (nd_epw-((nd_nvar-1-i)%nd_epw)-1)*nd_bpe;

}

} else {

for ( i = 0; i < nd_nvar; i++ ) {

epos[i].i = nd_exporigin + i/nd_epw;

epos[i].s = (nd_epw-(i%nd_epw)-1)*nd_bpe;

}

break;

case 1:

/* block order */

l = ord->ord.block.length;

op = ord->ord.block.order_pair;

for ( j = 0, s = 0; j < l; j++ ) {

ord_o = op[j].order;

ord_l = op[j].length;

if ( !ord_o )

for ( i = 0; i < ord_l; i++ ) {

epos[s+i].i = nd_exporigin + (s+ord_l-i-1)/nd_epw;

epos[s+i].s = (nd_epw-((s+ord_l-i-1)%nd_epw)-1)*nd_bpe;

}

else

for ( i = 0; i < ord_l; i++ ) {

epos[s+i].i = nd_exporigin + (s+i)/nd_epw;

epos[s+i].s = (nd_epw-((s+i)%nd_epw)-1)*nd_bpe;

}

s += ord_l;

}

break;

case 2:

error("nd_create_epos : matrix order is not supported yet.");

}

return epos;

}

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