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.157 and 1.172

version 1.157, 2009/01/04 05:44:51

version 1.172, 2009/02/15 03:07:41

Line 1

/* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.156 2008/05/23 01:24:21 noro Exp $ */

/* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.171 2009/02/11 06:30:21 noro Exp $ */

#include "nd.h"

Line 46 static int nd_worb_len;

static int nd_found,nd_create,nd_notfirst;

static int nmv_adv;

static int nd_demand;

static int nd_module,nd_istop,nd_mpos;

static int nd_module,nd_ispot,nd_mpos;

static NODE nd_tracelist;

static NODE nd_alltracelist;

static int nd_gentrace,nd_gensyz;

NumberField get_numberfield();

UINT *nd_det_compute_bound(NDV **dm,int n,int j);

Line 57 NDV plain_vect_to_ndv_q(Q *mat,int col,UINT *s0vect);

Line 60 NDV plain_vect_to_ndv_q(Q *mat,int col,UINT *s0vect);

LIST ndvtopl(int mod,VL vl,VL dvl,NDV p,int rank);

NDV pltondv(VL vl,VL dvl,LIST p);

void pltozpl(LIST l,Q *cont,LIST *pp);

void ndl_lcm_nocheck(UINT *d1,unsigned *d2,UINT *d);

void ndl_max(UINT *d1,unsigned *d2,UINT *d);

pointer GC_malloc_atomic_ignore_off_page(int);

void nmtodp(int mod,NM m,DP *r);

NODE reverse_node(NODE n);

P ndc_div(int mod,union oNDC a,union oNDC b);

P ndctop(int mod,union oNDC c);

void finalize_tracelist(int i,P cont);

void conv_ilist(int demand,int trace,NODE g,int **indp);

void parse_nd_option(NODE opt);

extern int Denominator,DP_Multiple;

Line 216 INLINE int ndl_reducible(UINT *d1,UINT *d2)

Line 227 INLINE int ndl_reducible(UINT *d1,UINT *d2)

* order is either 0 or 2.

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

void ndl_homogenize(UINT *d,UINT *r,int obpe,EPOS oepos,int ompos,int weight)

{

int w,i,e,n,omask0;

Line 229 void ndl_homogenize(UINT *d,UINT *r,int obpe,EPOS oepo

Line 240 void ndl_homogenize(UINT *d,UINT *r,int obpe,EPOS oepo

}

w = TD(d);

PUT_EXP(r,nd_nvar-1,weight-w);

if ( nd_module ) MPOS(r) = d[ompos];

TD(r) = weight;

if ( nd_blockmask ) ndl_weight_mask(r);

if ( nd_module ) MPOS(r) = MPOS(d);

}

void ndl_dehomogenize(UINT *d)

Line 363 void ndl_lcm(UINT *d1,unsigned *d2,UINT *d)

Line 374 void ndl_lcm(UINT *d1,unsigned *d2,UINT *d)

d[i] = u;

}

#endif

if ( nd_module ) MPOS(d) = MPOS(d1);

TD(d) = ndl_weight(d);

if ( nd_blockmask ) ndl_weight_mask(d);

if ( nd_module ) MPOS(d) = MPOS(d1);

}

void ndl_lcm_nocheck(UINT *d1,unsigned *d2,UINT *d)

void ndl_max(UINT *d1,unsigned *d2,UINT *d)

{

UINT t1,t2,u,u1,u2;

int i,j,l;

#if USE_UNROLL

switch ( nd_bpe ) {

case 3:

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

u1 = d1[i]; u2 = d2[i];

t1 = (u1&0x38000000); t2 = (u2&0x38000000); u = t1>t2?t1:t2;

t1 = (u1& 0x7000000); t2 = (u2& 0x7000000); u |= t1>t2?t1:t2;

t1 = (u1& 0xe00000); t2 = (u2& 0xe00000); u |= t1>t2?t1:t2;

t1 = (u1& 0x1c0000); t2 = (u2& 0x1c0000); u |= t1>t2?t1:t2;

t1 = (u1& 0x38000); t2 = (u2& 0x38000); u |= t1>t2?t1:t2;

t1 = (u1& 0x7000); t2 = (u2& 0x7000); u |= t1>t2?t1:t2;

t1 = (u1& 0xe00); t2 = (u2& 0xe00); u |= t1>t2?t1:t2;

t1 = (u1& 0x1c0); t2 = (u2& 0x1c0); u |= t1>t2?t1:t2;

t1 = (u1& 0x38); t2 = (u2& 0x38); u |= t1>t2?t1:t2;

t1 = (u1& 0x7); t2 = (u2& 0x7); u |= t1>t2?t1:t2;

d[i] = u;

}

break;

case 4:

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

u1 = d1[i]; u2 = d2[i];

t1 = (u1&0xf0000000); t2 = (u2&0xf0000000); u = t1>t2?t1:t2;

t1 = (u1& 0xf000000); t2 = (u2& 0xf000000); u |= t1>t2?t1:t2;

t1 = (u1& 0xf00000); t2 = (u2& 0xf00000); u |= t1>t2?t1:t2;

t1 = (u1& 0xf0000); t2 = (u2& 0xf0000); u |= t1>t2?t1:t2;

t1 = (u1& 0xf000); t2 = (u2& 0xf000); u |= t1>t2?t1:t2;

t1 = (u1& 0xf00); t2 = (u2& 0xf00); u |= t1>t2?t1:t2;

t1 = (u1& 0xf0); t2 = (u2& 0xf0); u |= t1>t2?t1:t2;

t1 = (u1& 0xf); t2 = (u2& 0xf); u |= t1>t2?t1:t2;

d[i] = u;

}

break;

case 6:

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

u1 = d1[i]; u2 = d2[i];

t1 = (u1&0x3f000000); t2 = (u2&0x3f000000); u = t1>t2?t1:t2;

t1 = (u1& 0xfc0000); t2 = (u2& 0xfc0000); u |= t1>t2?t1:t2;

t1 = (u1& 0x3f000); t2 = (u2& 0x3f000); u |= t1>t2?t1:t2;

t1 = (u1& 0xfc0); t2 = (u2& 0xfc0); u |= t1>t2?t1:t2;

t1 = (u1& 0x3f); t2 = (u2& 0x3f); u |= t1>t2?t1:t2;

d[i] = u;

}

break;

case 8:

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

u1 = d1[i]; u2 = d2[i];

t1 = (u1&0xff000000); t2 = (u2&0xff000000); u = t1>t2?t1:t2;

t1 = (u1& 0xff0000); t2 = (u2& 0xff0000); u |= t1>t2?t1:t2;

t1 = (u1& 0xff00); t2 = (u2& 0xff00); u |= t1>t2?t1:t2;

t1 = (u1& 0xff); t2 = (u2& 0xff); u |= t1>t2?t1:t2;

d[i] = u;

}

break;

case 16:

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

u1 = d1[i]; u2 = d2[i];

t1 = (u1&0xffff0000); t2 = (u2&0xffff0000); u = t1>t2?t1:t2;

t1 = (u1& 0xffff); t2 = (u2& 0xffff); u |= t1>t2?t1:t2;

d[i] = u;

}

break;

case 32:

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

u1 = d1[i]; u2 = d2[i];

d[i] = u1>u2?u1:u2;

}

break;

default:

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

u1 = d1[i]; u2 = d2[i];

for ( j = 0, u = 0; j < nd_epw; j++ ) {

t1 = (u1&nd_mask[j]); t2 = (u2&nd_mask[j]); u |= t1>t2?t1:t2;

}

d[i] = u;

}

break;

}

#else

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

u1 = d1[i]; u2 = d2[i];

for ( j = 0, u = 0; j < nd_epw; j++ ) {

Line 458 void ndl_lcm_nocheck(UINT *d1,unsigned *d2,UINT *d)

Line 391 void ndl_lcm_nocheck(UINT *d1,unsigned *d2,UINT *d)

}

d[i] = u;

}

#endif

TD(d) = ndl_weight(d);

if ( nd_blockmask ) ndl_weight_mask(d);

if ( nd_module ) MPOS(d) = MPOS(d1);

}

int ndl_weight(UINT *d)

Line 480 int ndl_weight(UINT *d)

Line 409 int ndl_weight(UINT *d)

for ( j = 0; j < nd_epw; j++, u>>=nd_bpe )

t += (u&nd_mask0);

}

if ( nd_module && current_module_weight_vector && MPOS(d) )

t += current_module_weight_vector[MPOS(d)];

return t;

}

Line 647 int ndl_ww_lex_compare(UINT *d1,UINT *d2)

Line 578 int ndl_ww_lex_compare(UINT *d1,UINT *d2)

int ndl_module_grlex_compare(UINT *d1,UINT *d2)

{

int i;

int i,c;

if ( nd_istop ) {

if ( nd_ispot ) {

if ( MPOS(d1) < MPOS(d2) ) return 1;

else if ( MPOS(d1) > MPOS(d2) ) return -1;

}

if ( TD(d1) > TD(d2) ) return 1;

else if ( TD(d1) < TD(d2) ) return -1;

for ( i = nd_nvar-1; i >= 0; i-- )

if ( c = ndl_lex_compare(d1,d2) ) return c;

if ( GET_EXP(d1,i) < GET_EXP(d2,i) ) return 1;

if ( !nd_ispot ) {

else if ( GET_EXP(d1,i) > GET_EXP(d2,i) ) return -1;

if ( !nd_istop ) {

if ( MPOS(d1) < MPOS(d2) ) return 1;

else if ( MPOS(d1) > MPOS(d2) ) return -1;

}

Line 667 int ndl_module_grlex_compare(UINT *d1,UINT *d2)

Line 596 int ndl_module_grlex_compare(UINT *d1,UINT *d2)

int ndl_module_glex_compare(UINT *d1,UINT *d2)

{

int i;

int i,c;

if ( nd_istop ) {

if ( nd_ispot ) {

if ( MPOS(d1) < MPOS(d2) ) return 1;

else if ( MPOS(d1) > MPOS(d2) ) return -1;

}

if ( TD(d1) > TD(d2) ) return 1;

else if ( TD(d1) < TD(d2) ) return -1;

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

if ( c = ndl_lex_compare(d1,d2) ) return c;

if ( GET_EXP(d1,i) > GET_EXP(d2,i) ) return 1;

if ( !nd_ispot ) {

else if ( GET_EXP(d1,i) < GET_EXP(d2,i) ) return -1;

if ( !nd_istop ) {

if ( MPOS(d1) < MPOS(d2) ) return 1;

else if ( MPOS(d1) > MPOS(d2) ) return -1;

}

Line 687 int ndl_module_glex_compare(UINT *d1,UINT *d2)

Line 614 int ndl_module_glex_compare(UINT *d1,UINT *d2)

int ndl_module_lex_compare(UINT *d1,UINT *d2)

{

int i;

int i,c;

if ( nd_istop ) {

if ( nd_ispot ) {

if ( MPOS(d1) < MPOS(d2) ) return 1;

else if ( MPOS(d1) > MPOS(d2) ) return -1;

}

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

if ( c = ndl_lex_compare(d1,d2) ) return c;

if ( GET_EXP(d1,i) > GET_EXP(d2,i) ) return 1;

if ( !nd_ispot ) {

else if ( GET_EXP(d1,i) < GET_EXP(d2,i) ) return -1;

if ( !nd_istop ) {

if ( MPOS(d1) < MPOS(d2) ) return 1;

else if ( MPOS(d1) > MPOS(d2) ) return -1;

}

Line 707 int ndl_module_block_compare(UINT *d1,UINT *d2)

Line 632 int ndl_module_block_compare(UINT *d1,UINT *d2)

{

int i,c;

if ( nd_istop ) {

if ( nd_ispot ) {

if ( MPOS(d1) < MPOS(d2) ) return 1;

else if ( MPOS(d1) > MPOS(d2) ) return -1;

}

if ( c = ndl_block_compare(d1,d2) ) return c;

if ( !nd_istop ) {

if ( !nd_ispot ) {

if ( MPOS(d1) < MPOS(d2) ) return 1;

else if ( MPOS(d1) > MPOS(d2) ) return -1;

}

Line 723 int ndl_module_matrix_compare(UINT *d1,UINT *d2)

Line 648 int ndl_module_matrix_compare(UINT *d1,UINT *d2)

{

int i,c;

if ( nd_istop ) {

if ( nd_ispot ) {

if ( MPOS(d1) < MPOS(d2) ) return 1;

else if ( MPOS(d1) > MPOS(d2) ) return -1;

}

if ( c = ndl_matrix_compare(d1,d2) ) return c;

if ( !nd_istop ) {

if ( !nd_ispot ) {

if ( MPOS(d1) < MPOS(d2) ) return 1;

else if ( MPOS(d1) > MPOS(d2) ) return -1;

}

Line 739 int ndl_module_composite_compare(UINT *d1,UINT *d2)

Line 664 int ndl_module_composite_compare(UINT *d1,UINT *d2)

{

int i,c;

if ( nd_istop ) {

if ( nd_ispot ) {

if ( MPOS(d1) > MPOS(d2) ) return 1;

else if ( MPOS(d1) < MPOS(d2) ) return -1;

}

if ( c = ndl_composite_compare(d1,d2) ) return c;

if ( !nd_istop ) {

if ( !nd_ispot ) {

if ( MPOS(d1) > MPOS(d2) ) return 1;

else if ( MPOS(d1) < MPOS(d2) ) return -1;

}

Line 806 INLINE void ndl_add(UINT *d1,UINT *d2,UINT *d)

Line 731 INLINE void ndl_add(UINT *d1,UINT *d2,UINT *d)

{

int i;

if ( nd_module ) {

if ( MPOS(d1) && MPOS(d2) && (MPOS(d1) != MPOS(d2)) )

error("ndl_add : invalid operation");

}

#if 1

switch ( nd_wpd ) {

case 2:

Line 824 INLINE void ndl_add(UINT *d1,UINT *d2,UINT *d)

Line 753 INLINE void ndl_add(UINT *d1,UINT *d2,UINT *d)

#else

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

#endif

if ( nd_module ) {

if ( MPOS(d1) && MPOS(d2) && (MPOS(d1) != MPOS(d2)) )

error("ndl_add : invalid operation");

MPOS(d) = MPOS(d1);

}

/* d1 += d2 */

Line 836 INLINE void ndl_addto(UINT *d1,UINT *d2)

Line 760 INLINE void ndl_addto(UINT *d1,UINT *d2)

{

int i;

if ( nd_module ) {

if ( MPOS(d1) && MPOS(d2) && (MPOS(d1) != MPOS(d2)) )

error("ndl_addto : invalid operation");

}

#if 1

switch ( nd_wpd ) {

case 2:

Line 854 INLINE void ndl_addto(UINT *d1,UINT *d2)

Line 782 INLINE void ndl_addto(UINT *d1,UINT *d2)

#else

for ( i = 0; i < nd_wpd; i++ ) d1[i] += d2[i];

#endif

if ( nd_module ) {

if ( MPOS(d1) && MPOS(d2) && (MPOS(d1) != MPOS(d2)) )

error("ndl_addto : invalid operation");

MPOS(d1) = MPOS(d2);

}

INLINE void ndl_sub(UINT *d1,UINT *d2,UINT *d)

Line 1318 ND nd_add_sf(ND p1,ND p2)

Line 1241 ND nd_add_sf(ND p1,ND p2)

}

ND nd_reduce2(int mod,ND d,ND g,NDV p,NM mul,NDC dn)

ND nd_reduce2(int mod,ND d,ND g,NDV p,NM mul,NDC dn,Obj *divp)

{

int c,c1,c2;

Q cg,cred,gcd,tq;

P cgp,credp,gcdp;

Obj tr,tr1;

if ( mod == -1 )

if ( mod == -1 ) {

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

else if ( mod ) {

*divp = (Obj)ONE;

} else if ( mod ) {

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

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

*divp = (Obj)ONE;

} else if ( nd_vc ) {

ezgcdpz(nd_vc,HCP(g),HCP(p),&gcdp);

divsp(nd_vc,HCP(g),gcdp,&cgp); divsp(nd_vc,HCP(p),gcdp,&credp);

Line 1339 ND nd_reduce2(int mod,ND d,ND g,NDV p,NM mul,NDC dn)

Line 1264 ND nd_reduce2(int mod,ND d,ND g,NDV p,NM mul,NDC dn)

mulr(nd_vc,(Obj)dn->r,(Obj)credp,&tr);

reductr(nd_vc,tr,&tr1); dn->r = (R)tr1;

}

*divp = (Obj)credp;

} else {

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

chsgnq(cg,&CQ(mul));

Line 1346 ND nd_reduce2(int mod,ND d,ND g,NDV p,NM mul,NDC dn)

Line 1272 ND nd_reduce2(int mod,ND d,ND g,NDV p,NM mul,NDC dn)

if ( dn ) {

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

}

*divp = (Obj)cred;

}

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

}

Line 1359 int nd_nf(int mod,ND d,ND g,NDV *ps,int full,NDC dn,ND

Line 1286 int nd_nf(int mod,ND d,ND g,NDV *ps,int full,NDC dn,ND

int c,c1,c2,dummy;

RHist h;

NDV p,red;

Q cg,cred,gcd,tq,qq;

Q cg,cred,gcd,tq,qq,iq;

DP dmul;

NODE node;

LIST hist;

double hmag;

P tp,tp1;

Obj tr,tr1;

Obj tr,tr1,div;

union oNDC hg;

P cont;

if ( dn ) {

if ( mod )

Line 1393 int nd_nf(int mod,ND d,ND g,NDV *ps,int full,NDC dn,ND

Line 1325 int nd_nf(int mod,ND d,ND g,NDV *ps,int full,NDC dn,ND

return 0;

}

p = nd_demand ? ndv_load(index) : ps[index];

g = nd_reduce2(mod,d,g,p,mul,dn);

/* d+g -> div*(d+g)+mul*p */

g = nd_reduce2(mod,d,g,p,mul,dn,&div);

if ( nd_gentrace ) {

/* Trace=[div,index,mul,ONE] */

STOQ(index,iq);

nmtodp(mod,mul,&dmul);

node = mknode(4,div,iq,dmul,ONE);

}

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

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

tp = HCP(g);

hg = HCU(g);

nd_removecont2(d,g);

if ( dn ) {

if ( dn || nd_gentrace ) {

if ( nd_vc ) {

/* overwrite cont : Trace=[div,index,mul,cont] */

divsp(nd_vc,tp,HCP(g),&tp1);

cont = ndc_div(mod,hg,HCU(g));

divr(nd_vc,(Obj)dn->r,(Obj)tp1,&tr);

if ( dn ) {

reductr(nd_vc,(Obj)tr,&tr1); dn->r = (R)tr1;

if ( nd_vc ) {

} else {

divr(nd_vc,(Obj)dn->r,(Obj)cont,&tr);

divq((Q)tp,HCQ(g),&qq);

reductr(nd_vc,(Obj)tr,&tr1); dn->r = (R)tr1;

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

} else divq(dn->z,(Q)cont,&dn->z);

}

if ( nd_gentrace && !UNIQ(cont) ) ARG3(node) = (pointer)cont;

}

hmag = ((double)p_mag(HCP(g)))*nd_scale;

}

MKLIST(hist,node);

MKNODE(node,hist,nd_tracelist); nd_tracelist = node;

} else if ( !full ) {

*rp = g;

return 1;

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

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

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

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

int ndv_check_membership(int m,NODE input,int obpe,int oadv,EPOS oepos,NODE cand)

{

int n,i,stat;

ND nf,d;

NDV r;

NODE t,s;

union oNDC dn;

Q q;

LIST list;

ndv_setup(0,0,cand,0,1);

ndv_setup(m,0,cand,nd_gentrace?1:0,1);

n = length(cand);

if ( nd_gentrace ) { nd_alltracelist = 0; nd_tracelist = 0; }

/* membercheck : list is a subset of Id(cand) ? */

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

for ( t = input, i = 0; t; t = NEXT(t), i++ ) {

again:

nd_tracelist = 0;

if ( nd_bpe > obpe )

r = ndv_dup_realloc((NDV)BDY(t),obpe,oadv,oepos);

else

r = (NDV)BDY(t);

d = ndvtond(0,r);

d = ndvtond(m,r);

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

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

if ( !stat ) {

nd_reconstruct(0,0);

goto again;

} else if ( nf ) return 0;

if ( nd_gentrace ) {

nd_tracelist = reverse_node(nd_tracelist);

MKLIST(list,nd_tracelist);

STOQ(i,q); s = mknode(2,q,list); MKLIST(list,s);

MKNODE(s,list,nd_alltracelist);

nd_alltracelist = s; nd_tracelist = 0;

}

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

}

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

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

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

/* XXX */

return 1;

}

Line 1866 int do_diagonalize(int sugar,int m)

Line 1816 int do_diagonalize(int sugar,int m)

ND h,nf,s,head;

NDV nfv;

Q q,num,den;

P nm,nmp,dn,mnp,dnp;

P nm,nmp,dn,mnp,dnp,cont,cont1;

union oNDC hc;

NODE node;

LIST l;

Q iq;

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

if ( nd_gentrace ) {

/* Trace = [1,index,1,1] */

STOQ(i,iq); node = mknode(4,ONE,iq,ONE,ONE);

MKLIST(l,node); MKNODE(nd_tracelist,l,0);

}

if ( nd_demand )

nfv = ndv_load(i);

else

Line 1878 int do_diagonalize(int sugar,int m)

Line 1837 int do_diagonalize(int sugar,int m)

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

if ( !stat ) return 0;

ndv_free(nfv);

nd_removecont(m,nf);

hc = HCU(nf); nd_removecont(m,nf);

cont = ndc_div(m,hc,HCU(nf));

if ( nd_gentrace ) finalize_tracelist(i,cont);

nfv = ndtondv(m,nf);

nd_free(nf);

nd_bound[i] = ndv_compute_bound(nfv);

Line 1894 int do_diagonalize(int sugar,int m)

Line 1855 int do_diagonalize(int sugar,int m)

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

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

NODE nd_gb(int m,int ishomo,int checkonly,int gensyz,int **indp)

{

int i,nh,sugar,stat;

NODE r,g,t;

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

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

ND h,nf,s,head,nf1;

NDV nfv;

Q q,num,den;

union oNDC dn;

union oNDC dn,hc;

int diag_count = 0;

P cont;

LIST list;

g = 0; d = 0;

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

d = update_pairs(d,g,i);

d = update_pairs(d,g,i,gensyz);

g = update_base(g,i);

}

sugar = 0;

Line 1935 again:

Line 1898 again:

goto again;

}

#if USE_GEOBUCKET

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

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

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

#else

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

#endif

Line 1944 again:

Line 1908 again:

d = nd_reconstruct(0,d);

goto again;

} else if ( nf ) {

if ( checkonly ) return 0;

if ( checkonly || gensyz ) return 0;

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

hc = HCU(nf);

nd_removecont(m,nf);

if ( !m && nd_nalg ) {

nd_monic(0,&nf);

nd_removecont(m,nf);

}

if ( nd_gentrace ) {

cont = ndc_div(m,hc,HCU(nf));

if ( m || !UNIQ(cont) ) {

t = mknode(4,0,0,0,cont);

MKLIST(list,t); MKNODE(t,list,nd_tracelist);

nd_tracelist = t;

}

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

nh = ndv_newps(m,nfv,0);

if ( !m && (ishomo && ++diag_count == diag_period) ) {

Line 1962 again:

Line 1935 again:

goto again;

}

d = update_pairs(d,g,nh);

d = update_pairs(d,g,nh,0);

g = update_base(g,nh);

FREENDP(l);

} else {

if ( nd_gentrace && gensyz ) {

nd_tracelist = reverse_node(nd_tracelist);

MKLIST(list,nd_tracelist);

STOQ(-1,q); t = mknode(2,q,list); MKLIST(list,t);

MKNODE(t,list,nd_alltracelist);

nd_alltracelist = t; nd_tracelist = 0;

}

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

FREENDP(l);

}

if ( nd_demand )

conv_ilist(nd_demand,0,g,indp);

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

if ( !checkonly && DP_Print ) { printf("nd_gb done.\n"); fflush(stdout); }

return g;

}

Line 1987 int do_diagonalize_trace(int sugar,int m)

Line 1962 int do_diagonalize_trace(int sugar,int m)

ND h,nf,nfq,s,head;

NDV nfv,nfqv;

Q q,den,num;

union oNDC hc;

NODE node;

LIST l;

Q iq;

P cont,cont1;

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

if ( nd_gentrace ) {

/* Trace = [1,index,1,1] */

STOQ(i,iq); node = mknode(4,ONE,iq,ONE,ONE);

MKLIST(l,node); MKNODE(nd_tracelist,l,0);

}

/* for nd_ps */

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

s = nd_separate_head(s,&head);

Line 2009 int do_diagonalize_trace(int sugar,int m)

Line 1994 int do_diagonalize_trace(int sugar,int m)

stat = nd_nf(0,head,s,nd_ps_trace,1,0,&nf);

if ( !stat ) return 0;

ndv_free(nfv);

nd_removecont(0,nf);

hc = HCU(nf); nd_removecont(0,nf);

cont = ndc_div(0,hc,HCU(nf));

if ( nd_gentrace ) finalize_tracelist(i,cont);

nfv = ndtondv(0,nf);

nd_free(nf);

nd_bound[i] = ndv_compute_bound(nfv);

Line 2037 void nd_subst_vector(VL vl,P p,NODE subst,P *r)

Line 2024 void nd_subst_vector(VL vl,P p,NODE subst,P *r)

*r = p;

}

NODE nd_gb_trace(int m,int ishomo)

NODE nd_gb_trace(int m,int ishomo,int **indp)

{

int i,nh,sugar,stat;

NODE r,g,t;

Line 2047 NODE nd_gb_trace(int m,int ishomo)

Line 2034 NODE nd_gb_trace(int m,int ishomo)

NDV nfv,nfqv;

Q q,den,num;

P hc;

union oNDC dn;

union oNDC dn,hnfq;

struct oEGT eg_monic,egm0,egm1;

int diag_count = 0;

P cont;

LIST list;

init_eg(&eg_monic);

init_eg(&eg_invdalg);

init_eg(&eg_le);

g = 0; d = 0;

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

d = update_pairs(d,g,i);

d = update_pairs(d,g,i,0);

g = update_base(g,i);

}

sugar = 0;

Line 2117 again:

Line 2106 again:

if ( !rem(NM(q),m) ) return 0;

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

hnfq = HCU(nfq);

if ( nd_nalg ) {

/* m|DN(HC(nf)^(-1)) => failure */

get_eg(&egm0);

Line 2128 again:

Line 2118 again:

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

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

}

if ( nd_gentrace ) {

cont = ndc_div(0,hnfq,HCU(nfqv));

if ( !UNIQ(cont) ) {

t = mknode(4,0,0,0,cont);

MKLIST(list,t); MKNODE(t,list,nd_tracelist);

nd_tracelist = t;

}

nh = ndv_newps(0,nfv,nfqv);

if ( ishomo && ++diag_count == diag_period ) {

diag_count = 0;

Line 2140 again:

Line 2138 again:

goto again;

}

d = update_pairs(d,g,nh);

d = update_pairs(d,g,nh,0);

g = update_base(g,nh);

} else {

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

Line 2150 again:

Line 2148 again:

}

FREENDP(l);

}

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_trace[(int)BDY(t)];

if ( nd_nalg ) {

print_eg("monic",&eg_monic);

print_eg("invdalg",&eg_invdalg);

print_eg("le",&eg_le);

}

conv_ilist(nd_demand,1,g,indp);

if ( DP_Print ) { printf("nd_gb_trace done.\n"); fflush(stdout); }

return g;

}

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

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

return -DL_COMPARE(HDL(*p1),HDL(*p2));

}

int ndvi_compare(NDVI p1,NDVI p2)

{

return DL_COMPARE(HDL(p1->p),HDL(p2->p));

}

int ndvi_compare_rev(NDVI p1,NDVI p2)

{

return -DL_COMPARE(HDL(p1->p),HDL(p2->p));

}

NODE ndv_reduceall(int m,NODE f)

{

int i,n,stat;

int i,j,n,stat;

ND nf,g,head;

NODE t,a0,a;

union oNDC dn;

NDV *w;

Q q,num,den;

NODE node;

LIST l;

Q iq,jq;

int *perm;

union oNDC hc;

P cont,cont1;

n = length(f);

#if 0

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

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

qsort(w,n,sizeof(NDV),

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

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

#endif

ndv_setup(m,0,f,0,1);

perm = (int *)MALLOC(n*sizeof(int));

if ( nd_gentrace ) {

for ( t = nd_tracelist, i = 0; i < n; i++, t = NEXT(t) )

perm[i] = QTOS((Q)ARG1(BDY((LIST)BDY(t))));

}

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

if ( nd_gentrace ) {

/* Trace = [1,index,1,1] */

STOQ(i,iq); node = mknode(4,ONE,iq,ONE,ONE);

MKLIST(l,node); MKNODE(nd_tracelist,l,0);

}

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

g = nd_separate_head(g,&head);

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

Line 2202 NODE ndv_reduceall(int m,NODE f)

Line 2213 NODE ndv_reduceall(int m,NODE f)

else {

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

ndv_free(nd_ps[i]);

nd_removecont(m,nf);

hc = HCU(nf); nd_removecont(m,nf);

if ( nd_gentrace ) {

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

jq = ARG1(BDY((LIST)BDY(t))); j = QTOS(jq);

STOQ(perm[j],jq); ARG1(BDY((LIST)BDY(t))) = jq;

}

cont = ndc_div(m,hc,HCU(nf));

finalize_tracelist(perm[i],cont);

}

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

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

i++;

Line 2211 NODE ndv_reduceall(int m,NODE f)

Line 2230 NODE ndv_reduceall(int m,NODE f)

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

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

NEXTNODE(a0,a);

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

if ( !nd_gentrace ) BDY(a) = (pointer)nd_ps[i];

else {

for ( j = 0; j < n; j++ ) if ( perm[j] == i ) break;

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

}

NEXT(a) = 0;

return a0;

}

ND_pairs update_pairs( ND_pairs d, NODE /* of index */ g, int t)

ND_pairs update_pairs( ND_pairs d, NODE /* of index */ g, int t, int gensyz)

{

ND_pairs d1,nd,cur,head,prev,remove;

if ( !g ) return d;

/* for testing */

if ( gensyz && nd_gensyz == 2 ) {

d1 = nd_newpairs(g,t);

if ( !d )

return d1;

else {

nd = d;

while ( NEXT(nd) ) nd = NEXT(nd);

NEXT(nd) = d1;

return d;

}

d = crit_B(d,t);

d1 = nd_newpairs(g,t);

d1 = crit_M(d1);

d1 = crit_F(d1);

if ( do_weyl )

if ( gensyz || do_weyl )

head = d1;

else {

prev = 0; cur = head = d1;

Line 2262 ND_pairs nd_newpairs( NODE g, int t )

Line 2297 ND_pairs nd_newpairs( NODE g, int t )

dl = DL(nd_psh[t]);

ts = SG(nd_psh[t]) - TD(dl);

for ( r0 = 0, h = g; h; h = NEXT(h) ) {

if ( nd_module && (MPOS(DL(nd_psh[(int)BDY(h)])) != MPOS(dl)) )

if ( nd_module && (MPOS(DL(nd_psh[(long)BDY(h)])) != MPOS(dl)) )

continue;

NEXTND_pairs(r0,r);

r->i1 = (int)BDY(h);

r->i1 = (long)BDY(h);

r->i2 = t;

ndl_lcm(DL(nd_psh[r->i1]),dl,r->lcm);

s = SG(nd_psh[r->i1])-TD(DL(nd_psh[r->i1]));

Line 2290 ND_pairs crit_B( ND_pairs d, int s )

Line 2325 ND_pairs crit_B( ND_pairs d, int s )

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

while ( cur ) {

tl = cur->lcm;

if ( ndl_reducible(tl,t)

if ( ndl_reducible(tl,t) ) {

&& (ndl_lcm(DL(nd_psh[cur->i1]),t,lcm),!ndl_equal(lcm,tl))

ndl_lcm(DL(nd_psh[cur->i1]),t,lcm);

&& (ndl_lcm(DL(nd_psh[cur->i2]),t,lcm),!ndl_equal(lcm,tl)) ) {

if ( !ndl_equal(lcm,tl) ) {

remove = cur;

ndl_lcm(DL(nd_psh[cur->i2]),t,lcm);

if ( !prev ) {

if (!ndl_equal(lcm,tl)) {

head = cur = NEXT(cur);

remove = cur;

if ( !prev ) {

head = cur = NEXT(cur);

} else {

cur = NEXT(prev) = NEXT(cur);

}

FREENDP(remove);

} else {

prev = cur; cur = NEXT(cur);

}

} else {

cur = NEXT(prev) = NEXT(cur);

prev = cur; cur = NEXT(cur);

}

FREENDP(remove);

} else {

prev = cur; cur = NEXT(cur);

}

Line 2423 NODE update_base(NODE nd,int ndp)

Line 2466 NODE update_base(NODE nd,int ndp)

dl = DL(nd_psh[ndp]);

for ( head = last = 0, p = nd; p; ) {

dln = DL(nd_psh[(int)BDY(p)]);

dln = DL(nd_psh[(long)BDY(p)]);

if ( ndl_reducible( dln, dl ) ) {

p = NEXT(p);

if ( last ) NEXT(last) = p;

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

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

int len;

RHist r;

NDV b;

NODE tn;

LIST l;

Q iq;

if ( nd_psn == nd_pslen ) {

nd_pslen *= 2;

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

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

nd_ps[nd_psn] = 0;

}

if ( nd_gentrace ) {

/* reverse the tracelist and append it to alltracelist */

nd_tracelist = reverse_node(nd_tracelist); MKLIST(l,nd_tracelist);

STOQ(nd_psn,iq); tn = mknode(2,iq,l); MKLIST(l,tn);

MKNODE(tn,l,nd_alltracelist); nd_alltracelist = tn; nd_tracelist = 0;

}

return nd_psn++;

}

/* nd_tracelist = [[0,index,div],...,[nd_psn-1,index,div]] */

void ndv_setup(int mod,int trace,NODE f,int dont_sort,int dont_removecont)

{

int i,j,td,len,max;

NODE s,s0,f0;

NODE s,s0,f0,tn;

UINT *d;

RHist r;

NDV *w;

NDVI w;

NDV a,am;

union oNDC hc;

NODE node;

P hcp;

Q iq,jq,hcq;

LIST l;

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

/* initialize the tracelist */

nd_tracelist = 0;

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

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

w = (NDVI)ALLOCA(nd_psn*sizeof(struct oNDVI));

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

for ( i = j = 0, s = f; s; s = NEXT(s), j++ )

if ( BDY(s) ) { w[i].p = BDY(s); w[i].i = j; i++; }

if ( !dont_sort ) {

/* XXX heuristic */

if ( !nd_ord->id && (nd_ord->ord.simple<2) )

qsort(w,nd_psn,sizeof(NDV),

qsort(w,nd_psn,sizeof(struct oNDVI),

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

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

else

qsort(w,nd_psn,sizeof(NDV),

qsort(w,nd_psn,sizeof(struct oNDVI),

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

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

}

nd_pslen = 2*nd_psn;

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

Line 2571 void ndv_setup(int mod,int trace,NODE f,int dont_sort,

Line 2633 void ndv_setup(int mod,int trace,NODE f,int dont_sort,

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

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

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

hc = HCU(w[i].p);

if ( trace ) {

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

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

if ( !dont_removecont) ndv_removecont(0,a);

register_hcf(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,w[i]);

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

if ( mod || !dont_removecont ) ndv_removecont(mod,a);

if ( !mod ) register_hcf(a);

}

if ( nd_gentrace ) {

STOQ(i,iq); STOQ(w[i].i,jq); node = mknode(3,iq,jq,ONE);

if ( !dont_removecont )

ARG2(node) = (pointer)ndc_div(trace?0:mod,hc,HCU(a));

MKLIST(l,node); NEXTNODE(nd_tracelist,tn); BDY(tn) = l;

}

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

nd_bound[i] = ndv_compute_bound(a);

nd_psh[i] = r;

Line 2596 void ndv_setup(int mod,int trace,NODE f,int dont_sort,

Line 2665 void ndv_setup(int mod,int trace,NODE f,int dont_sort,

}

if ( nd_gentrace && nd_tracelist ) NEXT(tn) = 0;

}

struct order_spec *append_block(struct order_spec *spec,

Line 2631 void preprocess_algcoef(VL vv,VL av,struct order_spec

Line 2701 void preprocess_algcoef(VL vv,VL av,struct order_spec

}

NEXT(t) = 0;

/* simplification, makeing polynomials monic */

/* simplification, making polynomials monic */

setfield_dalg(alist);

obj_algtodalg(f,&f1);

for ( t = BDY(f); t; t = NEXT(t) ) {

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

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

Obj obj;

NumberField nf;

struct order_spec *ord1;

NODE tr,tl1,tl2,tl3,tl4;

LIST l1,l2,l3,l4,l5;

int j;

Q jq;

int *perm;

EPOS oepos;

int obpe,oadv,ompos;

nd_module;

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

else nd_demand = 0;

parse_nd_option(current_option);

if ( DP_Multiple )

nd_scale = ((double)DP_Multiple)/(double)(Denominator?Denominator:1);

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

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

}

nd_setup_parameters(nvar,max);

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

ishomo = 1;

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

if ( nd_module ) {

pltozpl((LIST)BDY(t),&dmy,&zpl);

if ( !m && !nd_gentrace ) pltozpl((LIST)BDY(t),&dmy,&zpl);

else zpl = (LIST)BDY(t);

b = (pointer)pltondv(CO,vv,zpl);

} else {

ptozp((P)BDY(t),1,&dmy,&zp);

if ( !m && !nd_gentrace ) ptozp((P)BDY(t),1,&dmy,&zp);

else zp = (P)BDY(t);

b = (pointer)ptondv(CO,vv,zp);

}

if ( ishomo )

ishomo = ishomo && ndv_ishomo(b);

if ( m ) ndv_mod(m,b);

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

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

}

if ( fd0 ) NEXT(fd) = 0;

ndv_setup(m,0,fd0,0,0);

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

if ( nd_gentrace ) {

MKLIST(l1,nd_tracelist); MKNODE(nd_alltracelist,l1,0);

}

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

nd_demand = 0;

x = ndv_reducebase(x);

x = ndv_reducebase(x,perm);

if ( nd_gentrace ) { tl1 = nd_alltracelist; nd_alltracelist = 0; }

x = ndv_reduceall(m,x);

if ( nd_gentrace ) {

tl2 = nd_alltracelist; nd_alltracelist = 0;

ndv_check_membership(m,fd0,obpe,oadv,oepos,x);

if ( nd_gentrace ) {

tl3 = nd_alltracelist; nd_alltracelist = 0;

} else tl3 = 0;

nd_gb(m,0,1,nd_gensyz?1:0,0)!=0;

if ( nd_gentrace && nd_gensyz ) {

tl4 = nd_alltracelist; nd_alltracelist = 0;

} else tl4 = 0;

}

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

NEXTNODE(r0,r);

if ( nd_module ) BDY(r) = ndvtopl(m,CO,vv,BDY(t),mrank);

else BDY(r) = ndvtop(m,CO,vv,BDY(t));

}

if ( r0 ) NEXT(r) = 0;

if ( nalg )

r0 = postprocess_algcoef(av,alist,r0);

MKLIST(*rp,r0);

if ( nd_gentrace ) {

tl1 = reverse_node(tl1); tl2 = reverse_node(tl2);

tl3 = reverse_node(tl3);

/* tl2 = [[i,[[*,j,*,*],...]],...] */

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

/* s = [i,[*,j,*,*],...] */

s = BDY((LIST)BDY(t));

j = perm[QTOS((Q)ARG0(s))]; STOQ(j,jq); ARG0(s) = (pointer)jq;

for ( s = BDY((LIST)ARG1(s)); s; s = NEXT(s) ) {

j = perm[QTOS((Q)ARG1(BDY((LIST)BDY(s))))]; STOQ(j,jq);

ARG1(BDY((LIST)BDY(s))) = (pointer)jq;

}

for ( j = length(x)-1, t = 0; j >= 0; j-- ) {

STOQ(perm[j],jq); MKNODE(s,jq,t); t = s;

}

MKLIST(l1,tl1); MKLIST(l2,tl2); MKLIST(l3,t); MKLIST(l4,tl3);

MKLIST(l5,tl4);

tr = mknode(7,*rp,0,l1,l2,l3,l4,l5); MKLIST(*rp,tr);

}

#if 0

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

#endif

Line 2817 void nd_gr_postproc(LIST f,LIST v,int m,struct order_s

Line 2934 void nd_gr_postproc(LIST f,LIST v,int m,struct order_s

Obj obj;

NumberField nf;

struct order_spec *ord1;

int *perm;

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

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

Line 2864 void nd_gr_postproc(LIST f,LIST v,int m,struct order_s

Line 2982 void nd_gr_postproc(LIST f,LIST v,int m,struct order_s

for ( x = 0, i = 0; i < nd_psn; i++ )

x = update_base(x,i);

if ( do_check ) {

x = nd_gb(m,ishomo,1);

x = nd_gb(m,ishomo,1,0,&perm);

if ( !x ) {

*rp = 0;

return;

}

} else {

for ( t = x; t; t = NEXT(t) )

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

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

}

x = ndv_reducebase(x);

x = ndv_reducebase(x,perm);

x = ndv_reduceall(m,x);

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

NEXTNODE(r0,r);

Line 2895 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int

Line 3013 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int

P p,zp;

Q dmy;

EPOS oepos;

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

int obpe,oadv,wmax,i,len,cbpe,ishomo,nalg,mrank,trank,ompos;

Alg alpha,dp;

P poly;

LIST f1,f2;

LIST f1,f2,zpl;

Obj obj;

NumberField nf;

struct order_spec *ord1;

struct oEGT eg_check,eg0,eg1;

NODE tr,tl1,tl2,tl3,tl4;

LIST l1,l2,l3,l4,l5;

int *perm;

int j,ret;

Q jq;

nd_module = 0;

parse_nd_option(current_option);

if ( DP_Multiple )

nd_scale = ((double)DP_Multiple)/(double)(Denominator?Denominator:1);

Line 2942 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int

Line 3067 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int

nocheck = 1;

}

m = trace > 1 ? trace : get_lprime(mindex);

nd_init_ord(ord);

mrank = 0;

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

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

e = getdeg(tv->v,(P)BDY(t));

if ( nd_module ) {

max = MAX(e,max);

s = BDY((LIST)BDY(t));

trank = length(s);

mrank = MAX(mrank,trank);

for ( ; s; s = NEXT(s) ) {

e = getdeg(tv->v,(P)BDY(s));

max = MAX(e,max);

}

} else {

e = getdeg(tv->v,(P)BDY(t));

max = MAX(e,max);

}

nd_init_ord(ord);

nd_setup_parameters(nvar,max);

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

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

ishomo = 1;

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

ptozp((P)BDY(t),1,&dmy,&zp);

if ( nd_module ) {

c = (pointer)ptondv(CO,vv,zp);

if ( !nd_gentrace ) pltozpl((LIST)BDY(t),&dmy,&zpl);

else zpl = (LIST)BDY(t);

c = (pointer)pltondv(CO,vv,zpl);

} else {

if ( !nd_gentrace ) ptozp((P)BDY(t),1,&dmy,&zp);

else zp = (P)BDY(t);

c = (pointer)ptondv(CO,vv,zp);

}

if ( ishomo )

ishomo = ishomo && ndv_ishomo(c);

if ( c ) {

Line 2973 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int

Line 3116 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int

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

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

}

while ( 1 ) {

if ( Demand )

nd_demand = 1;

ndv_setup(m,1,fd0,0,0);

cand = f4?nd_f4_trace(m):nd_gb_trace(m,ishomo || homo);

if ( nd_gentrace ) {

MKLIST(l1,nd_tracelist); MKNODE(nd_alltracelist,l1,0);

}

cand = f4?nd_f4_trace(m,&perm):nd_gb_trace(m,ishomo || homo,&perm);

if ( !cand ) {

/* failure */

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

Line 2993 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int

Line 3139 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int

nd_setup_parameters(nvar,0);

}

nd_demand = 0;

cand = ndv_reducebase(cand);

cand = ndv_reducebase(cand,perm);

if ( nd_gentrace ) { tl1 = nd_alltracelist; nd_alltracelist = 0; }

cand = ndv_reduceall(0,cand);

cbpe = nd_bpe;

if ( nd_gentrace ) { tl2 = nd_alltracelist; nd_alltracelist = 0; }

if ( nocheck )

break;

get_eg(&eg0);

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

if ( ret = ndv_check_membership(0,in0,obpe,oadv,oepos,cand) ) {

/* success */

if ( nd_gentrace ) {

break;

tl3 = nd_alltracelist; nd_alltracelist = 0;

} else tl3 = 0;

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

ret = nd_gb(0,0,1,nd_gensyz?1:0,0)!=0;

if ( nd_gentrace && nd_gensyz ) {

tl4 = nd_alltracelist; nd_alltracelist = 0;

} else tl4 = 0;

}

if ( ret ) break;

else if ( trace > 1 ) {

/* failure */

*rp = 0; return;

Line 3024 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int

Line 3180 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int

/* dp->p */

nd_bpe = cbpe;

nd_setup_parameters(nd_nvar,0);

for ( r = cand; r; r = NEXT(r) )

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

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

if ( nd_module ) BDY(r) = ndvtopl(0,CO,vv,BDY(r),mrank);

else BDY(r) = (pointer)ndvtop(0,CO,vv,BDY(r));

}

if ( nalg )

cand = postprocess_algcoef(av,alist,cand);

MKLIST(*rp,cand);

if ( nd_gentrace ) {

tl1 = reverse_node(tl1); tl2 = reverse_node(tl2);

tl3 = reverse_node(tl3);

/* tl2 = [[i,[[*,j,*,*],...]],...] */

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

/* s = [i,[*,j,*,*],...] */

s = BDY((LIST)BDY(t));

j = perm[QTOS((Q)ARG0(s))]; STOQ(j,jq); ARG0(s) = (pointer)jq;

for ( s = BDY((LIST)ARG1(s)); s; s = NEXT(s) ) {

j = perm[QTOS((Q)ARG1(BDY((LIST)BDY(s))))]; STOQ(j,jq);

ARG1(BDY((LIST)BDY(s))) = (pointer)jq;

}

for ( j = length(cand)-1, t = 0; j >= 0; j-- ) {

STOQ(perm[j],jq); MKNODE(s,jq,t); t = s;

}

MKLIST(l1,tl1); MKLIST(l2,tl2); MKLIST(l3,t); MKLIST(l4,tl3);

MKLIST(l5,tl4);

tr = mknode(7,*rp,(!ishomo&&homo)?ONE:0,l1,l2,l3,l4,l5); MKLIST(*rp,tr);

}

/* XXX : module element is not considered */

Line 3079 DL ndltodl(int n,UINT *ndl)

Line 3257 DL ndltodl(int n,UINT *ndl)

return dl;

}

void nmtodp(int mod,NM m,DP *r)

{

DP dp;

MP mr;

NEWMP(mr);

mr->dl = ndltodl(nd_nvar,DL(m));

mr->c = ndctop(mod,m->c);

NEXT(mr) = 0; MKDP(nd_nvar,mr,dp); dp->sugar = mr->dl->td;

*r = dp;

}

void ndl_print(UINT *dl)

{

int n;

Line 3233 void ndv_removecont(int mod,NDV p)

Line 3423 void ndv_removecont(int mod,NDV p)

/* koko */

void ndv_homogenize(NDV p,int obpe,int oadv,EPOS oepos)

void ndv_homogenize(NDV p,int obpe,int oadv,EPOS oepos,int ompos)

{

int len,i,max;

NMV m,mr0,mr,t;

Line 3246 void ndv_homogenize(NDV p,int obpe,int oadv,EPOS oepos

Line 3436 void ndv_homogenize(NDV p,int obpe,int oadv,EPOS oepos

mr = (NMV)((char *)mr0+(len-1)*nmv_adv);

t = (NMV)ALLOCA(nmv_adv);

for ( i = 0; i < len; i++, NMV_OPREV(m), NMV_PREV(mr) ) {

ndl_homogenize(DL(m),DL(t),obpe,oepos,max);

ndl_homogenize(DL(m),DL(t),obpe,oepos,ompos,max);

CQ(mr) = CQ(m);

ndl_copy(DL(t),DL(mr));

}

Line 3256 void ndv_homogenize(NDV p,int obpe,int oadv,EPOS oepos

Line 3446 void ndv_homogenize(NDV p,int obpe,int oadv,EPOS oepos

void ndv_dehomogenize(NDV p,struct order_spec *ord)

{

int i,j,adj,len,newnvar,newwpd,newadv,newexporigin;

int i,j,adj,len,newnvar,newwpd,newadv,newexporigin,newmpos;

int pos;

Q *w;

Q dvr,t;

NMV m,r;

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

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

len = p->len;

newnvar = nd_nvar-1;

newexporigin = nd_get_exporigin(ord);

if ( nd_module ) newmpos = newexporigin-1;

newwpd = newnvar/nd_epw+(newnvar%nd_epw?1:0)+newexporigin;

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

ndl_dehomogenize(DL(m));

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

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

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

if ( nd_module ) pos = MPOS(DL(m));

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

adj = nd_exporigin-newexporigin;

for ( ; j < newwpd; j++ ) DL(r)[j] = DL(m)[j+adj];

if ( nd_module ) {

DL(r)[newmpos] = pos;

}

NV(p)--;

Line 3456 UINT *ndv_compute_bound(NDV p)

Line 3652 UINT *ndv_compute_bound(NDV p)

len = LEN(p);

m = BDY(p); ndl_copy(DL(m),d1); NMV_ADV(m);

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

ndl_lcm_nocheck(DL(m),d1,d2);

ndl_max(DL(m),d1,d2);

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

}

l = nd_nvar+31;

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

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

ND t1,t2;

UINT *lcm;

P gp,tp;

Q g,t;

Q g,t,iq;

int td;

LIST hist;

NODE node;

DP d;

if ( !mod && nd_demand ) {

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

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

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

}

t1 = ndv_mul_nm(mod,m1,p1); t2 = ndv_mul_nm(mod,m2,p2);

*rp = nd_add(mod,t1,t2);

if ( nd_gentrace ) {

/* nd_tracelist is initialized */

STOQ(p->i1,iq); nmtodp(mod,m1,&d); node = mknode(4,ONE,iq,d,ONE);

MKLIST(hist,node); MKNODE(nd_tracelist,hist,0);

STOQ(p->i2,iq); nmtodp(mod,m2,&d); node = mknode(4,ONE,iq,d,ONE);

MKLIST(hist,node); MKNODE(node,hist,nd_tracelist);

nd_tracelist = node;

}

FREENM(m1); FREENM(m2);

return 1;

}

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

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

for ( i = 0; i < tlen; i++ ) tab[i] = 0;

if ( !m0 || !m1 ) return;

d0 = DL(m0); d1 = DL(m1); n2 = n>>1;

if ( nd_module )

if ( MPOS(d0) ) error("weyl_mul_nm_nmv : invalid operation");

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

if ( mod ) {

c0 = CM(m0); c1 = CM(m1); DMAR(c0,c1,0,mod,c); CM(m) = c;

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

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

TD(DL(m)) = h;

if ( nd_blockmask ) ndl_weight_mask(DL(m));

}

if ( nd_module ) {

mpos = MPOS(d1);

if ( MPOS(d0) ) error("weyl_mul_nm_nmv : invalid operation");

}

tab[0] = m;

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

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

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

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

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

} else TD(d) = h;

if ( nd_blockmask ) ndl_weight_mask(d);

if ( nd_module ) MPOS(d) = mpos;

if ( mod ) c = ctab[j];

else q = ctab_q[j];

p = tab+curlen*j;

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

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

curlen *= k+1;

}

FREENM(m);

if ( nd_module ) {

mpos = MPOS(d1);

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

if ( tab[i] ) {

d = DL(tab[i]);

MPOS(d) = mpos;

TD(d) = ndl_weight(d);

}

ND ndv_mul_nm_symbolic(NM m0,NDV p)

Line 4213 NDV pltondv(VL vl,VL dvl,LIST p)

Line 4427 NDV pltondv(VL vl,VL dvl,LIST p)

r = 0;

for ( i = 1, t = BDY(p); t; t = NEXT(t), i++ ) {

ri = ptond(vl,dvl,(P)BDY(t));

if ( ri )

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

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

MPOS(DL(m)) = i;

TD(DL(m)) = ndl_weight(DL(m));

if ( nd_blockmask ) ndl_weight_mask(DL(m));

}

r = nd_add(0,r,ri);

}

return ndtondv(0,r);

Line 4435 void ndv_print_q(NDV p)

Line 4652 void ndv_print_q(NDV p)

}

NODE ndv_reducebase(NODE x)

NODE ndv_reducebase(NODE x,int *perm)

{

int len,i,j;

NDV *w;

NDVI w;

NODE t,t0;

len = length(x);

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

w = (NDVI)ALLOCA(len*sizeof(struct oNDVI));

for ( i = 0, t = x; i < len; i++, t = NEXT(t) ) w[i] = BDY(t);

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

w[i].p = BDY(t); w[i].i = perm[i];

}

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

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

if ( w[i] && w[j] )

if ( w[i].p && w[j].p )

if ( ndl_reducible(HDL(w[i]),HDL(w[j])) ) w[i] = 0;

if ( ndl_reducible(HDL(w[i].p),HDL(w[j].p)) ) w[i].p = 0;

else if ( ndl_reducible(HDL(w[j]),HDL(w[i])) ) w[j] = 0;

else if ( ndl_reducible(HDL(w[j].p),HDL(w[i].p)) ) w[j].p = 0;

}

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

for ( i = j = 0, t0 = 0; i < len; i++ ) {

if ( w[i] ) { NEXTNODE(t0,t); BDY(t) = (pointer)w[i]; }

if ( w[i].p ) {

NEXTNODE(t0,t); BDY(t) = (pointer)w[i].p;

perm[j++] = w[i].i;

}

NEXT(t) = 0; x = t0;

return x;

Line 4516 void nd_init_ord(struct order_spec *ord)

Line 4738 void nd_init_ord(struct order_spec *ord)

/* module order */

case 256:

nd_istop = ord->istop;

nd_ispot = ord->ispot;

nd_dcomp = -1;

nd_isrlex = 0;

switch ( ord->ord.simple ) {

case 0:

nd_isrlex = 1;

ndl_compare_function = ndl_module_grlex_compare;

break;

case 1:

nd_isrlex = 0;

ndl_compare_function = ndl_module_glex_compare;

break;

case 2:

nd_isrlex = 0;

ndl_compare_function = ndl_module_lex_compare;

break;

default:

Line 4560 BlockMask nd_create_blockmask(struct order_spec *ord)

Line 4784 BlockMask nd_create_blockmask(struct order_spec *ord)

BlockMask bm;

/* we only create mask table for block order */

if ( ord->id != 1 )

if ( ord->id != 1 && ord->id != 257 )

return 0;

n = ord->ord.block.length;

bm = (BlockMask)MALLOC(sizeof(struct oBlockMask));

Line 4584 EPOS nd_create_epos(struct order_spec *ord)

Line 4808 EPOS nd_create_epos(struct order_spec *ord)

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

switch ( ord->id ) {

case 0:

case 0: case 256:

if ( nd_isrlex ) {

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

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

Line 4597 EPOS nd_create_epos(struct order_spec *ord)

Line 4821 EPOS nd_create_epos(struct order_spec *ord)

}

break;

case 1:

case 1: case 257:

/* block order */

l = ord->ord.block.length;

op = ord->ord.block.order_pair;

Line 4621 EPOS nd_create_epos(struct order_spec *ord)

Line 4845 EPOS nd_create_epos(struct order_spec *ord)

/* matrix order */

case 3:

/* composite order */

default:

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

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

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

Line 5152 int nd_symbolic_preproc(PGeoBucket bucket,int trace,UI

Line 5376 int nd_symbolic_preproc(PGeoBucket bucket,int trace,UI

return col;

}

NODE nd_f4(int m)

NODE nd_f4(int m,int **indp)

{

int i,nh,stat,index;

NODE r,g;

Line 5178 NODE nd_f4(int m)

Line 5402 NODE nd_f4(int m)

#endif

g = 0; d = 0;

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

d = update_pairs(d,g,i);

d = update_pairs(d,g,i,0);

g = update_base(g,i);

}

while ( d ) {

Line 5222 NODE nd_f4(int m)

Line 5446 NODE nd_f4(int m)

nf = ndtondv(m,nf1);

}

nh = ndv_newps(m,nf,0);

d = update_pairs(d,g,nh);

d = update_pairs(d,g,nh,0);

g = update_base(g,nh);

}

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

#if 0

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

#endif

conv_ilist(0,0,g,indp);

return g;

}

NODE nd_f4_trace(int m)

NODE nd_f4_trace(int m,int **indp)

{

int i,nh,stat,index;

NODE r,g;

Line 5256 NODE nd_f4_trace(int m)

Line 5480 NODE nd_f4_trace(int m)

g = 0; d = 0;

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

d = update_pairs(d,g,i);

d = update_pairs(d,g,i,0);

g = update_base(g,i);

}

while ( d ) {

Line 5322 NODE nd_f4_trace(int m)

Line 5546 NODE nd_f4_trace(int m)

ndv_mod(m,nfv);

ndv_removecont(m,nfv);

nh = ndv_newps(0,nfv,nfqv);

d = update_pairs(d,g,nh);

d = update_pairs(d,g,nh,0);

g = update_base(g,nh);

}

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

#if 0

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

#endif

conv_ilist(0,1,g,indp);

return g;

}

Line 6479 int nd_monic(int mod,ND *p)

Line 6703 int nd_monic(int mod,ND *p)

PUT_EXP(DL(mr),i+nd_ntrans,e);

td += MUL_WEIGHT(e,i+nd_ntrans);

}

if ( nd_module ) MPOS(DL(mr)) = MPOS(DL(m));

TD(DL(mr)) = td;

if ( nd_blockmask) ndl_weight_mask(DL(mr));

if ( nd_module ) MPOS(DL(mr)) = MPOS(DL(m));

}

NEXT(mr) = 0;

Line 6492 int nd_monic(int mod,ND *p)

Line 6716 int nd_monic(int mod,ND *p)

nd_free(*p);

*p = r;

return 1;

}

NODE reverse_node(NODE n)

{

NODE t,t1;

for ( t = 0; n; n = NEXT(n) ) {

MKNODE(t1,BDY(n),t); t = t1;

}

return t;

}

P ndc_div(int mod,union oNDC a,union oNDC b)

{

union oNDC c;

int inv,t;

if ( mod == -1 ) c.m = _mulsf(a.m,_invsf(b.m));

else if ( mod ) {

inv = invm(b.m,mod);

DMAR(a.m,inv,0,mod,t); c.m = t;

} else if ( nd_vc )

divsp(nd_vc,a.p,b.p,&c.p);

else

divq(a.z,b.z,&c.z);

return ndctop(mod,c);

}

P ndctop(int mod,union oNDC c)

{

Q q;

int e;

GFS gfs;

if ( mod == -1 ) {

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

} else if ( mod ) {

STOQ(c.m,q); return (P)q;

} else

return (P)c.p;

}

/* [0,0,0,cont] = p -> p/cont */

void finalize_tracelist(int i,P cont)

{

LIST l;

NODE node;

Q iq;

if ( !UNIQ(cont) ) {

node = mknode(4,0,0,0,cont);

MKLIST(l,node); MKNODE(node,l,nd_tracelist);

nd_tracelist = node;

}

STOQ(i,iq);

nd_tracelist = reverse_node(nd_tracelist);

MKLIST(l,nd_tracelist);

node = mknode(2,iq,l); MKLIST(l,node);

MKNODE(node,l,nd_alltracelist); MKLIST(l,node);

nd_alltracelist = node; nd_tracelist = 0;

}

void conv_ilist(int demand,int trace,NODE g,int **indp)

{

int n,i,j;

int *ind;

NODE t;

n = length(g);

ind = (int *)MALLOC(n*sizeof(int));

for ( i = 0, t = g; i < n; i++, t = NEXT(t) ) {

j = (long)BDY(t); ind[i] = j;

BDY(t) = (pointer)(demand?ndv_load(j):(trace?nd_ps_trace[j]:nd_ps[j]));

}

if ( indp ) *indp = ind;

}

void parse_nd_option(NODE opt)

{

NODE t,p;

char *key;

Obj value;

nd_gentrace = 0; nd_gensyz = 0;

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

p = BDY((LIST)BDY(t));

key = BDY((STRING)BDY(p));

value = (Obj)BDY(NEXT(p));

if ( !strcmp(key,"gentrace") )

nd_gentrace = value?1:0;

else if ( !strcmp(key,"gensyz") )

nd_gensyz = value?1:0;

}

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