version 1.41, 2003/08/21 07:39:25 |
version 1.44, 2003/08/22 08:32:51 |
|
|
/* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.40 2003/08/21 04:44:36 noro Exp $ */ |
/* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.43 2003/08/22 07:12:49 noro Exp $ */ |
|
|
#include "ca.h" |
#include "ca.h" |
#include "inline.h" |
#include "inline.h" |
Line 73 typedef struct oND_pairs { |
|
Line 73 typedef struct oND_pairs { |
|
unsigned int lcm[1]; |
unsigned int lcm[1]; |
} *ND_pairs; |
} *ND_pairs; |
|
|
|
/* index and shift count for each exponent */ |
|
typedef struct oEPOS { |
|
int i; /* index */ |
|
int s; /* shift */ |
|
} *EPOS; |
|
|
|
typedef struct oBlockMask { |
|
int n; |
|
struct order_pair *order_pair; |
|
unsigned int **mask; |
|
} *BlockMask; |
|
|
int (*nd_compare_function)(unsigned int *a1,unsigned int *a2); |
int (*nd_compare_function)(unsigned int *a1,unsigned int *a2); |
|
|
double nd_scale=2; |
static double nd_scale=2; |
static unsigned int **nd_bound; |
static unsigned int **nd_bound; |
struct order_spec *nd_ord; |
static struct order_spec *nd_ord; |
int nd_nvar; |
static EPOS nd_epos; |
int nd_isrlex; |
static BlockMask nd_blockmask; |
int nd_epw,nd_bpe,nd_wpd,nd_exporigin; |
static int nd_nvar; |
unsigned int nd_mask[32]; |
static int nd_isrlex; |
unsigned int nd_mask0,nd_mask1; |
static int nd_epw,nd_bpe,nd_wpd,nd_exporigin; |
|
static unsigned int nd_mask[32]; |
|
static unsigned int nd_mask0,nd_mask1; |
|
|
NM _nm_free_list; |
static NM _nm_free_list; |
ND _nd_free_list; |
static ND _nd_free_list; |
ND_pairs _ndp_free_list; |
static ND_pairs _ndp_free_list; |
|
|
static NDV *nd_ps; |
static NDV *nd_ps; |
static NDV *nd_psq; |
static NDV *nd_psq; |
RHist *nd_psh; |
static RHist *nd_psh; |
int nd_psn,nd_pslen; |
static int nd_psn,nd_pslen; |
|
|
RHist *nd_red; |
static RHist *nd_red; |
|
|
int nd_found,nd_create,nd_notfirst; |
static int nd_found,nd_create,nd_notfirst; |
int nm_adv; |
static int nm_adv; |
int nmv_adv; |
static int nmv_adv; |
int nd_dcomp; |
static int nd_dcomp; |
|
|
extern int Top,Reverse,dp_nelim; |
extern int Top,Reverse,dp_nelim; |
|
|
Line 114 extern int Top,Reverse,dp_nelim; |
|
Line 128 extern int Top,Reverse,dp_nelim; |
|
#define SG(a) ((a)->sugar) |
#define SG(a) ((a)->sugar) |
#define LEN(a) ((a)->len) |
#define LEN(a) ((a)->len) |
#define LCM(a) ((a)->lcm) |
#define LCM(a) ((a)->lcm) |
|
#define GET_EXP(d,a) (((d)[nd_epos[a].i]>>nd_epos[a].s)&nd_mask0) |
|
#define PUT_EXP(r,a,e) ((r)[nd_epos[a].i] |= ((e)<<nd_epos[a].s)) |
|
|
/* macros for term comparison */ |
/* macros for term comparison */ |
#define TD_DL_COMPARE(d1,d2)\ |
#define TD_DL_COMPARE(d1,d2)\ |
(TD(d1)>TD(d2)?1:(TD(d1)<TD(d2)?-1:ndl_lex_compare(d1,d2))) |
(TD(d1)>TD(d2)?1:(TD(d1)<TD(d2)?-1:ndl_lex_compare(d1,d2))) |
|
#if 0 |
#define DL_COMPARE(d1,d2)\ |
#define DL_COMPARE(d1,d2)\ |
(nd_dcomp?TD_DL_COMPARE(d1,d2):(*nd_compare_function)(d1,d2)) |
(nd_dcomp>0?TD_DL_COMPARE(d1,d2)\ |
|
:(nd_dcomp==0?ndl_lex_compare(d1,d2)\ |
|
:(nd_blockmask?ndl_block_compare(d1,d2)\ |
|
:(*nd_compare_function)(d1,d2)))) |
|
#else |
|
#define DL_COMPARE(d1,d2)\ |
|
(nd_dcomp>0?TD_DL_COMPARE(d1,d2):(*nd_compare_function)(d1,d2)) |
|
#endif |
|
|
/* allocators */ |
/* allocators */ |
#define NEWRHist(r) \ |
#define NEWRHist(r) \ |
Line 193 NODE nd_gb_trace(int m); |
|
Line 217 NODE nd_gb_trace(int m); |
|
|
|
/* ndl functions */ |
/* ndl functions */ |
int ndl_weight(unsigned int *d); |
int ndl_weight(unsigned int *d); |
|
int ndl_weight_mask(unsigned int *d,int i); |
void ndl_dehomogenize(unsigned int *p); |
void ndl_dehomogenize(unsigned int *p); |
void ndl_reconstruct(int obpe,unsigned int *d,unsigned int *r); |
void ndl_reconstruct(int obpe,EPOS oepos,unsigned int *d,unsigned int *r); |
INLINE int ndl_reducible(unsigned int *d1,unsigned int *d2); |
INLINE int ndl_reducible(unsigned int *d1,unsigned int *d2); |
INLINE int ndl_lex_compare(unsigned int *d1,unsigned int *d2); |
INLINE int ndl_lex_compare(unsigned int *d1,unsigned int *d2); |
|
INLINE int ndl_block_compare(unsigned int *d1,unsigned int *d2); |
INLINE int ndl_equal(unsigned int *d1,unsigned int *d2); |
INLINE int ndl_equal(unsigned int *d1,unsigned int *d2); |
INLINE void ndl_copy(unsigned int *d1,unsigned int *d2); |
INLINE void ndl_copy(unsigned int *d1,unsigned int *d2); |
INLINE void ndl_add(unsigned int *d1,unsigned int *d2,unsigned int *d); |
INLINE void ndl_add(unsigned int *d1,unsigned int *d2,unsigned int *d); |
Line 225 void nd_free_private_storage(); |
|
Line 251 void nd_free_private_storage(); |
|
void _NM_alloc(); |
void _NM_alloc(); |
void _ND_alloc(); |
void _ND_alloc(); |
void nd_free(ND p); |
void nd_free(ND p); |
void nd_realloc(ND p,int obpe); |
|
void nd_free_redlist(); |
void nd_free_redlist(); |
|
|
/* printing */ |
/* printing */ |
Line 241 ND_pairs nd_reconstruct(int mod,int trace,ND_pairs ndp |
|
Line 266 ND_pairs nd_reconstruct(int mod,int trace,ND_pairs ndp |
|
void nd_reconstruct_direct(int mod,NDV *ps,int len); |
void nd_reconstruct_direct(int mod,NDV *ps,int len); |
void nd_setup(int mod,int trace,NODE f); |
void nd_setup(int mod,int trace,NODE f); |
void nd_setup_parameters(); |
void nd_setup_parameters(); |
|
BlockMask nd_create_blockmask(struct order_spec *ord); |
|
|
/* ND functions */ |
/* ND functions */ |
int nd_check_candidate(NODE input,NODE cand); |
int nd_check_candidate(NODE input,NODE cand); |
Line 259 INLINE int nd_length(ND p); |
|
Line 285 INLINE int nd_length(ND p); |
|
/* NDV functions */ |
/* NDV functions */ |
void ndv_mul_c(int mod,NDV p,int mul); |
void ndv_mul_c(int mod,NDV p,int mul); |
void ndv_mul_c_q(NDV p,Q mul); |
void ndv_mul_c_q(NDV p,Q mul); |
void ndv_realloc(NDV p,int obpe,int oadv); |
void ndv_realloc(NDV p,int obpe,int oadv,EPOS oepos); |
ND ndv_mul_nm(int mod,NDV p,NM m0); |
ND ndv_mul_nm(int mod,NDV p,NM m0); |
void ndv_dehomogenize(NDV p); |
void ndv_dehomogenize(NDV p); |
void ndv_removecont(int mod,NDV p); |
void ndv_removecont(int mod,NDV p); |
Line 402 void ndl_dehomogenize(unsigned int *d) |
|
Line 428 void ndl_dehomogenize(unsigned int *d) |
|
unsigned int h; |
unsigned int h; |
int i,bits; |
int i,bits; |
|
|
if ( nd_isrlex ) { |
if ( nd_blockmask ) { |
if ( nd_bpe == 32 ) { |
h = GET_EXP(d,nd_nvar-1); |
h = d[nd_exporigin]; |
TD(d) -= h; |
for ( i = nd_exporigin+1; i < nd_wpd; i++ ) |
d[nd_exporigin-1] -= h; |
d[i-1] = d[i]; |
} else { |
d[i-1] = 0; |
if ( nd_isrlex ) { |
TD(d) -= h; |
if ( nd_bpe == 32 ) { |
} else { |
h = d[nd_exporigin]; |
bits = nd_epw*nd_bpe; |
for ( i = nd_exporigin+1; i < nd_wpd; i++ ) |
mask = bits==32?0xffffffff:((1<<(nd_epw*nd_bpe))-1); |
d[i-1] = d[i]; |
h = (d[nd_exporigin]>>((nd_epw-1)*nd_bpe))&nd_mask0; |
d[i-1] = 0; |
for ( i = nd_exporigin; i < nd_wpd; i++ ) |
TD(d) -= h; |
d[i] = ((d[i]<<nd_bpe)&mask) |
} else { |
|(i+1<nd_wpd?((d[i+1]>>((nd_epw-1)*nd_bpe))&nd_mask0):0); |
bits = nd_epw*nd_bpe; |
TD(d) -= h; |
mask = bits==32?0xffffffff:((1<<(nd_epw*nd_bpe))-1); |
} |
h = (d[nd_exporigin]>>((nd_epw-1)*nd_bpe))&nd_mask0; |
} else |
for ( i = nd_exporigin; i < nd_wpd; i++ ) |
TD(d) -= ((d[(nd_nvar-1)/nd_epw+nd_exporigin]>> |
d[i] = ((d[i]<<nd_bpe)&mask) |
((nd_epw-((nd_nvar-1)%nd_epw)-1)*nd_bpe))&((1<<nd_bpe)-1)); |
|(i+1<nd_wpd?((d[i+1]>>((nd_epw-1)*nd_bpe))&nd_mask0):0); |
|
TD(d) -= h; |
|
} |
|
} else |
|
TD(d) -= GET_EXP(d,nd_nvar-1); |
|
} |
} |
} |
|
|
void ndl_lcm(unsigned int *d1,unsigned *d2,unsigned int *d) |
void ndl_lcm(unsigned int *d1,unsigned *d2,unsigned int *d) |
{ |
{ |
unsigned int t1,t2,u,u1,u2; |
unsigned int t1,t2,u,u1,u2; |
int i,j; |
int i,j,l; |
|
|
switch ( nd_bpe ) { |
switch ( nd_bpe ) { |
case 4: |
case 4: |
Line 489 void ndl_lcm(unsigned int *d1,unsigned *d2,unsigned in |
|
Line 520 void ndl_lcm(unsigned int *d1,unsigned *d2,unsigned in |
|
break; |
break; |
} |
} |
TD(d) = ndl_weight(d); |
TD(d) = ndl_weight(d); |
|
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) |
int ndl_weight(unsigned int *d) |
Line 504 int ndl_weight(unsigned int *d) |
|
Line 540 int ndl_weight(unsigned int *d) |
|
return t; |
return t; |
} |
} |
|
|
INLINE int ndl_lex_compare(unsigned int *d1,unsigned int *d2) |
int ndl_weight_mask(unsigned int *d,int index) |
{ |
{ |
|
unsigned int t,u; |
|
unsigned int *mask; |
|
int i,j; |
|
|
|
mask = nd_blockmask->mask[index]; |
|
for ( t = 0, i = nd_exporigin; i < nd_wpd; i++ ) { |
|
u = d[i]&mask[i]; |
|
for ( j = 0; j < nd_epw; j++, u>>=nd_bpe ) |
|
t += (u&nd_mask0); |
|
} |
|
return t; |
|
} |
|
|
|
int ndl_lex_compare(unsigned int *d1,unsigned int *d2) |
|
{ |
int i; |
int i; |
|
|
d1 += nd_exporigin; |
d1 += nd_exporigin; |
Line 518 INLINE int ndl_lex_compare(unsigned int *d1,unsigned i |
|
Line 569 INLINE int ndl_lex_compare(unsigned int *d1,unsigned i |
|
return 0; |
return 0; |
} |
} |
|
|
|
int ndl_block_compare(unsigned int *d1,unsigned int *d2) |
|
{ |
|
int i,l,j,ord_o,ord_l; |
|
struct order_pair *op; |
|
unsigned int t1,t2,m; |
|
unsigned int *mask; |
|
|
|
l = nd_blockmask->n; |
|
op = nd_blockmask->order_pair; |
|
for ( j = 0; j < l; j++ ) { |
|
mask = nd_blockmask->mask[j]; |
|
ord_o = op[j].order; |
|
if ( ord_o < 2 ) |
|
if ( (t1=d1[j+1]) > (t2=d2[j+1]) ) return 1; |
|
else if ( t1 < t2 ) return -1; |
|
for ( i = nd_exporigin; i < nd_wpd; i++ ) { |
|
m = mask[i]; |
|
t1 = d1[i]&m; |
|
t2 = d2[i]&m; |
|
if ( t1 > t2 ) |
|
return !ord_o ? -1 : 1; |
|
else if ( t1 < t2 ) |
|
return !ord_o ? 1 : -1; |
|
} |
|
} |
|
return 0; |
|
} |
|
|
INLINE int ndl_equal(unsigned int *d1,unsigned int *d2) |
INLINE int ndl_equal(unsigned int *d1,unsigned int *d2) |
{ |
{ |
int i; |
int i; |
Line 553 INLINE void ndl_add(unsigned int *d1,unsigned int *d2, |
|
Line 632 INLINE void ndl_add(unsigned int *d1,unsigned int *d2, |
|
{ |
{ |
int i; |
int i; |
|
|
|
#if 1 |
switch ( nd_wpd ) { |
switch ( nd_wpd ) { |
case 2: |
case 2: |
TD(d) = TD(d1)+TD(d2); |
TD(d) = TD(d1)+TD(d2); |
Line 564 INLINE void ndl_add(unsigned int *d1,unsigned int *d2, |
|
Line 644 INLINE void ndl_add(unsigned int *d1,unsigned int *d2, |
|
d[2] = d1[2]+d2[2]; |
d[2] = d1[2]+d2[2]; |
break; |
break; |
default: |
default: |
for ( i = 0; i < nd_wpd; i++ ) |
for ( i = 0; i < nd_wpd; i++ ) d[i] = d1[i]+d2[i]; |
d[i] = d1[i]+d2[i]; |
|
break; |
break; |
} |
} |
|
#else |
|
for ( i = 0; i < nd_wpd; i++ ) d[i] = d1[i]+d2[i]; |
|
#endif |
} |
} |
|
|
INLINE void ndl_sub(unsigned int *d1,unsigned int *d2,unsigned int *d) |
INLINE void ndl_sub(unsigned int *d1,unsigned int *d2,unsigned int *d) |
{ |
{ |
int i; |
int i; |
|
|
for ( i = 0; i < nd_wpd; i++ ) |
for ( i = 0; i < nd_wpd; i++ ) d[i] = d1[i]-d2[i]; |
d[i] = d1[i]-d2[i]; |
|
} |
} |
|
|
int ndl_disjoint(unsigned int *d1,unsigned int *d2) |
int ndl_disjoint(unsigned int *d1,unsigned int *d2) |
Line 2066 void nd_gr_trace(LIST f,LIST v,int m,int homo,struct o |
|
Line 2147 void nd_gr_trace(LIST f,LIST v,int m,int homo,struct o |
|
void dltondl(int n,DL dl,unsigned int *r) |
void dltondl(int n,DL dl,unsigned int *r) |
{ |
{ |
unsigned int *d; |
unsigned int *d; |
int i; |
int i,j,l,s,ord_l,ord_o; |
|
struct order_pair *op; |
|
|
d = dl->d; |
d = dl->d; |
for ( i = 0; i < nd_wpd; i++ ) r[i] = 0; |
for ( i = 0; i < nd_wpd; i++ ) r[i] = 0; |
if ( nd_isrlex ) |
if ( nd_blockmask ) { |
for ( i = 0; i < n; i++ ) |
l = nd_blockmask->n; |
r[(n-1-i)/nd_epw+nd_exporigin] |= (d[i]<<((nd_epw-((n-1-i)%nd_epw)-1)*nd_bpe)); |
op = nd_blockmask->order_pair; |
else |
for ( j = 0, s = 0; j < l; j++ ) { |
for ( i = 0; i < n; i++ ) |
ord_o = op[j].order; |
r[i/nd_epw+nd_exporigin] |= d[i]<<((nd_epw-(i%nd_epw)-1)*nd_bpe); |
ord_l = op[j].length; |
TD(r) = ndl_weight(r); |
if ( !ord_o ) |
|
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++ ) |
|
r[j+1] = ndl_weight_mask(r,j); |
|
} else { |
|
if ( nd_isrlex ) |
|
for ( i = 0; i < n; i++ ) PUT_EXP(r,n-1-i,d[i]); |
|
else |
|
for ( i = 0; i < n; i++ ) PUT_EXP(r,i,d[i]); |
|
TD(r) = ndl_weight(r); |
|
} |
} |
} |
|
|
DL ndltodl(int n,unsigned int *ndl) |
DL ndltodl(int n,unsigned int *ndl) |
{ |
{ |
DL dl; |
DL dl; |
int *d; |
int *d; |
int i; |
int i,j,l,s,ord_l,ord_o; |
|
struct order_pair *op; |
|
|
NEWDL(dl,n); |
NEWDL(dl,n); |
dl->td = TD(ndl); |
dl->td = TD(ndl); |
d = dl->d; |
d = dl->d; |
if ( nd_isrlex ) |
if ( nd_blockmask ) { |
for ( i = 0; i < n; i++ ) |
l = nd_blockmask->n; |
d[i] = (ndl[(n-1-i)/nd_epw+nd_exporigin]>>((nd_epw-((n-1-i)%nd_epw)-1)*nd_bpe)) |
op = nd_blockmask->order_pair; |
&((1<<nd_bpe)-1); |
for ( j = 0, s = 0; j < l; j++ ) { |
else |
ord_o = op[j].order; |
for ( i = 0; i < n; i++ ) |
ord_l = op[j].length; |
d[i] = (ndl[i/nd_epw+nd_exporigin]>>((nd_epw-(i%nd_epw)-1)*nd_bpe)) |
if ( !ord_o ) |
&((1<<nd_bpe)-1); |
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 { |
|
if ( nd_isrlex ) |
|
for ( i = 0; i < n; i++ ) |
|
d[i] = GET_EXP(ndl,n-1-i); |
|
else |
|
for ( i = 0; i < n; i++ ) |
|
d[i] = GET_EXP(ndl,i); |
|
} |
return dl; |
return dl; |
} |
} |
|
|
Line 2148 DP ndtodp(int mod,ND p) |
|
Line 2262 DP ndtodp(int mod,ND p) |
|
void ndl_print(unsigned int *dl) |
void ndl_print(unsigned int *dl) |
{ |
{ |
int n; |
int n; |
int i; |
int i,j,l,ord_o,ord_l,s,s0; |
|
struct order_pair *op; |
|
|
n = nd_nvar; |
n = nd_nvar; |
printf("<<"); |
printf("<<"); |
if ( nd_isrlex ) |
if ( nd_blockmask ) { |
for ( i = 0; i < n; i++ ) |
l = nd_blockmask->n; |
printf(i==n-1?"%d":"%d,", |
op = nd_blockmask->order_pair; |
(dl[(n-1-i)/nd_epw+nd_exporigin]>>((nd_epw-((n-1-i)%nd_epw)-1)*nd_bpe)) |
for ( j = 0, s = s0 = 0; j < l; j++ ) { |
&((1<<nd_bpe)-1)); |
ord_o = op[j].order; |
else |
ord_l = op[j].length; |
for ( i = 0; i < n; i++ ) |
if ( !ord_o ) |
printf(i==n-1?"%d":"%d,", |
for ( i = 0, s0 += ord_l; i < ord_l; i++, s++ ) |
(dl[i/nd_epw+nd_exporigin]>>((nd_epw-(i%nd_epw)-1)*nd_bpe)) |
printf(s==n-1?"%d":"%d,",GET_EXP(dl,s0-i-1)); |
&((1<<nd_bpe)-1)); |
else |
|
for ( i = 0; i < ord_l; i++, s++ ) |
|
printf(s==n-1?"%d":"%d,",GET_EXP(dl,s)); |
|
} |
|
} else { |
|
if ( nd_isrlex ) |
|
for ( i = 0; i < n; i++ ) printf(i==n-1?"%d":"%d,",GET_EXP(dl,n-1-i)); |
|
else |
|
for ( i = 0; i < n; i++ ) printf(i==n-1?"%d":"%d,",GET_EXP(dl,i)); |
|
} |
printf(">>"); |
printf(">>"); |
} |
} |
|
|
Line 2432 unsigned int *nd_compute_bound(ND p) |
|
Line 2556 unsigned int *nd_compute_bound(ND p) |
|
} |
} |
l = nd_nvar+31; |
l = nd_nvar+31; |
t = (unsigned int *)MALLOC_ATOMIC(l*sizeof(unsigned int)); |
t = (unsigned int *)MALLOC_ATOMIC(l*sizeof(unsigned int)); |
for ( i = 0; i < l; i++ ) t[i] = 0; |
for ( i = 0; i < nd_nvar; i++ ) t[i] = GET_EXP(d1,i); |
for ( i = 0; i < nd_nvar; i++ ) |
|
t[i] = (d1[i/nd_epw+nd_exporigin]>>((nd_epw-(i%nd_epw)-1)*nd_bpe))&nd_mask0; |
|
for ( ; i < l; i++ ) t[i] = 0; |
for ( ; i < l; i++ ) t[i] = 0; |
return t; |
return t; |
} |
} |
|
|
void nd_setup_parameters() { |
void nd_setup_parameters() { |
int i; |
int i,n,elen; |
|
|
nd_epw = (sizeof(unsigned int)*8)/nd_bpe; |
nd_epw = (sizeof(unsigned int)*8)/nd_bpe; |
nd_wpd = nd_nvar/nd_epw+(nd_nvar%nd_epw?1:0); |
elen = nd_nvar/nd_epw+(nd_nvar%nd_epw?1:0); |
|
|
switch ( nd_ord->id ) { |
switch ( nd_ord->id ) { |
case 0: |
case 0: |
nd_exporigin = 1; |
nd_exporigin = 1; |
break; |
break; |
case 1: |
case 1: |
/* block order */ |
/* block order */ |
nd_exporigin = nd_ord->ord.block.length; |
/* d[0]:weight d[1]:w0,...,d[nd_exporigin-1]:w(n-1) */ |
|
nd_exporigin = nd_ord->ord.block.length+1; |
break; |
break; |
case 2: |
case 2: |
error("nd_setup_parameters : matrix order is not supported yet."); |
error("nd_setup_parameters : matrix order is not supported yet."); |
break; |
break; |
} |
} |
nd_wpd += nd_exporigin; |
nd_wpd = nd_exporigin+elen; |
|
nd_epos = (EPOS)MALLOC_ATOMIC(nd_nvar*sizeof(struct oEPOS)); |
|
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 ) { |
if ( nd_bpe < 32 ) { |
nd_mask0 = (1<<nd_bpe)-1; |
nd_mask0 = (1<<nd_bpe)-1; |
} else { |
} else { |
Line 2470 void nd_setup_parameters() { |
|
Line 2599 void nd_setup_parameters() { |
|
} |
} |
nm_adv = sizeof(struct oNM)+(nd_wpd-1)*sizeof(unsigned int); |
nm_adv = sizeof(struct oNM)+(nd_wpd-1)*sizeof(unsigned int); |
nmv_adv = sizeof(struct oNMV)+(nd_wpd-1)*sizeof(unsigned int); |
nmv_adv = sizeof(struct oNMV)+(nd_wpd-1)*sizeof(unsigned int); |
|
nd_blockmask = nd_create_blockmask(nd_ord); |
} |
} |
|
|
ND_pairs nd_reconstruct(int mod,int trace,ND_pairs d) |
ND_pairs nd_reconstruct(int mod,int trace,ND_pairs d) |
Line 2480 ND_pairs nd_reconstruct(int mod,int trace,ND_pairs d) |
|
Line 2610 ND_pairs nd_reconstruct(int mod,int trace,ND_pairs d) |
|
RHist r; |
RHist r; |
RHist *old_red; |
RHist *old_red; |
ND_pairs s0,s,t,prev_ndp_free_list; |
ND_pairs s0,s,t,prev_ndp_free_list; |
|
EPOS oepos; |
|
|
obpe = nd_bpe; |
obpe = nd_bpe; |
oadv = nmv_adv; |
oadv = nmv_adv; |
|
oepos = nd_epos; |
if ( obpe < 4 ) nd_bpe = 4; |
if ( obpe < 4 ) nd_bpe = 4; |
else if ( obpe < 6 ) nd_bpe = 6; |
else if ( obpe < 6 ) nd_bpe = 6; |
else if ( obpe < 8 ) nd_bpe = 8; |
else if ( obpe < 8 ) nd_bpe = 8; |
Line 2496 ND_pairs nd_reconstruct(int mod,int trace,ND_pairs d) |
|
Line 2628 ND_pairs nd_reconstruct(int mod,int trace,ND_pairs d) |
|
_nm_free_list = 0; |
_nm_free_list = 0; |
_ndp_free_list = 0; |
_ndp_free_list = 0; |
if ( mod != 0 ) |
if ( mod != 0 ) |
for ( i = nd_psn-1; i >= 0; i-- ) ndv_realloc(nd_ps[i],obpe,oadv); |
for ( i = nd_psn-1; i >= 0; i-- ) ndv_realloc(nd_ps[i],obpe,oadv,oepos); |
if ( !mod || trace ) |
if ( !mod || trace ) |
for ( i = nd_psn-1; i >= 0; i-- ) ndv_realloc(nd_psq[i],obpe,oadv); |
for ( i = nd_psn-1; i >= 0; i-- ) ndv_realloc(nd_psq[i],obpe,oadv,oepos); |
s0 = 0; |
s0 = 0; |
for ( t = d; t; t = NEXT(t) ) { |
for ( t = d; t; t = NEXT(t) ) { |
NEXTND_pairs(s0,s); |
NEXTND_pairs(s0,s); |
s->i1 = t->i1; |
s->i1 = t->i1; |
s->i2 = t->i2; |
s->i2 = t->i2; |
SG(s) = SG(t); |
SG(s) = SG(t); |
ndl_reconstruct(obpe,LCM(t),LCM(s)); |
ndl_reconstruct(obpe,oepos,LCM(t),LCM(s)); |
} |
} |
|
|
old_red = (RHist *)ALLOCA(REDTAB_LEN*sizeof(RHist)); |
old_red = (RHist *)ALLOCA(REDTAB_LEN*sizeof(RHist)); |
Line 2518 ND_pairs nd_reconstruct(int mod,int trace,ND_pairs d) |
|
Line 2650 ND_pairs nd_reconstruct(int mod,int trace,ND_pairs d) |
|
NEWRHist(mr); |
NEWRHist(mr); |
mr->index = r->index; |
mr->index = r->index; |
SG(mr) = SG(r); |
SG(mr) = SG(r); |
ndl_reconstruct(obpe,DL(r),DL(mr)); |
ndl_reconstruct(obpe,oepos,DL(r),DL(mr)); |
h = ndl_hash_value(DL(mr)); |
h = ndl_hash_value(DL(mr)); |
NEXT(mr) = nd_red[h]; |
NEXT(mr) = nd_red[h]; |
nd_red[h] = mr; |
nd_red[h] = mr; |
Line 2527 ND_pairs nd_reconstruct(int mod,int trace,ND_pairs d) |
|
Line 2659 ND_pairs nd_reconstruct(int mod,int trace,ND_pairs d) |
|
old_red = 0; |
old_red = 0; |
for ( i = 0; i < nd_psn; i++ ) { |
for ( i = 0; i < nd_psn; i++ ) { |
NEWRHist(r); SG(r) = SG(nd_psh[i]); |
NEWRHist(r); SG(r) = SG(nd_psh[i]); |
ndl_reconstruct(obpe,DL(nd_psh[i]),DL(r)); |
ndl_reconstruct(obpe,oepos,DL(nd_psh[i]),DL(r)); |
nd_psh[i] = r; |
nd_psh[i] = r; |
} |
} |
if ( s0 ) NEXT(s) = 0; |
if ( s0 ) NEXT(s) = 0; |
Line 2545 void nd_reconstruct_direct(int mod,NDV *ps,int len) |
|
Line 2677 void nd_reconstruct_direct(int mod,NDV *ps,int len) |
|
RHist r; |
RHist r; |
RHist *old_red; |
RHist *old_red; |
ND_pairs s0,s,t,prev_ndp_free_list; |
ND_pairs s0,s,t,prev_ndp_free_list; |
|
EPOS oepos; |
|
|
obpe = nd_bpe; |
obpe = nd_bpe; |
oadv = nmv_adv; |
oadv = nmv_adv; |
|
oepos = nd_epos; |
if ( obpe < 4 ) nd_bpe = 4; |
if ( obpe < 4 ) nd_bpe = 4; |
else if ( obpe < 6 ) nd_bpe = 6; |
else if ( obpe < 6 ) nd_bpe = 6; |
else if ( obpe < 8 ) nd_bpe = 8; |
else if ( obpe < 8 ) nd_bpe = 8; |
Line 2559 void nd_reconstruct_direct(int mod,NDV *ps,int len) |
|
Line 2693 void nd_reconstruct_direct(int mod,NDV *ps,int len) |
|
prev_nm_free_list = _nm_free_list; |
prev_nm_free_list = _nm_free_list; |
prev_ndp_free_list = _ndp_free_list; |
prev_ndp_free_list = _ndp_free_list; |
_nm_free_list = 0; _ndp_free_list = 0; |
_nm_free_list = 0; _ndp_free_list = 0; |
for ( i = len-1; i >= 0; i-- ) ndv_realloc(ps[i],obpe,oadv); |
for ( i = len-1; i >= 0; i-- ) ndv_realloc(ps[i],obpe,oadv,oepos); |
old_red = (RHist *)ALLOCA(REDTAB_LEN*sizeof(RHist)); |
old_red = (RHist *)ALLOCA(REDTAB_LEN*sizeof(RHist)); |
for ( i = 0; i < REDTAB_LEN; i++ ) { |
for ( i = 0; i < REDTAB_LEN; i++ ) { |
old_red[i] = nd_red[i]; |
old_red[i] = nd_red[i]; |
Line 2570 void nd_reconstruct_direct(int mod,NDV *ps,int len) |
|
Line 2704 void nd_reconstruct_direct(int mod,NDV *ps,int len) |
|
NEWRHist(mr); |
NEWRHist(mr); |
mr->index = r->index; |
mr->index = r->index; |
SG(mr) = SG(r); |
SG(mr) = SG(r); |
ndl_reconstruct(obpe,DL(r),DL(mr)); |
ndl_reconstruct(obpe,oepos,DL(r),DL(mr)); |
h = ndl_hash_value(DL(mr)); |
h = ndl_hash_value(DL(mr)); |
NEXT(mr) = nd_red[h]; |
NEXT(mr) = nd_red[h]; |
nd_red[h] = mr; |
nd_red[h] = mr; |
Line 2582 void nd_reconstruct_direct(int mod,NDV *ps,int len) |
|
Line 2716 void nd_reconstruct_direct(int mod,NDV *ps,int len) |
|
GC_gcollect(); |
GC_gcollect(); |
} |
} |
|
|
void ndl_reconstruct(int obpe,unsigned int *d,unsigned int *r) |
void ndl_reconstruct(int obpe,EPOS oepos,unsigned int *d,unsigned int *r) |
{ |
{ |
int n,i,ei,oepw,cepw,cbpe; |
int n,i,ei,oepw,omask0,j,s,ord_l,ord_o,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)) |
|
|
n = nd_nvar; |
n = nd_nvar; |
oepw = (sizeof(unsigned int)*8)/obpe; |
oepw = (sizeof(unsigned int)*8)/obpe; |
cepw = nd_epw; |
omask0 = (1<<obpe)-1; |
cbpe = nd_bpe; |
|
TD(r) = TD(d); |
TD(r) = TD(d); |
for ( i = nd_exporigin; i < nd_wpd; i++ ) r[i] = 0; |
for ( i = nd_exporigin; i < nd_wpd; i++ ) r[i] = 0; |
if ( nd_isrlex ) |
if ( nd_blockmask ) { |
for ( i = 0; i < n; i++ ) { |
l = nd_blockmask->n; |
ei = (d[(n-1-i)/oepw+nd_exporigin]>>((oepw-((n-1-i)%oepw)-1)*obpe)) |
op = nd_blockmask->order_pair; |
&((1<<obpe)-1); |
for ( i = 1; i < nd_exporigin; i++ ) |
r[(n-1-i)/cepw+nd_exporigin] |= (ei<<((cepw-((n-1-i)%cepw)-1)*cbpe)); |
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++ ) { |
|
ei = GET_EXP_OLD(d,s+ord_l-i-1); |
|
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 |
} else { |
for ( i = 0; i < n; i++ ) { |
if ( nd_isrlex ) |
ei = (d[i/oepw+nd_exporigin]>>((oepw-(i%oepw)-1)*obpe)) |
for ( i = 0; i < n; i++ ) { |
&((1<<obpe)-1); |
ei = GET_EXP_OLD(d,n-1-i); |
r[i/cepw+nd_exporigin] |= (ei<<((cepw-(i%cepw)-1)*cbpe)); |
PUT_EXP(r,n-1-i,ei); |
} |
} |
} |
else |
|
for ( i = 0; i < n; i++ ) { |
void nd_realloc(ND p,int obpe) |
ei = GET_EXP_OLD(d,i); |
{ |
PUT_EXP(r,i,ei); |
NM m,mr,mr0; |
} |
|
|
if ( p ) { |
|
m = BDY(p); |
|
for ( mr0 = 0; m; m = NEXT(m) ) { |
|
NEXTNM(mr0,mr); |
|
CM(mr) = CM(m); |
|
ndl_reconstruct(obpe,DL(m),DL(mr)); |
|
} |
|
NEXT(mr) = 0; |
|
BDY(p) = mr0; |
|
} |
} |
} |
} |
|
|
Line 2740 ND ndv_mul_nm(int mod,NDV p,NM m0) |
|
Line 2880 ND ndv_mul_nm(int mod,NDV p,NM m0) |
|
} |
} |
} |
} |
|
|
void ndv_realloc(NDV p,int obpe,int oadv) |
void ndv_realloc(NDV p,int obpe,int oadv,EPOS oepos) |
{ |
{ |
NMV m,mr,mr0,t; |
NMV m,mr,mr0,t; |
int len,i,k; |
int len,i,k; |
Line 2757 void ndv_realloc(NDV p,int obpe,int oadv) |
|
Line 2897 void ndv_realloc(NDV p,int obpe,int oadv) |
|
for ( i = 0; i < len; i++, NMV_OPREV(m), NMV_PREV(mr) ) { |
for ( i = 0; i < len; i++, NMV_OPREV(m), NMV_PREV(mr) ) { |
CQ(t) = CQ(m); |
CQ(t) = CQ(m); |
for ( k = 0; k < nd_wpd; k++ ) DL(t)[k] = 0; |
for ( k = 0; k < nd_wpd; k++ ) DL(t)[k] = 0; |
ndl_reconstruct(obpe,DL(m),DL(t)); |
ndl_reconstruct(obpe,oepos,DL(m),DL(t)); |
CQ(mr) = CQ(t); |
CQ(mr) = CQ(t); |
ndl_copy(DL(t),DL(mr)); |
ndl_copy(DL(t),DL(mr)); |
} |
} |
Line 2911 NODE nd_reducebase(NODE x) |
|
Line 3051 NODE nd_reducebase(NODE x) |
|
return x; |
return x; |
} |
} |
|
|
|
/* XXX incomplete */ |
|
|
void nd_init_ord(struct order_spec *ord) |
void nd_init_ord(struct order_spec *ord) |
{ |
{ |
if ( ord->id ) |
switch ( ord->id ) { |
error("nd_gr : unsupported order"); |
|
nd_dcomp = 0; |
|
switch ( ord->ord.simple ) { |
|
case 0: |
case 0: |
nd_dcomp = 1; |
switch ( ord->ord.simple ) { |
nd_isrlex = 1; |
case 0: |
|
nd_dcomp = 1; |
|
nd_isrlex = 1; |
|
break; |
|
case 1: |
|
nd_dcomp = 1; |
|
nd_isrlex = 0; |
|
break; |
|
case 2: |
|
nd_dcomp = 0; |
|
nd_isrlex = 0; |
|
break; |
|
default: |
|
error("nd_gr : unsupported order"); |
|
} |
break; |
break; |
case 1: |
case 1: |
nd_dcomp = 1; |
/* XXX */ |
|
nd_dcomp = -1; |
nd_isrlex = 0; |
nd_isrlex = 0; |
|
nd_compare_function = ndl_block_compare; |
break; |
break; |
case 9: |
case 2: |
/* td1->td->rlex */ |
error("nd_init_ord : matrix order is not supported yet."); |
nd_dcomp = -dp_nelim; |
|
nd_isrlex = 1; |
|
break; |
break; |
default: |
|
error("nd_gr : unsupported order"); |
|
} |
} |
nd_ord = ord; |
nd_ord = ord; |
} |
} |
|
|
|
BlockMask nd_create_blockmask(struct order_spec *ord) |
|
{ |
|
int n,i,j,s,l; |
|
unsigned int *t; |
|
BlockMask bm; |
|
|
|
if ( !ord->id ) |
|
return 0; |
|
n = ord->ord.block.length; |
|
bm = (BlockMask)MALLOC(sizeof(struct oBlockMask)); |
|
bm->n = n; |
|
bm->order_pair = ord->ord.block.order_pair; |
|
bm->mask = (unsigned int **)MALLOC(n*sizeof(unsigned int *)); |
|
for ( i = 0, s = 0; i < n; i++ ) { |
|
bm->mask[i] = t |
|
= (unsigned int *)MALLOC_ATOMIC(nd_wpd*sizeof(unsigned int)); |
|
for ( j = 0; j < nd_wpd; j++ ) t[j] = 0; |
|
l = bm->order_pair[i].length; |
|
for ( j = 0; j < l; j++, s++ ) PUT_EXP(t,s,nd_mask0); |
|
} |
|
return bm; |
|
} |