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

version 1.69, 2003/09/15 09:49:44

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

Line 1

/* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.68 2003/09/12 15:07:11 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 98 typedef struct oBaseSet {

Line 100 typedef struct oBaseSet {

typedef struct oNM_ind_pair

{

NM mul;

int index;

int index,sugar;

} *NM_ind_pair;

typedef struct oIndArray

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

Line 141 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 209 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 224 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 255 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 331 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 348 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 359 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 767 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 1141 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 1228 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,NDC dn,ND *rp)

{

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

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

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 {

Line 1322 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 1337 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 1344 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 1353 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 1430 again:

Line 1521 again:

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 1594 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 1665 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;

Line 1685 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 1705 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;

Line 1741 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 1760 again:

Line 1918 again:

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

Line 1992 NODE ndv_reduceall(int m,NODE f)

if ( !stat )

nd_reconstruct(m,0,0);

else {

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

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

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

nf = nd_add(m,head,nf);

ndv_free(nd_ps[i]);

Line 1831 NODE ndv_reduceall(int m,NODE f)

Line 2002 NODE ndv_reduceall(int m,NODE f)

i++;

}

printf("\n");

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

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

NEXTNODE(a0,a);

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

Line 2064 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 2103 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 2127 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 2154 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++ ) {

if ( trace ) {

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

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

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

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

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 2189 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 2205 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 2217 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 2238 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 2247 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 2260 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 2289 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 2300 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 2381 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 2397 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 2422 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 2468 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 2569 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 2674 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 2690 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 2719 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 2740 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 2783 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;

}

Line 2846 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 2858 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 2878 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 3070 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 3185 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 3274 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 3281 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 3305 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 3345 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 3362 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 3517 void nd_nf_p(P f,LIST g,LIST v,int m,struct order_spec

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

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 3576 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 3607 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 3616 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 3648 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 3659 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 3703 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 3716 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 3730 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 3754 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 3773 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 3789 int nd_symbolic_preproc(PGeoBucket bucket,UINT **s0vec

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

return col;

}

#if 0

NODE nd_f4(int m)

{

int i,nh,stat,index;

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

UINT *s0vect,*svect,*p,*v;

int *colstat;

IndArray *imat;

Line 3809 NODE nd_f4(int m)

Line 4143 NODE nd_f4(int m)

int sugar;

PGeoBucket bucket;

struct oEGT eg0,eg1,eg_f4;

static UINT **spmat;

static UINT *spb;

static int spblen;

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

g = update_base(g,i);

}

if ( !spmat ) {

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

spblen = 10000;

spb = (UINT *)MALLOC_ATOMIC(nd_f4_nsp*spblen*sizeof(UINT));

}

while ( d ) {

get_eg(&eg0);

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

/* elimination (1st step) */

/* construction of index arrays */

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

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

if ( spcol > spblen ) {

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

spblen = spcol;

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

spb = REALLOC(spb,spblen*nd_f4_nsp*sizeof(UINT));

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

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

/* elimination (2nd step) */

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

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

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

if ( m == -1 )

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

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

if ( i < col ) {

else

spmat[sprow] = p;

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

v = spmat[sprow];

r0 = 0;

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

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

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

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

sprow++;

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

p += k;

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

}

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

}

/* free index arrays */

}

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

}

/* elimination (2nd step) */

void nd_send_nd(ND p) {

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

int len,i;

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

NM m;

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

if ( !p ) nd_send_int(0);

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

else {

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

len = LEN(p);

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

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

}

/* adding new bases */

NDV nd_recv_ndv()

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

{

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

int len,i;

SG(nf) = sugar;

NMV m,m0;

ndv_removecont(m,nf);

NDV r;

nh = ndv_newps(nf,0);

d = update_pairs(d,g,nh);

len = nd_recv_int();

g = update_base(g,nh);

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;

}

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

return g;

}

#else

NODE nd_f4(int m)

int ox_exec_f4_red(Q proc)

{

int i,nh,stat,index;

Obj obj;

NODE r,g;

STRING fname;

ND_pairs d,l,t;

NODE arg;

ND spol,red;

int s;

NDV nf,redv;

extern int ox_need_conv,ox_file_io;

NM s0,s;

NODE sp0,sp,rp0,rp;

MKSTR(fname,"nd_exec_f4_red");

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

arg = mknode(2,proc,fname);

UINT c;

Pox_cmo_rpc(arg,&obj);

UINT **spmat;

s = get_ox_server_id(QTOS(proc));

UINT *s0vect,*svect,*p,*v;

nd_write = iofp[s].out;

int *colstat;

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 spcol,sprow;

int **spmat;

int sugar;

UINT *svect,*v;

PGeoBucket bucket;

ND_pairs *sp0;

struct oEGT eg0,eg1,eg_f4;

int *colstat;

int a,sprow,rank;

struct order_spec ord;

Obj ordspec;

ND spol;

int maxrs;

int *spsugar;

if ( !m )

nd_read = iofp[0].in;

error("nd_f4 : not implemented");

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

g = 0; d = 0;

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

d = update_pairs(d,g,i);

nd_ps[i] = nd_recv_ndv();

g = update_base(g,i);

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

}

while ( d ) {

get_eg(&eg0);

nsp = nd_recv_int();

l = nd_minsugarp(d,&d);

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

sugar = SG(l);

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

bucket = create_pbucket();

NEWND_pairs(sp0[i]);

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

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

if ( !stat ) {

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

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

}

NEXT(t) = d; d = l;

d = nd_reconstruct(m,0,d);

col = nd_recv_int();

continue;

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

}

if ( !sp0 ) continue;

nd_free(spol);

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

}

if ( !col ) {

/* elimination (2nd step) */

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

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

NEXT(t) = d; d = l;

if ( m == -1 )

d = nd_reconstruct(m,0,d);

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

}

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;

}

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

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

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

{

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

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

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

unsigned int *t,*pivot,*pk;

unsigned int **mat;

/* construction of index arrays */

mat = (unsigned int **)mat0;

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

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

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

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

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

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

/* elimination (1st step) */

s = sugar[rank];

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

inv = _invsf(pivot[j]);

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

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

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

if ( *pk )

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

*pk = _mulsf(*pk,inv);

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

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

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

t = mat[i];

if ( i < col ) {

if ( a = t[j] ) {

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

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

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

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

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

sprow++;

}

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

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;

}

/* elimination (2nd step) */

int ndv_ishomo(NDV p)

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

{

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

NMV m;

int len,h;

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

if ( !p ) return 1;

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

len = LEN(p);

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

m = BDY(p);

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

h = TD(DL(m));

NMV_ADV(m);

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

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

return 1;

}

/* adding new bases */

void ndv_save(NDV p,int index)

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

{

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

FILE *s;

SG(nf) = sugar;

char name[BUFSIZ];

ndv_removecont(m,nf);

short id;

nh = ndv_newps(nf,0);

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

d = update_pairs(d,g,nh);

NMV m;

g = update_base(g,nh);

unsigned int *dl;

GC_free(spmat[i]);

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;

}

#endif

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>