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.75 and 1.90

version 1.75, 2003/09/19 10:09:42

version 1.90, 2004/03/13 06:49:15

Line 1

/* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.74 2003/09/19 02:33:12 noro Exp $ */

/* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.89 2004/02/03 23:31:57 noro Exp $ */

#include "ca.h"

#include "parse.h"

#include "ox.h"

#include "base.h"

#include "inline.h"

#include <time.h>

Line 100 typedef struct oBaseSet {

Line 101 typedef struct oBaseSet {

typedef struct oNM_ind_pair

{

NM mul;

int index;

int index,sugar;

} *NM_ind_pair;

typedef struct oIndArray

Line 117 typedef struct oIndArray

Line 118 typedef struct oIndArray

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

static int ndv_alloc;

#if 1

static int nd_f4_nsp=0x7fffffff;

#else

static int nd_f4_nsp=50;

#endif

static double nd_scale=2;

static UINT **nd_bound;

static struct order_spec *nd_ord;

Line 141 static int nd_psn,nd_pslen;

Line 146 static int nd_psn,nd_pslen;

static RHist *nd_red;

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 struct order_spec *dp_current_spec;

extern char *Demand;

extern VL CO;

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

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

extern int *current_weyl_weight_vector;

/* fundamental macros */

Line 172 extern int *current_weyl_weight_vector;

Line 178 extern int *current_weyl_weight_vector;

#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))

#define ROUND_FOR_ALIGN(s) ((((s)+sizeof(void *)-1)/sizeof(void *))*sizeof(void *))

/* macros for term comparison */

#define TD_DL_COMPARE(d1,d2)\

(TD(d1)>TD(d2)?1:(TD(d1)<TD(d2)?-1:ndl_lex_compare(d1,d2)))

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

Line 221 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 261 ND_pairs crit_B( ND_pairs d, int s );

Line 269 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 357 void ndv_removecont(int mod,NDV p);

Line 365 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 368 int nm_ind_pair_to_vect(int m,UINT *s0,int n,NM_ind_pa

Line 378 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()

{

_nm_free_list = 0;

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

Line 790 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 1322 int nd_nf(int mod,ND g,NDV *ps,int full,NDC dn,ND *rp)

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

nd_free(g); nd_free(d);

return 0;

}

p = ps[index];

if ( nd_demand )

p = ndv_load(index);

else

p = ps[index];

if ( mod == -1 )

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

else if ( mod ) {

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

Line 1412 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 1396 int nd_nf_pbucket(int mod,ND g,NDV *ps,int full,ND *rp

Line 1429 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 1403 int nd_nf_pbucket(int mod,ND g,NDV *ps,int full,ND *rp

Line 1437 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 1495 again:

Line 1531 again:

}

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 1730 ND normalize_pbucket(int mod,PGeoBucket g)

Line 1766 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,num,den;

union oNDC dn;

g = 0; d = 0;

Line 1750 NODE nd_gb(int m,int checkonly)

Line 1787 NODE nd_gb(int m,int checkonly)

again:

l = nd_minp(d,&d);

if ( SG(l) != sugar ) {

if ( ishomo ) {

for ( i = nd_psn-1; i >= 0 && 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 ) {

NTOQ(NM(dn.z),SGN(dn.z),num);

mulq(HCQ(head),num,&q); HCQ(head) = q;

if ( DN(dn.z) ) {

NTOQ(DN(dn.z),1,den);

nd_mul_c_q(nf,den);

}

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);

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

}

Line 1773 again:

Line 1840 again:

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);

Line 1782 again:

Line 1849 again:

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,den,num;

union oNDC dn;

g = 0; d = 0;

Line 1806 NODE nd_gb_trace(int m)

Line 1879 NODE nd_gb_trace(int m)

again:

l = nd_minp(d,&d);

if ( SG(l) != sugar ) {

if ( ishomo ) {

for ( i = nd_psn-1; i >= 0 && 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);

NTOQ(NM(dn.z),SGN(dn.z),num);

mulq(HCQ(head),num,&q); HCQ(head) = q;

if ( DN(dn.z) ) {

NTOQ(DN(dn.z),1,den);

nd_mul_c_q(nf,den);

}

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);

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

}

Line 1825 again:

Line 1936 again:

d = nd_reconstruct(m,1,d);

goto again;

} else if ( nf ) {

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

if ( nd_demand ) {

NEXT(l) = d; d = l;

nfqv = ndv_load(nd_psn);

d = nd_reconstruct(m,1,d);

nfq = ndvtond(0,nfqv);

goto again;

} 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 ) {

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

Line 1837 again:

Line 1955 again:

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 {

Line 1848 again:

Line 1966 again:

}

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 1870 NODE ndv_reduceall(int m,NODE f)

Line 1992 NODE ndv_reduceall(int m,NODE f)

NODE t,a0,a;

union oNDC dn;

NDV *w;

Q q;

Q q,num,den;

n = length(f);

#if 0

Line 1889 NODE ndv_reduceall(int m,NODE f)

Line 2011 NODE ndv_reduceall(int m,NODE f)

nd_reconstruct(m,0,0);

else {

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

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

if ( !m ) {

NTOQ(NM(dn.z),SGN(dn.z),num);

mulq(HCQ(head),num,&q); HCQ(head) = q;

if ( DN(dn.z) ) {

NTOQ(DN(dn.z),1,den);

nd_mul_c_q(nf,den);

}

nf = nd_add(m,head,nf);

ndv_free(nd_ps[i]);

nd_removecont(m,nf);

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

Line 2260 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 2170 ND_pairs nd_minsugarp( ND_pairs d, ND_pairs *prest )

Line 2306 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 2194 int ndv_newps(NDV a,NDV aq)

Line 2330 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 2236 void ndv_setup(int mod,int trace,NODE f)

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

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 2245 void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe

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

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

int e,max,nvar;

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);

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

switch ( ord->id ) {

case 1:

if ( ord->nv != nvar )

error("nd_{gr,f4} : invalid order specification");

break;

default:

break;

}

nd_init_ord(ord);

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

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

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

Line 2422 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 2277 void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe

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

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

{

struct order_spec ord1;

struct order_spec *ord1;

VL tv,fv,vv,vc;

NODE fd,fd0,in0,in,r,r0,t,s,cand;

int m,nocheck,nvar,mindex,e,max;

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

Line 2455 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);

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

switch ( ord->id ) {

case 1:

if ( ord->nv != nvar )

error("nd_gr_trace : invalid order specification");

break;

default:

break;

}

nocheck = 0;

mindex = 0;

if ( Demand ) nd_demand = 1;

else nd_demand = 0;

/* setup modulus */

if ( trace < 0 ) {

trace = -trace;

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

Line 2487 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 2315 void nd_gr_trace(LIST f,LIST v,int trace,int homo,stru

Line 2499 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) )

wmax = MAX(TD(DL(a)),wmax);

}

homogenize_order(ord,nvar,&ord1);

nd_init_ord(&ord1);

nd_init_ord(ord1);

nd_setup_parameters(nvar+1,wmax);

for ( t = fd0; t; t = NEXT(t) )

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 2357 void nd_gr_trace(LIST f,LIST v,int trace,int homo,stru

Line 2544 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_init_ord(ord1);

nd_setup_parameters(nvar+1,wmax);

} else {

nd_init_ord(ord);

Line 2589 void ndv_dehomogenize(NDV p,struct order_spec *ord)

Line 2776 void ndv_dehomogenize(NDV p,struct order_spec *ord)

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

ndl_dehomogenize(DL(m));

if ( newwpd != nd_wpd ) {

newadv = sizeof(struct oNMV)+(newwpd-1)*sizeof(UINT);

newadv = ROUND_FOR_ALIGN(sizeof(struct oNMV)+(newwpd-1)*sizeof(UINT));

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

CQ(r) = CQ(m);

for ( j = 0; j < newexporigin; j++ ) DL(r)[j] = DL(m)[j];

Line 2748 int nd_get_exporigin(struct order_spec *ord)

Line 2935 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;

int bpe;

if ( !max ) bpe = nd_bpe;

else if ( max < 2 ) bpe = 1;

else if ( max < 4 ) bpe = 2;

else if ( max < 8 ) bpe = 3;

else if ( max < 16 ) bpe = 4;

else if ( max < 32 ) bpe = 5;

else if ( max < 64 ) bpe = 6;

else if ( max < 256 ) bpe = 8;

else if ( max < 1024 ) bpe = 10;

else if ( max < 65536 ) bpe = 16;

else bpe = 32;

if ( bpe != nd_bpe || nvar != nd_nvar )

nd_free_private_storage();

nd_bpe = bpe;

nd_nvar = nvar;

if ( max ) {

/* XXX */

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;

else if ( max < 64 ) nd_bpe = 6;

else if ( max < 256 ) nd_bpe = 8;

else if ( max < 1024 ) nd_bpe = 10;

else if ( max < 65536 ) nd_bpe = 16;

else nd_bpe = 32;

}

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 2784 void nd_setup_parameters(int nvar,int max) {

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

nd_mask[nd_epw-i-1] = (nd_mask0<<(i*nd_bpe));

nd_mask1 |= (1<<(nd_bpe-1))<<(i*nd_bpe);

}

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

nmv_adv = ROUND_FOR_ALIGN(sizeof(struct oNMV)+(nd_wpd-1)*sizeof(UINT));

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

nd_epos = nd_create_epos(nd_ord);

nd_blockmask = nd_create_blockmask(nd_ord);

}

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

Line 3110 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 3736 IndArray nm_ind_pair_to_vect_compress(int mod,UINT *s0

Line 3927 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 3745 IndArray nm_ind_pair_to_vect_compress(int mod,UINT *s0

Line 3936 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 3777 IndArray nm_ind_pair_to_vect_compress(int mod,UINT *s0

Line 3968 IndArray nm_ind_pair_to_vect_compress(int mod,UINT *s0

}

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

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 3788 void ndv_reduce_vect(int m,UINT *svect,int col,IndArra

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

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 = m-c; redv = nd_ps[rp0[i]->index];

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

svect[k] = 0; prev = k;

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

Line 4026 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;

}

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

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;

Line 3845 void ndv_reduce_vect_sf(int m,UINT *svect,int col,IndA

Line 4040 void ndv_reduce_vect_sf(int m,UINT *svect,int col,IndA

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;

Line 3878 void ndv_reduce_vect_sf(int m,UINT *svect,int col,IndA

Line 4076 void ndv_reduce_vect_sf(int m,UINT *svect,int col,IndA

}

return maxrs;

}

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

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

Line 4126 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 3946 int nd_symbolic_preproc(PGeoBucket bucket,UINT **s0vec

Line 4145 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;

Line 3971 NODE nd_f4(int m)

Line 4171 NODE nd_f4(int m)

ND spol,red;

NDV nf,redv;

NM s0,s;

NODE rp0,sp0,srp0,nflist;

NODE rp0,srp0,nflist;

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

UINT c;

UINT **spmat;

Line 4004 NODE nd_f4(int m)

Line 4204 NODE nd_f4(int m)

d = nd_reconstruct(m,0,d);

continue;

}

if ( !sp0 ) continue;

if ( bucket->m < 0 ) continue;

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

if ( !col ) {

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

Line 4023 NODE nd_f4(int m)

Line 4223 NODE nd_f4(int m)

/* adding new bases */

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

nf = (NDV)BDY(r);

SG(nf) = sugar;

ndv_removecont(m,nf);

nh = ndv_newps(nf,0);

nh = ndv_newps(m,nf,0);

d = update_pairs(d,g,nh);

g = update_base(g,nh);

}

Line 4047 NODE nd_f4_red(int m,ND_pairs sp0,UINT *s0vect,int col

Line 4246 NODE nd_f4_red(int m,ND_pairs sp0,UINT *s0vect,int col

int **spmat;

UINT *svect,*v;

int *colstat;

struct oEGT eg0,eg1,eg_f4;

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

NM_ind_pair *rvect;

int maxrs;

int *spsugar;

get_eg(&eg0);

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

Line 4068 NODE nd_f4_red(int m,ND_pairs sp0,UINT *s0vect,int col

Line 4269 NODE nd_f4_red(int m,ND_pairs sp0,UINT *s0vect,int col

/* 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);

nd_free(spol);

if ( m == -1 )

if ( m == -1 ) ndv_reduce_vect_sf(m,svect,col,imat,rvect,nred);

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

else ndv_reduce_vect(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 (2nd step) */

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

if ( m == -1 )

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

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

else

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

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

r0 = 0;

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

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

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

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

GC_free(spmat[i]);

}

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

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

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);

Line 4220 NODE nd_f4_red_dist(int m,ND_pairs sp0,UINT *s0vect,in

Line 4433 NODE nd_f4_red_dist(int m,ND_pairs sp0,UINT *s0vect,in

nd_send_int(nd_wpd);

nd_send_int(nmv_adv);

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

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]);

Line 4266 void nd_exec_f4_red_dist()

Line 4479 void nd_exec_f4_red_dist()

ND_pairs *sp0;

int *colstat;

int a,sprow,rank;

struct order_spec ord;

struct order_spec *ord;

Obj ordspec;

ND spol;

int maxrs;

int *spsugar;

nd_read = iofp[0].in;

nd_write = iofp[0].out;

Line 4279 void nd_exec_f4_red_dist()

Line 4494 void nd_exec_f4_red_dist()

nmv_adv = nd_recv_int();

loadobj(nd_read,&ordspec);

create_order_spec(ordspec,&ord);

create_order_spec(0,ordspec,&ord);

nd_init_ord(&ord);

nd_init_ord(ord);

nd_setup_parameters(nd_nvar,0);

nd_psn = nd_recv_int();

Line 4327 void nd_exec_f4_red_dist()

Line 4542 void nd_exec_f4_red_dist()

/* 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);

nd_free(spol);

if ( m == -1 )

if ( m == -1 ) ndv_reduce_vect_sf(m,svect,col,imat,rp0,nred);

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

else ndv_reduce_vect(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 = generic_gauss_elim_sf(spmat,sprow,spcol,m,colstat);

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

else

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

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);

}

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];

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;

}

int nd_gauss_elim_sf(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++ )

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;

}

int ndv_ishomo(NDV p)

{

NMV m;

int len,h;

if ( !p ) return 1;

len = LEN(p);

m = BDY(p);

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);

}

fclose(s);

}

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>