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.68 and 1.84

version 1.68, 2003/09/12 15:07:11

version 1.84, 2003/10/18 01:39:42

Line 1

/* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.67 2003/09/12 14:51:27 noro Exp $ */

/* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.83 2003/10/17 05:15:20 noro Exp $ */

#include "ca.h"

#include "parse.h"

#include "ox.h"

#include "inline.h"

#include <time.h>

Line 42 typedef struct oNDV {

Line 44 typedef struct oNDV {

int sugar;

} *NDV;

typedef union oNDC {

int m;

Q z;

P p;

} *NDC;

/* monomial; linked list rep. */

typedef struct oNM {

struct oNM *next;

union {

union oNDC c;

int m;

Q z;

P p;

} c;

UINT dl[1];

} *NM;

/* monomial; array rep. */

typedef struct oNMV {

union {

union oNDC c;

int m;

Q z;

P p;

} c;

UINT dl[1];

} *NMV;

Line 100 typedef struct oBaseSet {

typedef struct oNM_ind_pair

{

NM mul;

int index;

int index,sugar;

} *NM_ind_pair;

typedef struct oIndArray

Line 116 typedef struct oIndArray

int (*ndl_compare_function)(UINT *a1,UINT *a2);

static int ndv_alloc;

static int nd_f4_nsp=0x7fffffff;

static double nd_scale=2;

static UINT **nd_bound;

static struct order_spec *nd_ord;

Line 142 static int nd_found,nd_create,nd_notfirst;

Line 144 static int nd_found,nd_create,nd_notfirst;

static int nm_adv;

static int nmv_adv;

static int nd_dcomp;

static int nd_demand;

extern struct order_spec dp_current_spec;

extern char *Demand;

extern VL CO;

extern int Top,Reverse,dp_nelim,do_weyl;

extern int Top,Reverse,DP_Print,dp_nelim,do_weyl,NoSugar;

extern int *current_weyl_weight_vector;

/* fundamental macros */

Line 210 if(!(r)){NEWNM(r);(c)=(r);}else{NEWNM(NEXT(c));(c)=NEX

Line 215 if(!(r)){NEWNM(r);(c)=(r);}else{NEWNM(NEXT(c));(c)=NEX

if(!(r)){(c)=(r)=(s);}else{NEXT(c)=(s);(c)=(s);}

#define NEXTND_pairs(r,c) \

if(!(r)){NEWND_pairs(r);(c)=(r);}else{NEWND_pairs(NEXT(c));(c)=NEXT(c);}

#define MKNM_ind_pair(p,m,i) (NEWNM_ind_pair(p),(p)->mul=(m),(p)->index=(i))

#define MKNM_ind_pair(p,m,i,s) (NEWNM_ind_pair(p),(p)->mul=(m),(p)->index=(i),(p)->sugar = (s))

/* deallocators */

#define FREENM(m) NEXT(m)=_nm_free_list; _nm_free_list=(m)

Line 225 if(!(r)){NEWND_pairs(r);(c)=(r);}else{NEWND_pairs(NEXT

Line 230 if(!(r)){NEWND_pairs(r);(c)=(r);}else{NEWND_pairs(NEXT

#define NMV_OPREV(m) (m = (NMV)(((char *)m)-oadv))

/* external functions */

#if 1

void GC_gcollect();

#endif

NODE append_one(NODE,int);

/* manipulation of coefficients */

Line 256 ND_pairs crit_B( ND_pairs d, int s );

Line 263 ND_pairs crit_B( ND_pairs d, int s );

ND_pairs crit_M( ND_pairs d1 );

ND_pairs crit_F( ND_pairs d1 );

int crit_2( int dp1, int dp2 );

int ndv_newps(NDV a,NDV aq);

int ndv_newps(int m,NDV a,NDV aq);

/* top level functions */

void nd_gr(LIST f,LIST v,int m,int f4,struct order_spec *ord,LIST *rp);

void nd_gr_trace(LIST f,LIST v,int trace,int homo,struct order_spec *ord,LIST *rp);

NODE nd_f4(int m);

NODE nd_gb(int m,int checkonly);

NODE nd_gb(int m,int ishomo,int checkonly);

NODE nd_gb_trace(int m);

NODE nd_gb_trace(int m,int ishomo);

/* ndl functions */

int ndl_weight(UINT *d);

Line 284 INLINE int ndl_hash_value(UINT *d);

Line 291 INLINE int ndl_hash_value(UINT *d);

/* normal forms */

INLINE int ndl_find_reducer(UINT *g);

INLINE int ndl_find_reducer_direct(UINT *g,NDV *ps,int len);

int nd_sp(int mod,int trace,ND_pairs p,ND *nf);

int nd_nf(int mod,ND g,NDV *ps,int full,ND *nf);

int nd_nf(int mod,ND g,NDV *ps,int full,NDC dn,ND *nf);

int nd_nf_pbucket(int mod,ND g,NDV *ps,int full,ND *nf);

int nd_nf_direct(int mod,ND g,BaseSet base,int full,ND *rp);

/* finalizers */

NODE ndv_reducebase(NODE x);

Line 311 void ndp_print(ND_pairs d);

Line 316 void ndp_print(ND_pairs d);

/* setup, reconstruct */

void nd_init_ord(struct order_spec *spec);

ND_pairs nd_reconstruct(int mod,int trace,ND_pairs ndp);

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

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

void nd_setup_parameters(int nvar,int max);

BlockMask nd_create_blockmask(struct order_spec *ord);

Line 327 void nd_mul_c(int mod,ND p,int mul);

Line 331 void nd_mul_c(int mod,ND p,int mul);

void nd_mul_c_q(ND p,Q mul);

void nd_mul_c_p(VL vl,ND p,P mul);

ND nd_remove_head(ND p);

ND nd_separate_head(ND p,ND *head);

int nd_length(ND p);

void nd_append_red(UINT *d,int i);

UINT *ndv_compute_bound(NDV p);

Line 334 ND nd_copy(ND p);

Line 339 ND nd_copy(ND p);

ND nd_merge(ND p1,ND p2);

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

ND nd_add_q(ND p1,ND p2);

ND nd_add_sf(ND p1,ND p2);

INLINE int nd_length(ND p);

NODE nd_f4_red(int m,ND_pairs sp0,UINT *s0vect,int col,NODE rp0);

NODE nd_f4_red_dist(int m,ND_pairs sp0,UINT *s0vect,int col,NODE rp0);

/* NDV functions */

ND weyl_ndv_mul_nm(int mod,NM m0,NDV p);

Line 351 void ndv_removecont(int mod,NDV p);

Line 359 void ndv_removecont(int mod,NDV p);

void ndv_print(NDV p);

void ndv_print_q(NDV p);

void ndv_free(NDV p);

void ndv_save(NDV p,int index);

NDV ndv_load(int index);

/* converters */

ND ptond(VL vl,VL dvl,P p);

Line 362 int nm_ind_pair_to_vect(int m,UINT *s0,int n,NM_ind_pa

Line 372 int nm_ind_pair_to_vect(int m,UINT *s0,int n,NM_ind_pa

IndArray nm_ind_pair_to_vect_compress(int m,UINT *s0,int n,NM_ind_pair pair);

int nd_to_vect(int mod,UINT *s0,int n,ND d,UINT *r);

/* elimination */

int nd_gauss_elim_mod(int **mat0,int *sugar,int row,int col,int md,int *colstat);

int nd_gauss_elim_sf(int **mat0,int *sugar,int row,int col,int md,int *colstat);

void nd_free_private_storage()

{

_nd_free_list = 0;

_nm_free_list = 0;

_ndp_free_list = 0;

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

#if 0

GC_gcollect();

#endif

}

void _NM_alloc()

Line 770 INLINE int ndl_equal(UINT *d1,UINT *d2)

Line 784 INLINE int ndl_equal(UINT *d1,UINT *d2)

{

int i;

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

switch ( nd_wpd ) {

if ( *d1++ != *d2++ )

case 2:

return 0;

if ( TD(d2) != TD(d1) ) return 0;

return 1;

if ( d2[1] != d1[1] ) return 0;

return 1;

break;

case 3:

if ( TD(d2) != TD(d1) ) return 0;

if ( d2[1] != d1[1] ) return 0;

if ( d2[2] != d1[2] ) return 0;

return 1;

break;

default:

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

if ( *d1++ != *d2++ ) return 0;

return 1;

break;

}

INLINE void ndl_copy(UINT *d1,UINT *d2)

Line 1048 int ndl_check_bound2(int index,UINT *d2)

Line 1076 int ndl_check_bound2(int index,UINT *d2)

#endif

}

int ndl_check_bound2_direct(UINT *d1,UINT *d2)

{

UINT u2;

int i,j,ind,k;

ind = 0;

#if USE_UNROLL

switch ( nd_bpe ) {

case 3:

for ( i = nd_exporigin; i < nd_wpd; i++ ) {

u2 = d2[i];

if ( d1[ind++]+((u2>>27)&0x7) >= 0x8 ) return 1;

if ( d1[ind++]+((u2>>24)&0x7) >= 0x8 ) return 1;

if ( d1[ind++]+((u2>>21)&0x7) >= 0x8 ) return 1;

if ( d1[ind++]+((u2>>18)&0x7) >= 0x8 ) return 1;

if ( d1[ind++]+((u2>>15)&0x7) >= 0x8 ) return 1;

if ( d1[ind++]+((u2>>12)&0x7) >= 0x8 ) return 1;

if ( d1[ind++]+((u2>>9)&0x7) >= 0x8 ) return 1;

if ( d1[ind++]+((u2>>6)&0x7) >= 0x8 ) return 1;

if ( d1[ind++]+((u2>>3)&0x7) >= 0x8 ) return 1;

if ( d1[ind++]+(u2&0x7) >= 0x8 ) return 1;

}

return 0;

break;

case 4:

for ( i = nd_exporigin; i < nd_wpd; i++ ) {

u2 = d2[i];

if ( d1[ind++]+((u2>>28)&0xf) >= 0x10 ) return 1;

if ( d1[ind++]+((u2>>24)&0xf) >= 0x10 ) return 1;

if ( d1[ind++]+((u2>>20)&0xf) >= 0x10 ) return 1;

if ( d1[ind++]+((u2>>16)&0xf) >= 0x10 ) return 1;

if ( d1[ind++]+((u2>>12)&0xf) >= 0x10 ) return 1;

if ( d1[ind++]+((u2>>8)&0xf) >= 0x10 ) return 1;

if ( d1[ind++]+((u2>>4)&0xf) >= 0x10 ) return 1;

if ( d1[ind++]+(u2&0xf) >= 0x10 ) return 1;

}

return 0;

break;

case 6:

for ( i = nd_exporigin; i < nd_wpd; i++ ) {

u2 = d2[i];

if ( d1[ind++]+((u2>>24)&0x3f) >= 0x40 ) return 1;

if ( d1[ind++]+((u2>>18)&0x3f) >= 0x40 ) return 1;

if ( d1[ind++]+((u2>>12)&0x3f) >= 0x40 ) return 1;

if ( d1[ind++]+((u2>>6)&0x3f) >= 0x40 ) return 1;

if ( d1[ind++]+(u2&0x3f) >= 0x40 ) return 1;

}

return 0;

break;

case 8:

for ( i = nd_exporigin; i < nd_wpd; i++ ) {

u2 = d2[i];

if ( d1[ind++]+((u2>>24)&0xff) >= 0x100 ) return 1;

if ( d1[ind++]+((u2>>16)&0xff) >= 0x100 ) return 1;

if ( d1[ind++]+((u2>>8)&0xff) >= 0x100 ) return 1;

if ( d1[ind++]+(u2&0xff) >= 0x100 ) return 1;

}

return 0;

break;

case 16:

for ( i = nd_exporigin; i < nd_wpd; i++ ) {

u2 = d2[i];

if ( d1[ind++]+((u2>>16)&0xffff) > 0x10000 ) return 1;

if ( d1[ind++]+(u2&0xffff) > 0x10000 ) return 1;

}

return 0;

break;

case 32:

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

if ( d1[i]+d2[i]<d1[i] ) return 1;

return 0;

break;

default:

for ( i = nd_exporigin; i < nd_wpd; i++ ) {

u2 = d2[i];

k = (nd_epw-1)*nd_bpe;

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

if ( d1[ind++]+((u2>>k)&nd_mask0) > nd_mask0 ) return 1;

}

return 0;

break;

}

#else

for ( i = nd_exporigin; i < nd_wpd; i++ ) {

u2 = d2[i];

k = (nd_epw-1)*nd_bpe;

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

if ( d1[ind++]+((u2>>k)&nd_mask0) > nd_mask0 ) return 1;

}

return 0;

#endif

}

INLINE int ndl_hash_value(UINT *d)

{

int i;

Line 1186 INLINE int ndl_find_reducer(UINT *dg)

Line 1121 INLINE int ndl_find_reducer(UINT *dg)

return -1;

}

INLINE int ndl_find_reducer_direct(UINT *dg,NDV *ps,int len)

{

NDV r;

RHist s;

int d,k,i;

if ( Reverse )

for ( i = len-1; i >= 0; i-- ) {

r = ps[i];

if ( ndl_reducible(dg,HDL(r)) )

return i;

}

else

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

r = ps[i];

if ( ndl_reducible(dg,HDL(r)) )

return i;

}

return -1;

}

ND nd_merge(ND p1,ND p2)

{

int n,c;

Line 1258 ND nd_add(int mod,ND p1,ND p2)

Line 1172 ND nd_add(int mod,ND p1,ND p2)

if ( !p1 ) return p2;

else if ( !p2 ) return p1;

else if ( mod == -1 ) return nd_add_sf(p1,p2);

else if ( !mod ) return nd_add_q(p1,p2);

else {

can = 0;

Line 1345 ND nd_add_q(ND p1,ND p2)

Line 1260 ND nd_add_q(ND p1,ND p2)

}

ND nd_add_sf(ND p1,ND p2)

{

int n,c,can;

ND r;

NM m1,m2,mr0,mr,s;

int t;

if ( !p1 ) return p2;

else if ( !p2 ) return p1;

else {

can = 0;

for ( n = NV(p1), m1 = BDY(p1), m2 = BDY(p2), mr0 = 0; m1 && m2; ) {

c = DL_COMPARE(DL(m1),DL(m2));

switch ( c ) {

case 0:

t = _addsf(CM(m1),CM(m2));

s = m1; m1 = NEXT(m1);

if ( t ) {

can++; NEXTNM2(mr0,mr,s); CM(mr) = (t);

} else {

can += 2; FREENM(s);

}

s = m2; m2 = NEXT(m2); FREENM(s);

break;

case 1:

s = m1; m1 = NEXT(m1); NEXTNM2(mr0,mr,s);

break;

case -1:

s = m2; m2 = NEXT(m2); NEXTNM2(mr0,mr,s);

break;

}

if ( !mr0 )

if ( m1 ) mr0 = m1;

else if ( m2 ) mr0 = m2;

else return 0;

else if ( m1 ) NEXT(mr) = m1;

else if ( m2 ) NEXT(mr) = m2;

else NEXT(mr) = 0;

BDY(p1) = mr0;

SG(p1) = MAX(SG(p1),SG(p2));

LEN(p1) = LEN(p1)+LEN(p2)-can;

FREEND(p2);

return p1;

}

/* ret=1 : success, ret=0 : overflow */

int nd_nf(int mod,ND g,NDV *ps,int full,ND *rp)

int nd_nf(int mod,ND g,NDV *ps,int full,NDC dn,ND *rp)

{

ND d;

NM m,mrd,tail;

Line 1355 int nd_nf(int mod,ND g,NDV *ps,int full,ND *rp)

Line 1317 int nd_nf(int mod,ND g,NDV *ps,int full,ND *rp)

int c,c1,c2,dummy;

RHist h;

NDV p,red;

Q cg,cred,gcd;

Q cg,cred,gcd,tq,qq;

double hmag;

if ( dn ) {

if ( mod )

dn->m = 1;

else

dn->z = ONE;

}

if ( !g ) {

*rp = 0;

return 1;

Line 1376 int nd_nf(int mod,ND g,NDV *ps,int full,ND *rp)

Line 1344 int nd_nf(int mod,ND g,NDV *ps,int full,ND *rp)

nd_free(g); nd_free(d);

return 0;

}

p = ps[index];

if ( nd_demand )

if ( mod ) {

p = ndv_load(index);

else

p = ps[index];

if ( mod == -1 )

CM(mul) = _mulsf(_invsf(HCM(p)),_chsgnsf(HCM(g)));

else if ( mod ) {

c1 = invm(HCM(p),mod); c2 = mod-HCM(g);

DMAR(c1,c2,0,mod,c); CM(mul) = c;

} else {

igcd_cofactor(HCQ(g),HCQ(p),&gcd,&cg,&cred);

chsgnq(cg,&CQ(mul));

nd_mul_c_q(d,cred); nd_mul_c_q(g,cred);

if ( dn ) {

mulq(dn->z,cred,&tq); dn->z = tq;

}

g = nd_add(mod,g,ndv_mul_nm(mod,mul,p));

sugar = MAX(sugar,SG(p)+TD(DL(mul)));

if ( !mod && hmag && g && ((double)(p_mag((P)HCQ(g))) > hmag) ) {

tq = HCQ(g);

nd_removecont2(d,g);

if ( dn ) {

divq(tq,HCQ(g),&qq); divq(dn->z,qq,&tq); dn->z = tq;

}

hmag = ((double)p_mag((P)HCQ(g)))*nd_scale;

}

} else if ( !full ) {

Line 1426 int nd_nf_pbucket(int mod,ND g,NDV *ps,int full,ND *rp

Line 1406 int nd_nf_pbucket(int mod,ND g,NDV *ps,int full,ND *rp

Q cg,cred,gcd,zzz;

RHist h;

double hmag,gmag;

int count = 0;

int hcount = 0;

if ( !g ) {

*rp = 0;

Line 1441 int nd_nf_pbucket(int mod,ND g,NDV *ps,int full,ND *rp

Line 1423 int nd_nf_pbucket(int mod,ND g,NDV *ps,int full,ND *rp

while ( 1 ) {

hindex = mod?head_pbucket(mod,bucket):head_pbucket_q(bucket);

if ( hindex < 0 ) {

if ( DP_Print > 3 ) printf("(%d %d)",count,hcount);

if ( d ) SG(d) = sugar;

*rp = d;

return 1;

Line 1448 int nd_nf_pbucket(int mod,ND g,NDV *ps,int full,ND *rp

Line 1431 int nd_nf_pbucket(int mod,ND g,NDV *ps,int full,ND *rp

g = bucket->body[hindex];

index = ndl_find_reducer(HDL(g));

if ( index >= 0 ) {

count++;

if ( !d ) hcount++;

h = nd_psh[index];

ndl_sub(HDL(g),DL(h),DL(mul));

if ( ndl_check_bound2(index,DL(mul)) ) {

Line 1457 int nd_nf_pbucket(int mod,ND g,NDV *ps,int full,ND *rp

Line 1442 int nd_nf_pbucket(int mod,ND g,NDV *ps,int full,ND *rp

return 0;

}

p = ps[index];

if ( mod ) {

if ( mod == -1 )

CM(mul) = _mulsf(_invsf(HCM(p)),_chsgnsf(HCM(g)));

else if ( mod ) {

c1 = invm(HCM(p),mod); c2 = mod-HCM(g);

DMAR(c1,c2,0,mod,c); CM(mul) = c;

} else {

Line 1508 int nd_nf_pbucket(int mod,ND g,NDV *ps,int full,ND *rp

Line 1495 int nd_nf_pbucket(int mod,ND g,NDV *ps,int full,ND *rp

}

int nd_nf_direct(int mod,ND g,BaseSet base,int full,ND *rp)

{

ND d;

NM m,mrd,tail;

NM mul;

NDV *ps;

int n,sugar,psugar,sugar0,stat,index,len;

int c,c1,c2;

UINT **bound;

RHist h;

NDV p,red;

Q cg,cred,gcd;

double hmag;

if ( !g ) {

*rp = 0;

return 1;

}

#if 0

if ( !mod )

hmag = ((double)p_mag((P)HCQ(g)))*nd_scale;

#else

/* XXX */

hmag = 0;

#endif

ps = base->ps;

bound = base->bound;

len = base->len;

sugar0 = sugar = SG(g);

n = NV(g);

mul = (NM)ALLOCA(sizeof(struct oNM)+(nd_wpd-1)*sizeof(UINT));

for ( d = 0; g; ) {

index = ndl_find_reducer_direct(HDL(g),ps,len);

if ( index >= 0 ) {

p = ps[index];

ndl_sub(HDL(g),HDL(p),DL(mul));

if ( ndl_check_bound2_direct(bound[index],DL(mul)) ) {

nd_free(g); nd_free(d);

return 0;

}

if ( mod ) {

c1 = invm(HCM(p),mod); c2 = mod-HCM(g);

DMAR(c1,c2,0,mod,c); CM(mul) = c;

} else {

igcd_cofactor(HCQ(g),HCQ(p),&gcd,&cg,&cred);

chsgnq(cg,&CQ(mul));

nd_mul_c_q(d,cred); nd_mul_c_q(g,cred);

}

g = nd_add(mod,g,ndv_mul_nm(mod,mul,p));

sugar = MAX(sugar,SG(p)+TD(DL(mul)));

if ( !mod && hmag && g && ((double)(p_mag((P)HCQ(g))) > hmag) ) {

nd_removecont2(d,g);

hmag = ((double)p_mag((P)HCQ(g)))*nd_scale;

}

} else if ( !full ) {

*rp = g;

return 1;

} else {

m = BDY(g);

if ( NEXT(m) ) {

BDY(g) = NEXT(m); NEXT(m) = 0; LEN(g)--;

} else {

FREEND(g); g = 0;

}

if ( d ) {

NEXT(tail)=m; tail=m; LEN(d)++;

} else {

MKND(n,m,1,d); tail = BDY(d);

}

if ( d ) SG(d) = sugar;

*rp = d;

return 1;

}

/* input : list of NDV, cand : list of NDV */

int ndv_check_candidate(NODE input,int obpe,int oadv,EPOS oepos,NODE cand)

Line 1593 int ndv_check_candidate(NODE input,int obpe,int oadv,E

Line 1503 int ndv_check_candidate(NODE input,int obpe,int oadv,E

ND nf,d;

NDV r;

NODE t,s;

union oNDC dn;

ndv_setup(0,0,cand);

n = length(cand);

Line 1605 again:

Line 1516 again:

else

r = (NDV)BDY(t);

d = ndvtond(0,r);

stat = nd_nf(0,d,nd_ps,0,&nf);

stat = nd_nf(0,d,nd_ps,0,0,&nf);

if ( !stat ) {

nd_reconstruct(0,0,0);

goto again;

} else if ( nf ) return 0;

printf("."); fflush(stdout);

if ( DP_Print ) { printf("."); fflush(stdout); }

}

printf("\n");

if ( DP_Print ) { printf("\n"); }

/* gbcheck : cand is a GB of Id(cand) ? */

if ( !nd_gb(0,1) ) return 0;

if ( !nd_gb(0,0,1) ) return 0;

/* XXX */

return 1;

}

Line 1633 ND nd_remove_head(ND p)

Line 1544 ND nd_remove_head(ND p)

return p;

}

ND nd_separate_head(ND p,ND *head)

{

NM m,m0;

ND r;

m = BDY(p);

if ( !NEXT(m) ) {

*head = p; p = 0;

} else {

m0 = m;

BDY(p) = NEXT(m); LEN(p)--;

NEXT(m0) = 0;

MKND(NV(p),m0,1,r);

*head = r;

}

return p;

}

PGeoBucket create_pbucket()

{

PGeoBucket g;

Line 1756 int head_pbucket(int mod,PGeoBucket g)

Line 1685 int head_pbucket(int mod,PGeoBucket g)

dj = HDL(gj);

sum = HCM(gj);

} else if ( c == 0 ) {

sum = sum+HCM(gi)-mod;

if ( mod == -1 )

if ( sum < 0 ) sum += mod;

sum = _addsf(sum,HCM(gi));

else {

sum = sum+HCM(gi)-mod;

if ( sum < 0 ) sum += mod;

}

g->body[i] = nd_remove_head(gi);

}

Line 1827 ND normalize_pbucket(int mod,PGeoBucket g)

Line 1760 ND normalize_pbucket(int mod,PGeoBucket g)

/* return value = 0 => input is not a GB */

NODE nd_gb(int m,int checkonly)

NODE nd_gb(int m,int ishomo,int checkonly)

{

int i,nh,sugar,stat;

NODE r,g,t;

ND_pairs d;

ND_pairs l;

ND h,nf;

ND h,nf,s,head;

NDV nfv;

Q q;

union oNDC dn;

g = 0; d = 0;

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

Line 1846 NODE nd_gb(int m,int checkonly)

Line 1781 NODE nd_gb(int m,int checkonly)

again:

l = nd_minp(d,&d);

if ( SG(l) != sugar ) {

if ( ishomo ) {

for ( i = nd_psn-1; SG(nd_psh[i]) == sugar; i-- ) {

if ( nd_demand )

nfv = ndv_load(i);

else

nfv = nd_ps[i];

s = ndvtond(m,nfv);

s = nd_separate_head(s,&head);

nd_nf(m,s,nd_ps,1,&dn,&nf);

if ( !m ) { mulq(HCQ(head),dn.z,&q); HCQ(head) = q; }

nf = nd_add(m,head,nf);

ndv_free(nfv);

nd_removecont(m,nf);

nfv = ndtondv(m,nf);

nd_free(nf);

nd_bound[i] = ndv_compute_bound(nfv);

if ( nd_demand ) {

ndv_save(nfv,i);

ndv_free(nfv);

} else

nd_ps[i] = nfv;

}

sugar = SG(l);

fprintf(asir_out,"%d",sugar);

if ( DP_Print ) fprintf(asir_out,"%d",sugar);

}

stat = nd_sp(m,0,l,&h);

if ( !stat ) {

Line 1856 again:

Line 1814 again:

goto again;

}

#if USE_GEOBUCKET

stat = m?nd_nf_pbucket(m,h,nd_ps,!Top,&nf):nd_nf(m,h,nd_ps,!Top,&nf);

stat = m?nd_nf_pbucket(m,h,nd_ps,!Top,&nf):nd_nf(m,h,nd_ps,!Top,0,&nf);

#else

stat = nd_nf(m,h,nd_ps,!Top,&nf);

stat = nd_nf(m,h,nd_ps,!Top,0,&nf);

#endif

if ( !stat ) {

NEXT(l) = d; d = l;

Line 1866 again:

Line 1824 again:

goto again;

} else if ( nf ) {

if ( checkonly ) return 0;

printf("+"); fflush(stdout);

if ( DP_Print ) { printf("+"); fflush(stdout); }

nd_removecont(m,nf);

nfv = ndtondv(m,nf); nd_free(nf);

nh = ndv_newps(nfv,0);

nh = ndv_newps(m,nfv,0);

d = update_pairs(d,g,nh);

g = update_base(g,nh);

FREENDP(l);

} else {

printf("."); fflush(stdout);

if ( DP_Print ) { printf("."); fflush(stdout); }

FREENDP(l);

}

for ( t = g; t; t = NEXT(t) ) BDY(t) = (pointer)nd_ps[(int)BDY(t)];

if ( nd_demand )

for ( t = g; t; t = NEXT(t) )

BDY(t) = (pointer)ndv_load((int)BDY(t));

else

for ( t = g; t; t = NEXT(t) )

BDY(t) = (pointer)nd_ps[(int)BDY(t)];

return g;

}

NODE nd_gb_trace(int m)

NODE nd_gb_trace(int m,int ishomo)

{

int i,nh,sugar,stat;

NODE r,g,t;

ND_pairs d;

ND_pairs l;

ND h,nf,nfq;

ND h,nf,nfq,s,head;

NDV nfv,nfqv;

Q q;

union oNDC dn;

g = 0; d = 0;

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

Line 1901 NODE nd_gb_trace(int m)

Line 1866 NODE nd_gb_trace(int m)

again:

l = nd_minp(d,&d);

if ( SG(l) != sugar ) {

if ( ishomo ) {

for ( i = nd_psn-1; SG(nd_psh[i]) == sugar; i-- ) {

/* for nd_ps */

s = ndvtond(m,nd_ps[i]);

s = nd_separate_head(s,&head);

nd_nf_pbucket(m,s,nd_ps,1,&nf);

nf = nd_add(m,head,nf);

ndv_free(nd_ps[i]);

nd_ps[i] = ndtondv(m,nf);

nd_free(nf);

/* for nd_ps_trace */

if ( nd_demand )

nfv = ndv_load(i);

else

nfv = nd_ps_trace[i];

s = ndvtond(0,nfv);

s = nd_separate_head(s,&head);

nd_nf(0,s,nd_ps_trace,1,&dn,&nf);

mulq(HCQ(head),dn.z,&q); HCQ(head) = q;

nf = nd_add(0,head,nf);

ndv_free(nfv);

nd_removecont(0,nf);

nfv = ndtondv(0,nf);

nd_free(nf);

nd_bound[i] = ndv_compute_bound(nfv);

if ( nd_demand ) {

ndv_save(nfv,i);

ndv_free(nfv);

} else

nd_ps_trace[i] = nfv;

}

sugar = SG(l);

fprintf(asir_out,"%d",sugar);

if ( DP_Print ) fprintf(asir_out,"%d",sugar);

}

stat = nd_sp(m,0,l,&h);

if ( !stat ) {

Line 1913 again:

Line 1911 again:

#if USE_GEOBUCKET

stat = nd_nf_pbucket(m,h,nd_ps,!Top,&nf);

#else

stat = nd_nf(m,h,nd_ps,!Top,&nf);

stat = nd_nf(m,h,nd_ps,!Top,0,&nf);

#endif

if ( !stat ) {

NEXT(l) = d; d = l;

d = nd_reconstruct(m,1,d);

goto again;

} else if ( nf ) {

/* overflow does not occur */

if ( nd_demand ) {

nd_sp(0,1,l,&h);

nfqv = ndv_load(nd_psn);

nd_nf(0,h,nd_ps_trace,!Top,&nfq);

nfq = ndvtond(0,nfqv);

} else

nfq = 0;

if ( !nfq ) {

if ( !nd_sp(0,1,l,&h) || !nd_nf(0,h,nd_ps_trace,!Top,0,&nfq) ) {

NEXT(l) = d; d = l;

d = nd_reconstruct(m,1,d);

goto again;

}

if ( nfq ) {

/* failure; m|HC(nfq) */

/* m|HC(nfq) => failure */

if ( !rem(NM(HCQ(nfq)),m) ) return 0;

printf("+"); fflush(stdout);

if ( DP_Print ) { printf("+"); fflush(stdout); }

nd_removecont(m,nf); nfv = ndtondv(m,nf); nd_free(nf);

nd_removecont(0,nfq); nfqv = ndtondv(0,nfq); nd_free(nfq);

nh = ndv_newps(nfv,nfqv);

nh = ndv_newps(0,nfv,nfqv);

d = update_pairs(d,g,nh);

g = update_base(g,nh);

} else {

printf("*"); fflush(stdout);

if ( DP_Print ) { printf("*"); fflush(stdout); }

}

} else {

printf("."); fflush(stdout);

if ( DP_Print ) { printf("."); fflush(stdout); }

}

FREENDP(l);

}

for ( t = g; t; t = NEXT(t) )

if ( nd_demand )

BDY(t) = (pointer)nd_ps_trace[(int)BDY(t)];

for ( t = g; t; t = NEXT(t) )

BDY(t) = (pointer)ndv_load((int)BDY(t));

else

for ( t = g; t; t = NEXT(t) )

BDY(t) = (pointer)nd_ps_trace[(int)BDY(t)];

return g;

}

Line 1958 int ndv_compare_rev(NDV *p1,NDV *p2)

Line 1969 int ndv_compare_rev(NDV *p1,NDV *p2)

NODE ndv_reduceall(int m,NODE f)

{

int i,j,n,stat;

int i,n,stat;

NDV *w,*ps;

ND nf,g,head;

ND nf,g;

NODE t,a0,a;

struct oBaseSet base;

union oNDC dn;

UINT **bound;

NDV *w;

Q q;

for ( n = 0, t = f; t; t = NEXT(t), n++ );

n = length(f);

ps = (NDV *)ALLOCA(n*sizeof(NDV));

#if 0

bound = (UINT **)ALLOCA(n*sizeof(UINT *));

w = (NDV *)ALLOCA(n*sizeof(NDV));

for ( i = 0, t = f; i < n; i++, t = NEXT(t) ) ps[i] = (NDV)BDY(t);

for ( i = 0, t = f; i < n; i++, t = NEXT(t) ) w[i] = (NDV)BDY(t);

qsort(ps,n,sizeof(NDV),(int (*)(const void *,const void *))ndv_compare);

qsort(w,n,sizeof(NDV),

for ( i = 0; i < n; i++ ) bound[i] = ndv_compute_bound(ps[i]);

(int (*)(const void *,const void *))ndv_compare);

base.ps = (NDV *)ALLOCA((n-1)*sizeof(NDV));

for ( t = f, i = 0; t; i++, t = NEXT(t) ) BDY(t) = (pointer)w[i];

base.bound = (UINT **)ALLOCA((n-1)*sizeof(UINT *));

#endif

base.len = n-1;

ndv_setup(m,0,f);

i = 0;

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

while ( i < n ) {

g = ndvtond(m,nd_ps[i]);

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

g = nd_separate_head(g,&head);

base.ps[j] = ps[j]; base.bound[j] = bound[j];

stat = nd_nf(m,g,nd_ps,1,&dn,&nf);

}

for ( j = i+1; j < n; j++ ) {

base.ps[j-1] = ps[j]; base.bound[j-1] = bound[j];

}

g = ndvtond(m,ps[i]);

stat = nd_nf_direct(m,g,&base,1,&nf);

if ( !stat )

nd_reconstruct_direct(m,ps,n);

nd_reconstruct(m,0,0);

else if ( !nf ) {

else {

printf("."); fflush(stdout);

if ( DP_Print ) { printf("."); fflush(stdout); }

ndv_free(ps[i]);

if ( !m ) { mulq(HCQ(head),dn.z,&q); HCQ(head) = q; }

for ( j = i+1; j < n; j++ ) {

nf = nd_add(m,head,nf);

ps[j-1] = ps[j]; bound[j-1] = bound[j];

ndv_free(nd_ps[i]);

}

n--;

base.len = n-1;

} else {

printf("."); fflush(stdout);

ndv_free(ps[i]);

nd_removecont(m,nf);

ps[i] = ndtondv(m,nf);

nd_ps[i] = ndtondv(m,nf); nd_free(nf);

bound[i] = ndv_compute_bound(ps[i]);

nd_bound[i] = ndv_compute_bound(nd_ps[i]);

nd_free(nf);

i++;

}

printf("\n");

if ( DP_Print ) { printf("\n"); }

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

NEXTNODE(a0,a);

BDY(a) = (pointer)ps[i];

BDY(a) = (pointer)nd_ps[i];

}

NEXT(a) = 0;

return a0;

Line 2237 ND_pairs nd_minp( ND_pairs d, ND_pairs *prest )

Line 2235 ND_pairs nd_minp( ND_pairs d, ND_pairs *prest )

return m;

}

s = SG(m);

for ( ml = 0, l = m; p; p = NEXT(l = p) )

if ( !NoSugar ) {

if ( (SG(p) < s)

for ( ml = 0, l = m; p; p = NEXT(l = p) )

|| ((SG(p) == s) && (DL_COMPARE(LCM(p),LCM(m)) < 0)) ) {

if ( (SG(p) < s)

ml = l; m = p; s = SG(m);

|| ((SG(p) == s) && (DL_COMPARE(LCM(p),LCM(m)) < 0)) ) {

}

ml = l; m = p; s = SG(m);

}

} else {

for ( ml = 0, l = m; p; p = NEXT(l = p) )

if ( DL_COMPARE(LCM(p),LCM(m)) < 0 ) {

ml = l; m = p; s = SG(m);

}

if ( !ml ) *prest = NEXT(m);

else {

NEXT(ml) = NEXT(m);

Line 2253 ND_pairs nd_minp( ND_pairs d, ND_pairs *prest )

Line 2258 ND_pairs nd_minp( ND_pairs d, ND_pairs *prest )

ND_pairs nd_minsugarp( ND_pairs d, ND_pairs *prest )

{

int msugar;

int msugar,i;

ND_pairs t,dm0,dm,dr0,dr;

for ( msugar = SG(d), t = NEXT(d); t; t = NEXT(t) )

if ( SG(t) < msugar ) msugar = SG(t);

dm0 = 0; dr0 = 0;

for ( t = d; t; t = NEXT(t) )

for ( i = 0, t = d; t; t = NEXT(t) )

if ( SG(t) == msugar ) {

if ( i < nd_f4_nsp && SG(t) == msugar ) {

if ( dm0 ) NEXT(dm) = t;

else dm0 = t;

dm = t;

i++;

} else {

if ( dr0 ) NEXT(dr) = t;

else dr0 = t;

Line 2275 ND_pairs nd_minsugarp( ND_pairs d, ND_pairs *prest )

Line 2281 ND_pairs nd_minsugarp( ND_pairs d, ND_pairs *prest )

return dm0;

}

int ndv_newps(NDV a,NDV aq)

int ndv_newps(int m,NDV a,NDV aq)

{

int len;

RHist r;

Line 2299 int ndv_newps(NDV a,NDV aq)

Line 2305 int ndv_newps(NDV a,NDV aq)

nd_bound[nd_psn] = ndv_compute_bound(a);

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

}

if ( nd_demand ) {

if ( aq ) {

ndv_save(nd_ps_trace[nd_psn],nd_psn);

nd_ps_trace[nd_psn] = 0;

} else {

ndv_save(nd_ps[nd_psn],nd_psn);

nd_ps[nd_psn] = 0;

}

return nd_psn++;

}

Line 2308 void ndv_setup(int mod,int trace,NODE f)

Line 2323 void ndv_setup(int mod,int trace,NODE f)

NODE s,s0,f0;

UINT *d;

RHist r;

NDV *w;

NDV a,am;

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

nd_psn = length(f); nd_pslen = 2*nd_psn;

for ( nd_psn = 0, s = f; s; s = NEXT(s) ) if ( BDY(s) ) nd_psn++;

w = (NDV *)ALLOCA(nd_psn*sizeof(NDV));

for ( i = 0, s = f; s; s = NEXT(s) ) if ( BDY(s) ) w[i++] = BDY(s);

qsort(w,nd_psn,sizeof(NDV),

(int (*)(const void *,const void *))ndv_compare);

nd_pslen = 2*nd_psn;

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

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

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

Line 2320 void ndv_setup(int mod,int trace,NODE f)

Line 2341 void ndv_setup(int mod,int trace,NODE f)

if ( !nd_red )

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

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

for ( i = 0; i < REDTAB_LEN; i++ ) nd_red[i] = 0;

nd_free_private_storage();

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

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

if ( trace ) {

a = nd_ps_trace[i] = ndv_dup(0,(NDV)BDY(f));

a = nd_ps_trace[i] = ndv_dup(0,w[i]);

ndv_removecont(0,a);

am = nd_ps[i] = ndv_dup(mod,a);

ndv_mod(mod,am);

ndv_removecont(mod,am);

} else {

a = nd_ps[i] = ndv_dup(mod,(NDV)BDY(f));

a = nd_ps[i] = ndv_dup(mod,w[i]);

if ( mod ) ndv_mod(mod,a);

ndv_removecont(mod,a);

}

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

nd_bound[i] = ndv_compute_bound(a);

nd_psh[i] = r;

if ( nd_demand ) {

if ( trace ) {

ndv_save(nd_ps_trace[i],i);

nd_ps_trace[i] = 0;

} else {

ndv_save(nd_ps[i],i);

nd_ps[i] = 0;

}

Line 2345 void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe

Line 2373 void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe

VL tv,fv,vv,vc;

NODE fd,fd0,r,r0,t,x,s,xx;

int e,max,nvar;

ND b;

NDV b;

int ishomo;

if ( !m && Demand ) nd_demand = 1;

else nd_demand = 0;

ndv_alloc = 0;

get_vars((Obj)f,&fv); pltovl(v,&vv);

nvar = length(vv);

for ( nvar = 0, tv = vv; tv; tv = NEXT(tv), nvar++ );

nd_init_ord(ord);

for ( t = BDY(f), max = 0; t; t = NEXT(t) )

for ( tv = vv; tv; tv = NEXT(tv) ) {

Line 2356 void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe

Line 2389 void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe

max = MAX(e,max);

}

nd_setup_parameters(nvar,max);

ishomo = 1;

for ( fd0 = 0, t = BDY(f); t; t = NEXT(t) ) {

b = (pointer)ptondv(CO,vv,(P)BDY(t));

if ( ishomo )

ishomo = ishomo && ndv_ishomo(b);

if ( m ) ndv_mod(m,b);

if ( b ) { NEXTNODE(fd0,fd); BDY(fd) = (pointer)b; }

}

if ( fd0 ) NEXT(fd) = 0;

ndv_setup(m,0,fd0);

x = f4?nd_f4(m):nd_gb(m,0);

x = f4?nd_f4(m):nd_gb(m,ishomo,0);

nd_demand = 0;

x = ndv_reducebase(x);

x = ndv_reduceall(m,x);

for ( r0 = 0, t = x; t; t = NEXT(t) ) {

Line 2371 void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe

Line 2409 void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe

}

if ( r0 ) NEXT(r) = 0;

MKLIST(*rp,r0);

fprintf(asir_out,"ndv_alloc=%d\n",ndv_alloc);

}

void nd_gr_trace(LIST f,LIST v,int trace,int homo,struct order_spec *ord,LIST *rp)

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

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

NMV a;

P p;

EPOS oepos;

int obpe,oadv,wmax,i,len,cbpe;

int obpe,oadv,wmax,i,len,cbpe,ishomo;

get_vars((Obj)f,&fv); pltovl(v,&vv);

nvar = length(vv);

for ( nvar = 0, tv = vv; tv; tv = NEXT(tv), nvar++ );

nocheck = 0;

mindex = 0;

if ( Demand ) nd_demand = 1;

else nd_demand = 0;

/* setup modulus */

if ( trace < 0 ) {

trace = -trace;

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

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

nd_init_ord(ord);

nd_setup_parameters(nvar,max);

obpe = nd_bpe; oadv = nmv_adv; oepos = nd_epos;

ishomo = 1;

for ( in0 = 0, fd0 = 0, t = BDY(f); t; t = NEXT(t) ) {

c = ptondv(CO,vv,(P)BDY(t));

if ( ishomo )

ishomo = ishomo && ndv_ishomo(c);

if ( c ) {

NEXTNODE(in0,in); BDY(in) = (pointer)c;

NEXTNODE(fd0,fd); BDY(fd) = (pointer)ndv_dup(0,c);

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

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

}

if ( in0 ) NEXT(in) = 0;

if ( fd0 ) NEXT(fd) = 0;

if ( homo ) {

if ( !ishomo && homo ) {

for ( t = in0, wmax = 0; t; t = NEXT(t) ) {

c = (NDV)BDY(t); len = LEN(c);

for ( a = BDY(c), i = 0; i < len; i++, NMV_ADV(a) )

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

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

ndv_homogenize((NDV)BDY(t),obpe,oadv,oepos);

}

while ( 1 ) {

if ( Demand )

nd_demand = 1;

ndv_setup(m,1,fd0);

cand = nd_gb_trace(m);

cand = nd_gb_trace(m,ishomo || homo);

if ( !cand ) {

/* failure */

if ( trace > 1 ) { *rp = 0; return; }

else m = get_lprime(++mindex);

continue;

}

if ( homo ) {

if ( !ishomo && homo ) {

/* dehomogenization */

for ( t = cand; t; t = NEXT(t) ) ndv_dehomogenize((NDV)BDY(t),ord);

nd_init_ord(ord);

nd_setup_parameters(nvar,0);

}

nd_demand = 0;

cand = ndv_reducebase(cand);

cand = ndv_reduceall(0,cand);

cbpe = nd_bpe;

if ( nocheck )

break;

cbpe = nd_bpe;

if ( ndv_check_candidate(in0,obpe,oadv,oepos,cand) )

/* success */

break;

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

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

/* try the next modulus */

m = get_lprime(++mindex);

/* reset the parameters */

if ( homo ) {

if ( !ishomo && homo ) {

nd_init_ord(&ord1);

nd_setup_parameters(nvar+1,wmax);

} else {

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

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

}

/* dp->p */

nd_bpe = cbpe;

nd_setup_parameters(0,0);

nd_setup_parameters(nd_nvar,0);

for ( r = cand; r; r = NEXT(r) ) BDY(r) = (pointer)ndvtop(0,CO,vv,BDY(r));

MKLIST(*rp,cand);

}

Line 2547 void nd_print(ND p)

Line 2595 void nd_print(ND p)

printf("0\n");

else {

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

printf("+%d*",CM(m));

if ( CM(m) & 0x80000000 ) printf("+@_%d*",IFTOF(CM(m)));

else printf("+%d*",CM(m));

ndl_print(DL(m));

}

printf("\n");

Line 2563 void nd_print_q(ND p)

Line 2612 void nd_print_q(ND p)

else {

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

printf("+");

printexpr(CO,CQ(m));

printexpr(CO,(Obj)CQ(m));

printf("*");

ndl_print(DL(m));

}

Line 2588 void nd_removecont(int mod,ND p)

Line 2637 void nd_removecont(int mod,ND p)

struct oVECT v;

N q,r;

if ( mod ) nd_mul_c(mod,p,invm(HCM(p),mod));

if ( mod == -1 ) nd_mul_c(mod,p,_invsf(HCM(p)));

else if ( mod ) nd_mul_c(mod,p,invm(HCM(p),mod));

else {

for ( m = BDY(p), n = 0; m; m = NEXT(m), n++ );

w = (Q *)ALLOCA(n*sizeof(Q));

Line 2634 void ndv_removecont(int mod,NDV p)

Line 2684 void ndv_removecont(int mod,NDV p)

Q dvr,t;

NMV m;

if ( mod )

if ( mod == -1 )

ndv_mul_c(mod,p,_invsf(HCM(p)));

else if ( mod )

ndv_mul_c(mod,p,invm(HCM(p),mod));

else {

len = p->len;

Line 2735 void nd_mul_c(int mod,ND p,int mul)

Line 2787 void nd_mul_c(int mod,ND p,int mul)

int c,c1;

if ( !p ) return;

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

if ( mod == -1 )

c1 = CM(m);

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

DMAR(c1,mul,0,mod,c);

CM(m) = _mulsf(CM(m),mul);

CM(m) = c;

else

}

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

c1 = CM(m); DMAR(c1,mul,0,mod,c); CM(m) = c;

}

void nd_mul_c_q(ND p,Q mul)

Line 2840 int nd_get_exporigin(struct order_spec *ord)

Line 2894 int nd_get_exporigin(struct order_spec *ord)

}

void nd_setup_parameters(int nvar,int max) {

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

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

struct order_pair *op;

/* if max == 0, don't touch nd_bpe */

nd_nvar = nvar;

if ( max > 0 ) {

if ( max ) {

if ( max < 2 ) nd_bpe = 1;

/* XXX */

if ( max < 4 ) nd_bpe = 2;

if ( do_weyl ) nd_bpe = 32;

else if ( max < 2 ) nd_bpe = 1;

else if ( max < 4 ) nd_bpe = 2;

else if ( max < 8 ) nd_bpe = 3;

else if ( max < 16 ) nd_bpe = 4;

else if ( max < 32 ) nd_bpe = 5;

Line 2856 void nd_setup_parameters(int nvar,int max) {

Line 2912 void nd_setup_parameters(int nvar,int max) {

else if ( max < 65536 ) nd_bpe = 16;

else nd_bpe = 32;

}

/* nvar == 0, don't touch nd_nvar */

if ( nvar > 0 ) nd_nvar = nvar;

nd_epw = (sizeof(UINT)*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;

wpd = nd_exporigin+elen;

if ( wpd != nd_wpd ) {

nd_free_private_storage();

nd_wpd = wpd;

}

if ( nd_bpe < 32 ) {

nd_mask0 = (1<<nd_bpe)-1;

} else {

Line 2885 void nd_setup_parameters(int nvar,int max) {

Line 2940 void nd_setup_parameters(int nvar,int max) {

ND_pairs nd_reconstruct(int mod,int trace,ND_pairs d)

{

int i,obpe,oadv,h;

NM prev_nm_free_list;

static NM prev_nm_free_list;

static ND_pairs prev_ndp_free_list;

RHist mr0,mr;

RHist r;

RHist *old_red;

ND_pairs s0,s,t,prev_ndp_free_list;

ND_pairs s0,s,t;

EPOS oepos;

obpe = nd_bpe;

Line 2906 ND_pairs nd_reconstruct(int mod,int trace,ND_pairs d)

Line 2962 ND_pairs nd_reconstruct(int mod,int trace,ND_pairs d)

else if ( obpe < 32 ) nd_bpe = 32;

else error("nd_reconstruct : exponent too large");

nd_setup_parameters(0,0);

nd_setup_parameters(nd_nvar,0);

prev_nm_free_list = _nm_free_list;

prev_ndp_free_list = _ndp_free_list;

_nm_free_list = 0;

Line 2949 ND_pairs nd_reconstruct(int mod,int trace,ND_pairs d)

Line 3005 ND_pairs nd_reconstruct(int mod,int trace,ND_pairs d)

if ( s0 ) NEXT(s) = 0;

prev_nm_free_list = 0;

prev_ndp_free_list = 0;

#if 0

GC_gcollect();

#endif

return s0;

}

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

{

int i,obpe,oadv,h;

UINT **bound;

NM prev_nm_free_list;

RHist mr0,mr;

RHist r;

RHist *old_red;

ND_pairs s0,s,t,prev_ndp_free_list;

EPOS oepos;

obpe = nd_bpe;

oadv = nmv_adv;

oepos = nd_epos;

if ( obpe < 2 ) nd_bpe = 2;

else if ( obpe < 3 ) nd_bpe = 3;

else if ( obpe < 4 ) nd_bpe = 4;

else if ( obpe < 5 ) nd_bpe = 5;

else if ( obpe < 6 ) nd_bpe = 6;

else if ( obpe < 8 ) nd_bpe = 8;

else if ( obpe < 10 ) nd_bpe = 10;

else if ( obpe < 16 ) nd_bpe = 16;

else if ( obpe < 32 ) nd_bpe = 32;

else error("nd_reconstruct_direct : exponent too large");

nd_setup_parameters(0,0);

prev_nm_free_list = _nm_free_list;

prev_ndp_free_list = _ndp_free_list;

_nm_free_list = 0; _ndp_free_list = 0;

for ( i = len-1; i >= 0; i-- ) ndv_realloc(ps[i],obpe,oadv,oepos);

prev_nm_free_list = 0;

prev_ndp_free_list = 0;

GC_gcollect();

}

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

{

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

Line 3047 int nd_sp(int mod,int trace,ND_pairs p,ND *rp)

Line 3070 int nd_sp(int mod,int trace,ND_pairs p,ND *rp)

UINT *lcm;

int td;

if ( trace ) {

if ( !mod && nd_demand ) {

p1 = nd_ps_trace[p->i1]; p2 = nd_ps_trace[p->i2];

p1 = ndv_load(p->i1); p2 = ndv_load(p->i2);

} else {

p1 = nd_ps[p->i1]; p2 = nd_ps[p->i2];

if ( trace ) {

p1 = nd_ps_trace[p->i1]; p2 = nd_ps_trace[p->i2];

} else {

p1 = nd_ps[p->i1]; p2 = nd_ps[p->i2];

}

lcm = LCM(p);

NEWNM(m);

Line 3059 int nd_sp(int mod,int trace,ND_pairs p,ND *rp)

Line 3086 int nd_sp(int mod,int trace,ND_pairs p,ND *rp)

if ( ndl_check_bound2(p->i1,DL(m)) )

return 0;

t1 = ndv_mul_nm(mod,m,p1);

if ( mod ) CM(m) = mod-HCM(p1);

if ( mod == -1 ) CM(m) = _chsgnsf(HCM(p1));

else if ( mod ) CM(m) = mod-HCM(p1);

else chsgnq(HCQ(p1),&CQ(m));

ndl_sub(lcm,HDL(p2),DL(m));

if ( ndl_check_bound2(p->i2,DL(m)) ) {

Line 3079 void ndv_mul_c(int mod,NDV p,int mul)

Line 3107 void ndv_mul_c(int mod,NDV p,int mul)

if ( !p ) return;

len = LEN(p);

for ( m = BDY(p), i = 0; i < len; i++, NMV_ADV(m) ) {

if ( mod == -1 )

c1 = CM(m); DMAR(c1,mul,0,mod,c); CM(m) = c;

for ( m = BDY(p), i = 0; i < len; i++, NMV_ADV(m) )

}

CM(m) = _mulsf(CM(m),mul);

else

for ( m = BDY(p), i = 0; i < len; i++, NMV_ADV(m) ) {

c1 = CM(m); DMAR(c1,mul,0,mod,c); CM(m) = c;

}

void ndv_mul_c_q(NDV p,Q mul)

Line 3271 ND ndv_mul_nm(int mod,NM m0,NDV p)

Line 3303 ND ndv_mul_nm(int mod,NM m0,NDV p)

if ( !p ) return 0;

else if ( do_weyl )

return weyl_ndv_mul_nm(mod,m0,p);

if ( mod == -1 )

error("ndv_mul_nm : not implemented (weyl)");

else

return weyl_ndv_mul_nm(mod,m0,p);

else {

n = NV(p); m = BDY(p);

d = DL(m0);

len = LEN(p);

mr0 = 0;

td = TD(d);

if ( mod ) {

if ( mod == -1 ) {

c = CM(m0);

for ( i = 0; i < len; i++, NMV_ADV(m) ) {

NEXTNM(mr0,mr);

CM(mr) = _mulsf(CM(m),c);

ndl_add(DL(m),d,DL(mr));

}

} else if ( mod ) {

c = CM(m0);

for ( i = 0; i < len; i++, NMV_ADV(m) ) {

NEXTNM(mr0,mr);

c1 = CM(m);

DMAR(c1,c,0,mod,c2);

CM(mr) = c2;

Line 3386 void ndv_mod(int mod,NDV p)

Line 3428 void ndv_mod(int mod,NDV p)

NMV t,d;

int r;

int i,len,dlen;

Obj gfs;

if ( !p ) return;

len = LEN(p);

dlen = 0;

for ( t = d = BDY(p), i = 0; i < len; i++, NMV_ADV(t) ) {

if ( mod == -1 )

r = rem(NM(CQ(t)),mod);

for ( t = d = BDY(p), i = 0; i < len; i++, NMV_ADV(t) ) {

if ( r ) {

simp_ff((Obj)CP(t),&gfs);

if ( SGN(CQ(t)) < 0 )

r = FTOIF(CONT((GFS)gfs));

r = mod-r;

CM(d) = r;

ndl_copy(DL(t),DL(d));

NMV_ADV(d);

dlen++;

}

else

for ( t = d = BDY(p), i = 0; i < len; i++, NMV_ADV(t) ) {

r = rem(NM(CQ(t)),mod);

if ( r ) {

if ( SGN(CQ(t)) < 0 )

r = mod-r;

CM(d) = r;

ndl_copy(DL(t),DL(d));

NMV_ADV(d);

dlen++;

}

LEN(p) = dlen;

}

Line 3475 P ndvtop(int mod,VL vl,VL dvl,NDV p)

Line 3528 P ndvtop(int mod,VL vl,VL dvl,NDV p)

P c;

UINT *d;

P s,r,u,t,w;

GFS gfs;

if ( !p ) return 0;

else {

Line 3482 P ndvtop(int mod,VL vl,VL dvl,NDV p)

Line 3536 P ndvtop(int mod,VL vl,VL dvl,NDV p)

n = NV(p);

m = (NMV)(((char *)BDY(p))+nmv_adv*(len-1));

for ( j = len-1, s = 0; j >= 0; j--, NMV_PREV(m) ) {

if ( mod ) {

if ( mod == -1 ) {

e = IFTOF(CM(m)); MKGFS(e,gfs); c = (P)gfs;

} else if ( mod ) {

STOQ(CM(m),q); c = (P)q;

} else

c = CP(m);

Line 3506 NDV ndtondv(int mod,ND p)

Line 3562 NDV ndtondv(int mod,ND p)

if ( !p ) return 0;

len = LEN(p);

m0 = m = (NMV)(mod?MALLOC_ATOMIC(len*nmv_adv):MALLOC(len*nmv_adv));

if ( mod )

m0 = m = (NMV)GC_malloc_atomic_ignore_off_page(len*nmv_adv);

else

m0 = m = MALLOC(len*nmv_adv);

ndv_alloc += nmv_adv*len;

for ( t = BDY(p), i = 0; t; t = NEXT(t), i++, NMV_ADV(m) ) {

ndl_copy(DL(t),DL(m));

CQ(m) = CQ(t);

Line 3546 void ndv_print(NDV p)

Line 3606 void ndv_print(NDV p)

else {

len = LEN(p);

for ( m = BDY(p), i = 0; i < len; i++, NMV_ADV(m) ) {

printf("+%d*",CM(m));

if ( CM(m) & 0x80000000 ) printf("+@_%d*",IFTOF(CM(m)));

else printf("+%d*",CM(m));

ndl_print(DL(m));

}

printf("\n");

Line 3563 void ndv_print_q(NDV p)

Line 3624 void ndv_print_q(NDV p)

len = LEN(p);

for ( m = BDY(p), i = 0; i < len; i++, NMV_ADV(m) ) {

printf("+");

printexpr(CO,CQ(m));

printexpr(CO,(Obj)CQ(m));

printf("*");

ndl_print(DL(m));

}

Line 3715 void nd_nf_p(P f,LIST g,LIST v,int m,struct order_spec

Line 3776 void nd_nf_p(P f,LIST g,LIST v,int m,struct order_spec

NDV ndv;

VL vv,tv;

int stat,nvar,max,e;

union oNDC dn;

pltovl(v,&vv);

nvar = length(vv);

for ( nvar = 0, tv = vv; tv; tv = NEXT(tv), nvar++ );

/* get the degree bound */

for ( t = BDY(g), max = 0; t; t = NEXT(t) )

Line 3737 void nd_nf_p(P f,LIST g,LIST v,int m,struct order_spec

Line 3799 void nd_nf_p(P f,LIST g,LIST v,int m,struct order_spec

for ( in0 = 0, t = BDY(g); t; t = NEXT(t) ) {

NEXTNODE(in0,in);

BDY(in) = (pointer)ptondv(CO,vv,(P)BDY(t));

if ( m ) ndv_mod(m,(NDV)BDY(in));

}

NEXTNODE(in0,in);

BDY(in) = (pointer)ptondv(CO,vv,f);

if ( m ) ndv_mod(m,(NDV)BDY(in));

NEXT(in) = 0;

ndv_setup(m,0,in0);

Line 3747 void nd_nf_p(P f,LIST g,LIST v,int m,struct order_spec

Line 3811 void nd_nf_p(P f,LIST g,LIST v,int m,struct order_spec

nd_scale=2;

while ( 1 ) {

nd = (pointer)ndvtond(m,nd_ps[nd_psn]);

stat = nd_nf(m,nd,nd_ps,1,&nf);

stat = nd_nf(m,nd,nd_ps,1,0,&nf);

if ( !stat ) {

nd_psn++;

nd_reconstruct(m,0,0);

Line 3774 int nd_to_vect(int mod,UINT *s0,int n,ND d,UINT *r)

Line 3838 int nd_to_vect(int mod,UINT *s0,int n,ND d,UINT *r)

return i;

}

int ndv_to_vect(int mod,UINT *s0,int n,NDV d,UINT *r)

{

NMV m;

UINT *t,*s;

int i,j,len;

for ( i = 0; i < n; i++ ) r[i] = 0;

m = BDY(d);

len = LEN(d);

for ( i = j = 0, s = s0; j < len; j++, NMV_ADV(m)) {

t = DL(m);

for ( ; !ndl_equal(t,s); s += nd_wpd, i++ );

r[i] = CM(m);

}

for ( i = 0; !r[i]; i++ );

return i;

}

int nm_ind_pair_to_vect(int mod,UINT *s0,int n,NM_ind_pair pair,UINT *r)

{

NM m;

Line 3805 IndArray nm_ind_pair_to_vect_compress(int mod,UINT *s0

Line 3887 IndArray nm_ind_pair_to_vect_compress(int mod,UINT *s0

NDV p;

unsigned char *ivc;

unsigned short *ivs;

UINT *v,*ivi;

UINT *v,*ivi,*s0v;

int i,j,len,prev,diff,cdiff;

IndArray r;

Line 3814 IndArray nm_ind_pair_to_vect_compress(int mod,UINT *s0

Line 3896 IndArray nm_ind_pair_to_vect_compress(int mod,UINT *s0

p = nd_ps[pair->index];

len = LEN(p);

t = (UINT *)ALLOCA(nd_wpd*sizeof(UINT));

r = (IndArray)MALLOC(sizeof(struct oIndArray));

v = (unsigned int *)ALLOCA(len*sizeof(unsigned int));

for ( i = j = 0, s = s0, mr = BDY(p); j < len; j++, NMV_ADV(mr) ) {

ndl_add(d,DL(mr),t);

for ( ; !ndl_equal(t,s); s += nd_wpd, i++ );

v[j] = i;

}

r = (IndArray)MALLOC(sizeof(struct oIndArray));

r->head = v[0];

diff = 0;

for ( i = 1; i < len; i++ ) {

Line 3846 IndArray nm_ind_pair_to_vect_compress(int mod,UINT *s0

Line 3928 IndArray nm_ind_pair_to_vect_compress(int mod,UINT *s0

}

void ndv_reduce_vect(int m,UINT *svect,int col,IndArray *imat,NODE rp0)

int ndv_reduce_vect(int m,UINT *svect,int col,IndArray *imat,NM_ind_pair *rp0,int nred)

{

int i,j,k,len,pos,prev;

UINT c,c1,c2,c3,up,lo,dmy;

Line 3857 void ndv_reduce_vect(int m,UINT *svect,int col,IndArra

Line 3939 void ndv_reduce_vect(int m,UINT *svect,int col,IndArra

NDV redv;

NMV mr;

NODE rp;

int maxrs;

for ( rp = rp0, i = 0; rp; i++, rp = NEXT(rp) ) {

maxrs = 0;

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

ivect = imat[i];

k = ivect->head; svect[k] %= m;

if ( c = svect[k] ) {

c = m-c; redv = nd_ps[((NM_ind_pair)BDY(rp))->index];

maxrs = MAX(maxrs,rp0[i]->sugar);

c = m-c; redv = nd_ps[rp0[i]->index];

len = LEN(redv); mr = BDY(redv);

svect[k] = 0; prev = k;

switch ( ivect->width ) {

Line 3901 void ndv_reduce_vect(int m,UINT *svect,int col,IndArra

Line 3986 void ndv_reduce_vect(int m,UINT *svect,int col,IndArra

}

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

if ( svect[i] >= (UINT)m ) svect[i] %= m;

return maxrs;

}

int ndv_reduce_vect_sf(int m,UINT *svect,int col,IndArray *imat,NM_ind_pair *rp0,int nred)

{

int i,j,k,len,pos,prev;

UINT c,c1,c2,c3,up,lo,dmy;

IndArray ivect;

unsigned char *ivc;

unsigned short *ivs;

unsigned int *ivi;

NDV redv;

NMV mr;

NODE rp;

int maxrs;

maxrs = 0;

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

ivect = imat[i];

k = ivect->head; svect[k] %= m;

if ( c = svect[k] ) {

maxrs = MAX(maxrs,rp0[i]->sugar);

c = _chsgnsf(c); redv = nd_ps[rp0[i]->index];

len = LEN(redv); mr = BDY(redv);

svect[k] = 0; prev = k;

switch ( ivect->width ) {

case 1:

ivc = ivect->index.c;

for ( j = 1, NMV_ADV(mr); j < len; j++, NMV_ADV(mr) ) {

pos = prev+ivc[j]; prev = pos;

svect[pos] = _addsf(_mulsf(CM(mr),c),svect[pos]);

}

break;

case 2:

ivs = ivect->index.s;

for ( j = 1, NMV_ADV(mr); j < len; j++, NMV_ADV(mr) ) {

pos = prev+ivs[j]; prev = pos;

svect[pos] = _addsf(_mulsf(CM(mr),c),svect[pos]);

}

break;

case 4:

ivi = ivect->index.i;

for ( j = 1, NMV_ADV(mr); j < len; j++, NMV_ADV(mr) ) {

pos = prev+ivi[j]; prev = pos;

svect[pos] = _addsf(_mulsf(CM(mr),c),svect[pos]);

}

break;

}

return maxrs;

}

NDV vect_to_ndv(UINT *vect,int spcol,int col,int *rhead,UINT *s0vect)

{

int j,k,len;

Line 3914 NDV vect_to_ndv(UINT *vect,int spcol,int col,int *rhea

Line 4050 NDV vect_to_ndv(UINT *vect,int spcol,int col,int *rhea

for ( j = 0, len = 0; j < spcol; j++ ) if ( vect[j] ) len++;

if ( !len ) return 0;

else {

mr0 = (NMV)MALLOC_ATOMIC(nmv_adv*len);

mr0 = (NMV)GC_malloc_atomic_ignore_off_page(nmv_adv*len);

ndv_alloc += nmv_adv*len;

mr = mr0;

p = s0vect;

for ( j = k = 0; j < col; j++, p += nd_wpd )

Line 3928 NDV vect_to_ndv(UINT *vect,int spcol,int col,int *rhea

Line 4065 NDV vect_to_ndv(UINT *vect,int spcol,int col,int *rhea

}

int nd_sp_f4(int m,ND_pairs l,PGeoBucket bucket,NODE *s)

int nd_sp_f4(int m,ND_pairs l,PGeoBucket bucket)

{

ND_pairs t;

NODE sp0,sp;

int stat;

ND spol;

sp0 = 0;

for ( t = l; t; t = NEXT(t) ) {

stat = nd_sp(m,0,t,&spol);

if ( !stat ) return 0;

if ( spol ) {

NEXTNODE(sp0,sp); BDY(sp) = (pointer)nd_dup(spol);

add_pbucket_symbolic(bucket,spol);

}

*s = sp0;

return 1;

}

Line 3952 int nd_symbolic_preproc(PGeoBucket bucket,UINT **s0vec

Line 4086 int nd_symbolic_preproc(PGeoBucket bucket,UINT **s0vec

{

NODE rp0,rp;

NM mul,head,s0,s;

int index,col,i;

int index,col,i,sugar;

RHist h;

UINT *s0v,*p;

NM_ind_pair pair;

Line 3971 int nd_symbolic_preproc(PGeoBucket bucket,UINT **s0vec

Line 4105 int nd_symbolic_preproc(PGeoBucket bucket,UINT **s0vec

NEWNM(mul);

ndl_sub(DL(head),DL(h),DL(mul));

if ( ndl_check_bound2(index,DL(mul)) ) return 0;

MKNM_ind_pair(pair,mul,index);

sugar = TD(DL(mul))+SG(nd_ps[index]);

MKNM_ind_pair(pair,mul,index,sugar);

red = ndv_mul_nm_symbolic(mul,nd_ps[index]);

add_pbucket_symbolic(bucket,nd_remove_head(red));

NEXTNODE(rp0,rp); BDY(rp) = (pointer)pair;

}

col++;

}

NEXT(rp) = 0; NEXT(s) = 0;

if ( rp0 ) NEXT(rp) = 0;

NEXT(s) = 0;

s0v = (UINT *)MALLOC_ATOMIC(col*nd_wpd*sizeof(UINT));

for ( i = 0, p = s0v, s = s0; i < col;

i++, p += nd_wpd, s = NEXT(s) ) ndl_copy(DL(s),p);

Line 3995 NODE nd_f4(int m)

Line 4131 NODE nd_f4(int m)

ND spol,red;

NDV nf,redv;

NM s0,s;

NODE sp0,sp,rp0,rp;

NODE rp0,srp0,nflist;

int nsp,nred,col,rank,len,k,j,a;

UINT c;

UINT **spmat;

Line 4010 NODE nd_f4(int m)

Line 4146 NODE nd_f4(int m)

if ( !m )

error("nd_f4 : not implemented");

ndv_alloc = 0;

g = 0; d = 0;

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

d = update_pairs(d,g,i);

Line 4021 NODE nd_f4(int m)

Line 4157 NODE nd_f4(int m)

l = nd_minsugarp(d,&d);

sugar = SG(l);

bucket = create_pbucket();

stat = nd_sp_f4(m,l,bucket,&sp0);

stat = nd_sp_f4(m,l,bucket);

if ( !stat ) {

for ( t = l; NEXT(t); t = NEXT(t) );

NEXT(t) = d; d = l;

d = nd_reconstruct(m,0,d);

continue;

}

if ( !sp0 ) continue;

col = nd_symbolic_preproc(bucket,&s0vect,&rp0);

if ( !col ) {

for ( t = l; NEXT(t); t = NEXT(t) );

Line 4036 NODE nd_f4(int m)

Line 4171 NODE nd_f4(int m)

d = nd_reconstruct(m,0,d);

continue;

}

get_eg(&eg1); init_eg(&eg_f4); add_eg(&eg_f4,&eg0,&eg1);

if ( DP_Print )

fprintf(asir_out,"sugar=%d,symb=%fsec,",

sugar,eg_f4.exectime+eg_f4.gctime);

if ( 1 )

nflist = nd_f4_red(m,l,s0vect,col,rp0);

else

nflist = nd_f4_red_dist(m,l,s0vect,col,rp0);

/* adding new bases */

for ( r = nflist; r; r = NEXT(r) ) {

nf = (NDV)BDY(r);

ndv_removecont(m,nf);

nh = ndv_newps(m,nf,0);

d = update_pairs(d,g,nh);

g = update_base(g,nh);

}

for ( r = g; r; r = NEXT(r) ) BDY(r) = (pointer)nd_ps[(int)BDY(r)];

fprintf(asir_out,"ndv_alloc=%d\n",ndv_alloc);

return g;

}

nsp = length(sp0); nred = length(rp0); spcol = col-nred;

NODE nd_f4_red(int m,ND_pairs sp0,UINT *s0vect,int col,NODE rp0)

imat = (IndArray *)MALLOC(nred*sizeof(IndArray));

{

rhead = (int *)MALLOC_ATOMIC(col*sizeof(int));

IndArray *imat;

for ( i = 0; i < col; i++ ) rhead[i] = 0;

int nsp,nred,spcol,sprow,a;

int *rhead;

int i,j,k,l,rank;

NODE rp,r0,r;

ND_pairs sp;

ND spol;

int **spmat;

UINT *svect,*v;

int *colstat;

struct oEGT eg0,eg1,eg2,eg_f4,eg_f4_1,eg_f4_2;

NM_ind_pair *rvect;

int maxrs;

int *spsugar;

/* construction of index arrays */

get_eg(&eg0);

for ( rp = rp0, i = 0; rp; i++, rp = NEXT(rp) ) {

for ( sp = sp0, nsp = 0; sp; sp = NEXT(sp), nsp++ );

imat[i] = nm_ind_pair_to_vect_compress(m,s0vect,col,(NM_ind_pair)BDY(rp));

nred = length(rp0); spcol = col-nred;

rhead[imat[i]->head] = 1;

imat = (IndArray *)ALLOCA(nred*sizeof(IndArray));

rhead = (int *)ALLOCA(col*sizeof(int));

for ( i = 0; i < col; i++ ) rhead[i] = 0;

/* construction of index arrays */

rvect = (NM_ind_pair *)ALLOCA(nred*sizeof(NM_ind_pair));

for ( rp = rp0, i = 0; rp; i++, rp = NEXT(rp) ) {

rvect[i] = (NM_ind_pair)BDY(rp);

imat[i] = nm_ind_pair_to_vect_compress(m,s0vect,col,rvect[i]);

rhead[imat[i]->head] = 1;

}

/* elimination (1st step) */

spmat = (int **)ALLOCA(nsp*sizeof(UINT *));

svect = (UINT *)ALLOCA(col*sizeof(UINT));

spsugar = (int *)ALLOCA(nsp*sizeof(UINT));

for ( a = sprow = 0, sp = sp0; a < nsp; a++, sp = NEXT(sp) ) {

nd_sp(m,0,sp,&spol);

if ( !spol ) continue;

nd_to_vect(m,s0vect,col,spol,svect);

if ( m == -1 )

maxrs = ndv_reduce_vect_sf(m,svect,col,imat,rvect,nred);

else

maxrs = ndv_reduce_vect(m,svect,col,imat,rvect,nred);

for ( i = 0; i < col; i++ ) if ( svect[i] ) break;

if ( i < col ) {

spmat[sprow] = v = (UINT *)MALLOC_ATOMIC(spcol*sizeof(UINT));

for ( j = k = 0; j < col; j++ )

if ( !rhead[j] ) v[k++] = svect[j];

spsugar[sprow] = MAX(maxrs,SG(spol));

sprow++;

}

nd_free(spol);

}

get_eg(&eg1); init_eg(&eg_f4_1); add_eg(&eg_f4_1,&eg0,&eg1);

if ( DP_Print ) {

fprintf(asir_out,"elim1=%fsec,",eg_f4_1.exectime+eg_f4_1.gctime);

fflush(asir_out);

}

/* free index arrays */

for ( i = 0; i < nred; i++ ) GC_free(imat[i]->index.c);

/* elimination (1st step) */

/* elimination (2nd step) */

spmat = (UINT **)MALLOC(nsp*sizeof(UINT *));

colstat = (int *)ALLOCA(spcol*sizeof(int));

svect = (UINT *)MALLOC_ATOMIC(col*sizeof(UINT));

if ( m == -1 )

for ( a = sprow = 0, sp = sp0; a < nsp; a++, sp = NEXT(sp) ) {

rank = nd_gauss_elim_sf(spmat,spsugar,sprow,spcol,m,colstat);

nd_to_vect(m,s0vect,col,BDY(sp),svect);

else

ndv_reduce_vect(m,svect,col,imat,rp0);

rank = nd_gauss_elim_mod(spmat,spsugar,sprow,spcol,m,colstat);

for ( i = 0; i < col; i++ ) if ( svect[i] ) break;

r0 = 0;

if ( i < col ) {

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

spmat[sprow] = v = (UINT *)MALLOC_ATOMIC(spcol*sizeof(UINT));

NEXTNODE(r0,r); BDY(r) =

for ( j = k = 0; j < col; j++ )

(pointer)vect_to_ndv(spmat[i],spcol,col,rhead,s0vect);

if ( !rhead[j] ) v[k++] = svect[j];

SG((NDV)BDY(r)) = spsugar[i];

sprow++;

GC_free(spmat[i]);

}

for ( ; i < sprow; i++ ) GC_free(spmat[i]);

get_eg(&eg2); init_eg(&eg_f4_2); add_eg(&eg_f4_2,&eg1,&eg2);

init_eg(&eg_f4); add_eg(&eg_f4,&eg0,&eg2);

if ( DP_Print ) {

fprintf(asir_out,"elim2=%fsec\n",eg_f4_2.exectime+eg_f4_2.gctime);

fprintf(asir_out,"nsp=%d,nred=%d,spmat=(%d,%d),rank=%d ",

nsp,nred,sprow,spcol,rank);

fprintf(asir_out,"%fsec\n",eg_f4.exectime+eg_f4.gctime);

}

return r0;

}

FILE *nd_write,*nd_read;

void nd_send_int(int a) {

write_int(nd_write,&a);

}

void nd_send_intarray(int *p,int len) {

write_intarray(nd_write,p,len);

}

int nd_recv_int() {

int a;

read_int(nd_read,&a);

return a;

}

void nd_recv_intarray(int *p,int len) {

read_intarray(nd_read,p,len);

}

void nd_send_ndv(NDV p) {

int len,i;

NMV m;

if ( !p ) nd_send_int(0);

else {

len = LEN(p);

nd_send_int(len);

m = BDY(p);

for ( i = 0; i < len; i++, NMV_ADV(m) ) {

nd_send_int(CM(m));

nd_send_intarray(DL(m),nd_wpd);

}

void nd_send_nd(ND p) {

int len,i;

NM m;

if ( !p ) nd_send_int(0);

else {

len = LEN(p);

nd_send_int(len);

m = BDY(p);

for ( i = 0; i < len; i++, m = NEXT(m) ) {

nd_send_int(CM(m));

nd_send_intarray(DL(m),nd_wpd);

}

NDV nd_recv_ndv()

{

int len,i;

NMV m,m0;

NDV r;

len = nd_recv_int();

if ( !len ) return 0;

else {

m0 = m = (NMV)GC_malloc_atomic_ignore_off_page(nmv_adv*len);

ndv_alloc += len*nmv_adv;

for ( i = 0; i < len; i++, NMV_ADV(m) ) {

CM(m) = nd_recv_int();

nd_recv_intarray(DL(m),nd_wpd);

}

MKNDV(nd_nvar,m0,len,r);

return r;

}

int ox_exec_f4_red(Q proc)

{

Obj obj;

STRING fname;

NODE arg;

int s;

extern int ox_need_conv,ox_file_io;

MKSTR(fname,"nd_exec_f4_red");

arg = mknode(2,proc,fname);

Pox_cmo_rpc(arg,&obj);

s = get_ox_server_id(QTOS(proc));

nd_write = iofp[s].out;

nd_read = iofp[s].in;

ox_need_conv = ox_file_io = 0;

return s;

}

NODE nd_f4_red_dist(int m,ND_pairs sp0,UINT *s0vect,int col,NODE rp0)

{

int nsp,nred;

int i,rank,s;

NODE rp,r0,r;

ND_pairs sp;

NM_ind_pair pair;

NMV nmv;

NM nm;

NDV nf;

Obj proc,dmy;

ox_launch_main(0,0,&proc);

s = ox_exec_f4_red((Q)proc);

nd_send_int(m);

nd_send_int(nd_nvar);

nd_send_int(nd_bpe);

nd_send_int(nd_wpd);

nd_send_int(nmv_adv);

saveobj(nd_write,dp_current_spec.obj); fflush(nd_write);

nd_send_int(nd_psn);

for ( i = 0; i < nd_psn; i++ ) nd_send_ndv(nd_ps[i]);

for ( sp = sp0, nsp = 0; sp; sp = NEXT(sp), nsp++ );

nd_send_int(nsp);

for ( i = 0, sp = sp0; i < nsp; i++, sp = NEXT(sp) ) {

nd_send_int(sp->i1); nd_send_int(sp->i2);

}

nd_send_int(col); nd_send_intarray(s0vect,col*nd_wpd);

nred = length(rp0); nd_send_int(nred);

for ( i = 0, rp = rp0; i < nred; i++, rp = NEXT(rp) ) {

pair = (NM_ind_pair)BDY(rp);

nd_send_int(pair->index);

nd_send_intarray(pair->mul->dl,nd_wpd);

}

fflush(nd_write);

rank = nd_recv_int();

fprintf(asir_out,"rank=%d\n",rank);

r0 = 0;

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

nf = nd_recv_ndv();

NEXTNODE(r0,r); BDY(r) = (pointer)nf;

}

Pox_shutdown(mknode(1,proc),&dmy);

return r0;

}

/* server side */

void nd_exec_f4_red_dist()

{

int m,i,nsp,col,s0size,nred,spcol,j,k;

NM_ind_pair *rp0;

NDV nf;

UINT *s0vect;

IndArray *imat;

int *rhead;

int **spmat;

UINT *svect,*v;

ND_pairs *sp0;

int *colstat;

int a,sprow,rank;

struct order_spec ord;

Obj ordspec;

ND spol;

int maxrs;

int *spsugar;

nd_read = iofp[0].in;

nd_write = iofp[0].out;

m = nd_recv_int();

nd_nvar = nd_recv_int();

nd_bpe = nd_recv_int();

nd_wpd = nd_recv_int();

nmv_adv = nd_recv_int();

loadobj(nd_read,&ordspec);

create_order_spec(ordspec,&ord);

nd_init_ord(&ord);

nd_setup_parameters(nd_nvar,0);

nd_psn = nd_recv_int();

nd_ps = (NDV *)MALLOC(nd_psn*sizeof(NDV));

nd_bound = (UINT **)MALLOC(nd_psn*sizeof(UINT *));

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

nd_ps[i] = nd_recv_ndv();

nd_bound[i] = ndv_compute_bound(nd_ps[i]);

}

nsp = nd_recv_int();

sp0 = (ND_pairs *)MALLOC(nsp*sizeof(ND_pairs));

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

NEWND_pairs(sp0[i]);

sp0[i]->i1 = nd_recv_int(); sp0[i]->i2 = nd_recv_int();

ndl_lcm(HDL(nd_ps[sp0[i]->i1]),HDL(nd_ps[sp0[i]->i2]),LCM(sp0[i]));

}

col = nd_recv_int();

s0size = col*nd_wpd;

s0vect = (UINT *)MALLOC(s0size*sizeof(UINT));

nd_recv_intarray(s0vect,s0size);

nred = nd_recv_int();

rp0 = (NM_ind_pair *)MALLOC(nred*sizeof(NM_ind_pair));

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

rp0[i] = (NM_ind_pair)MALLOC(sizeof(struct oNM_ind_pair));

rp0[i]->index = nd_recv_int();

rp0[i]->mul = (NM)MALLOC(sizeof(struct oNM)+(nd_wpd-1)*sizeof(UINT));

nd_recv_intarray(rp0[i]->mul->dl,nd_wpd);

}

spcol = col-nred;

imat = (IndArray *)MALLOC(nred*sizeof(IndArray));

rhead = (int *)MALLOC(col*sizeof(int));

for ( i = 0; i < col; i++ ) rhead[i] = 0;

/* construction of index arrays */

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

imat[i] = nm_ind_pair_to_vect_compress(m,s0vect,col,rp0[i]);

rhead[imat[i]->head] = 1;

}

/* elimination (1st step) */

spmat = (int **)MALLOC(nsp*sizeof(UINT *));

svect = (UINT *)MALLOC(col*sizeof(UINT));

spsugar = (int *)ALLOCA(nsp*sizeof(UINT));

for ( a = sprow = 0; a < nsp; a++ ) {

nd_sp(m,0,sp0[a],&spol);

if ( !spol ) continue;

nd_to_vect(m,s0vect,col,spol,svect);

if ( m == -1 )

maxrs = ndv_reduce_vect_sf(m,svect,col,imat,rp0,nred);

else

maxrs = ndv_reduce_vect(m,svect,col,imat,rp0,nred);

for ( i = 0; i < col; i++ ) if ( svect[i] ) break;

if ( i < col ) {

spmat[sprow] = v = (UINT *)MALLOC(spcol*sizeof(UINT));

for ( j = k = 0; j < col; j++ )

if ( !rhead[j] ) v[k++] = svect[j];

spsugar[sprow] = MAX(maxrs,SG(spol));

sprow++;

}

nd_free(spol);

}

/* elimination (2nd step) */

colstat = (int *)ALLOCA(spcol*sizeof(int));

if ( m == -1 )

rank = nd_gauss_elim_sf(spmat,spsugar,sprow,spcol,m,colstat);

else

rank = nd_gauss_elim_mod(spmat,spsugar,sprow,spcol,m,colstat);

nd_send_int(rank);

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

nf = vect_to_ndv(spmat[i],spcol,col,rhead,s0vect);

nd_send_ndv(nf);

}

fflush(nd_write);

}

int nd_gauss_elim_mod(int **mat0,int *sugar,int row,int col,int md,int *colstat)

{

int i,j,k,l,inv,a,rank,s;

unsigned int *t,*pivot,*pk;

unsigned int **mat;

mat = (unsigned int **)mat0;

for ( rank = 0, j = 0; j < col; j++ ) {

for ( i = rank; i < row; i++ )

mat[i][j] %= md;

for ( i = rank; i < row; i++ )

if ( mat[i][j] )

break;

if ( i == row ) {

colstat[j] = 0;

continue;

} else

colstat[j] = 1;

if ( i != rank ) {

t = mat[i]; mat[i] = mat[rank]; mat[rank] = t;

s = sugar[i]; sugar[i] = sugar[rank]; sugar[rank] = s;

}

pivot = mat[rank];

s = sugar[rank];

inv = invm(pivot[j],md);

for ( k = j, pk = pivot+k; k < col; k++, pk++ )

if ( *pk ) {

if ( *pk >= (unsigned int)md )

*pk %= md;

DMAR(*pk,inv,0,md,*pk)

}

for ( i = rank+1; i < row; i++ ) {

t = mat[i];

if ( a = t[j] ) {

sugar[i] = MAX(sugar[i],s);

red_by_vect(md,t+j,pivot+j,md-a,col-j);

}

/* free index arrays */

rank++;

for ( i = 0; i < nred; i++ ) GC_free(imat[i]->index.c);

}

for ( j = col-1, l = rank-1; j >= 0; j-- )

if ( colstat[j] ) {

pivot = mat[l];

s = sugar[l];

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

t = mat[i];

t[j] %= md;

if ( a = t[j] ) {

sugar[i] = MAX(sugar[i],s);

red_by_vect(md,t+j,pivot+j,md-a,col-j);

}

l--;

}

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

if ( colstat[j] ) {

t = mat[l];

for ( k = j; k < col; k++ )

if ( t[k] >= (unsigned int)md )

t[k] %= md;

l++;

}

return rank;

}

/* elimination (2nd step) */

int nd_gauss_elim_sf(int **mat0,int *sugar,int row,int col,int md,int *colstat)

colstat = (int *)ALLOCA(spcol*sizeof(int));

{

rank = generic_gauss_elim_mod(spmat,sprow,spcol,m,colstat);

int i,j,k,l,inv,a,rank,s;

unsigned int *t,*pivot,*pk;

unsigned int **mat;

get_eg(&eg1); init_eg(&eg_f4); add_eg(&eg_f4,&eg0,&eg1);

mat = (unsigned int **)mat0;

fprintf(asir_out,"sugar=%d,nsp=%d,nred=%d,spmat=(%d,%d),rank=%d ",

for ( rank = 0, j = 0; j < col; j++ ) {

sugar,nsp,nred,sprow,spcol,rank);

for ( i = rank; i < row; i++ )

fprintf(asir_out,"%fsec\n",eg_f4.exectime+eg_f4.gctime);

if ( mat[i][j] )

break;

if ( i == row ) {

colstat[j] = 0;

continue;

} else

colstat[j] = 1;

if ( i != rank ) {

t = mat[i]; mat[i] = mat[rank]; mat[rank] = t;

s = sugar[i]; sugar[i] = sugar[rank]; sugar[rank] = s;

}

pivot = mat[rank];

s = sugar[rank];

inv = _invsf(pivot[j]);

for ( k = j, pk = pivot+k; k < col; k++, pk++ )

if ( *pk )

*pk = _mulsf(*pk,inv);

for ( i = rank+1; i < row; i++ ) {

t = mat[i];

if ( a = t[j] ) {

sugar[i] = MAX(sugar[i],s);

red_by_vect_sf(md,t+j,pivot+j,_chsgnsf(a),col-j);

}

rank++;

}

for ( j = col-1, l = rank-1; j >= 0; j-- )

if ( colstat[j] ) {

pivot = mat[l];

s = sugar[l];

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

t = mat[i];

if ( a = t[j] ) {

sugar[i] = MAX(sugar[i],s);

red_by_vect_sf(md,t+j,pivot+j,_chsgnsf(a),col-j);

}

l--;

}

return rank;

}

/* adding new bases */

int ndv_ishomo(NDV p)

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

{

nf = vect_to_ndv(spmat[i],spcol,col,rhead,s0vect);

NMV m;

SG(nf) = sugar;

int len,h;

ndv_removecont(m,nf);

nh = ndv_newps(nf,0);

if ( !p ) return 1;

d = update_pairs(d,g,nh);

len = LEN(p);

g = update_base(g,nh);

m = BDY(p);

GC_free(spmat[i]);

h = TD(DL(m));

NMV_ADV(m);

for ( len--; len; len--, NMV_ADV(m) )

if ( TD(DL(m)) != h ) return 0;

return 1;

}

void ndv_save(NDV p,int index)

{

FILE *s;

char name[BUFSIZ];

short id;

int nv,sugar,len,n,i,td,e,j;

NMV m;

unsigned int *dl;

sprintf(name,"%s/%d",Demand,index);

s = fopen(name,"w");

savevl(s,0);

if ( !p ) {

saveobj(s,0);

return;

}

id = O_DP;

nv = NV(p);

sugar = SG(p);

len = LEN(p);

write_short(s,&id); write_int(s,&nv); write_int(s,&sugar);

write_int(s,&len);

for ( m = BDY(p), i = 0; i < len; i++, NMV_ADV(m) ) {

saveobj(s,(Obj)CQ(m));

dl = DL(m);

td = TD(dl);

write_int(s,&td);

for ( j = 0; j < nv; j++ ) {

e = GET_EXP(dl,j);

write_int(s,&e);

}

for ( ; i < sprow; i++ ) GC_free(spmat[i]);

}

for ( r = g; r; r = NEXT(r) ) BDY(r) = (pointer)nd_ps[(int)BDY(r)];

fclose(s);

return g;

}

NDV ndv_load(int index)

{

FILE *s;

char name[BUFSIZ];

short id;

int nv,sugar,len,n,i,td,e,j;

NDV d;

NMV m0,m;

unsigned int *dl;

Obj obj;

sprintf(name,"%s/%d",Demand,index);

s = fopen(name,"r");

if ( !s ) return 0;

skipvl(s);

read_short(s,&id);

if ( !id ) return 0;

read_int(s,&nv);

read_int(s,&sugar);

read_int(s,&len);

m0 = m = MALLOC(len*nmv_adv);

for ( i = 0; i < len; i++, NMV_ADV(m) ) {

loadobj(s,&obj); CQ(m) = (Q)obj;

dl = DL(m);

ndl_zero(dl);

read_int(s,&td); TD(dl) = td;

for ( j = 0; j < nv; j++ ) {

read_int(s,&e);

PUT_EXP(dl,j,e);

}

if ( nd_blockmask ) ndl_weight_mask(dl);

}

fclose(s);

MKNDV(nv,m0,len,d);

SG(d) = sugar;

return d;

}

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