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.159 and 1.215

version 1.159, 2009/01/05 00:52:20

version 1.215, 2013/12/20 02:02:24

Line 1

/* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.158 2009/01/04 10:02:00 noro Exp $ */

/* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.214 2013/09/27 07:00:45 noro Exp $ */

#include "nd.h"

struct oEGT eg_search;

int diag_period = 6;

int weight_check = 1;

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

int nd_dcomp;

NM _nm_free_list;

Line 34 static UINT nd_mask[32];

Line 37 static UINT nd_mask[32];

static UINT nd_mask0,nd_mask1;

static NDV *nd_ps;

static NDV *nd_ps_gz;

static NDV *nd_ps_trace;

static NDV *nd_ps_sym;

static NDV *nd_ps_trace_sym;

static RHist *nd_psh;

static int nd_psn,nd_pslen;

static RHist *nd_red;

Line 46 static int nd_worb_len;

Line 52 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,nd_pot_nelim;

static NODE nd_tracelist;

static NODE nd_alltracelist;

static int nd_gentrace,nd_gensyz,nd_nora,nd_newelim,nd_intersect;

static int *nd_gbblock;

static NODE nd_nzlist,nd_check_splist;

static int nd_splist;

NumberField get_numberfield();

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

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

Line 70 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_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);

void dltondl(int n,DL dl,UINT *r);

DP ndvtodp(int mod,NDV p);

DP ndtodp(int mod,ND p);

NDV ndvtondvgz(NDV p);

NDV ndvgztondv(NDV p);

ND ndtondgz(ND p);

ND ndgztond(ND p);

extern int Denominator,DP_Multiple;

Line 77 void _NM_alloc()

Line 102 void _NM_alloc()

int i;

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

p = (NM)GC_malloc(sizeof(struct oNM)+(nd_wpd-1)*sizeof(UINT));

p = (NM)MALLOC(sizeof(struct oNM)+(nd_wpd-1)*sizeof(UINT));

p->next = _nm_free_list; _nm_free_list = p;

}

Line 88 void _ND_alloc()

Line 113 void _ND_alloc()

int i;

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

p = (ND)GC_malloc(sizeof(struct oND));

p = (ND)MALLOC(sizeof(struct oND));

p->body = (NM)_nd_free_list; _nd_free_list = p;

}

Line 99 void _NDP_alloc()

Line 124 void _NDP_alloc()

int i;

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

p = (ND_pairs)GC_malloc(sizeof(struct oND_pairs)

p = (ND_pairs)MALLOC(sizeof(struct oND_pairs)

+(nd_wpd-1)*sizeof(UINT));

p->next = _ndp_free_list; _ndp_free_list = p;

}

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

Line 242 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 230 void ndl_homogenize(UINT *d,UINT *r,int obpe,EPOS oepo

Line 255 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 364 void ndl_lcm(UINT *d1,unsigned *d2,UINT *d)

Line 389 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_max(UINT *d1,unsigned *d2,UINT *d)

Line 399 int ndl_weight(UINT *d)

Line 424 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 566 int ndl_ww_lex_compare(UINT *d1,UINT *d2)

Line 593 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 ( nd_pot_nelim && MPOS(d1)>=nd_pot_nelim+1 && MPOS(d2) >= nd_pot_nelim+1 ) {

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

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

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

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

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

return 0;

}

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 586 int ndl_module_grlex_compare(UINT *d1,UINT *d2)

Line 619 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 606 int ndl_module_glex_compare(UINT *d1,UINT *d2)

Line 637 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 626 int ndl_module_block_compare(UINT *d1,UINT *d2)

Line 655 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 642 int ndl_module_matrix_compare(UINT *d1,UINT *d2)

Line 671 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 658 int ndl_module_composite_compare(UINT *d1,UINT *d2)

Line 687 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 725 INLINE void ndl_add(UINT *d1,UINT *d2,UINT *d)

Line 754 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 743 INLINE void ndl_add(UINT *d1,UINT *d2,UINT *d)

Line 776 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 755 INLINE void ndl_addto(UINT *d1,UINT *d2)

Line 783 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 773 INLINE void ndl_addto(UINT *d1,UINT *d2)

Line 805 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 1237 ND nd_add_sf(ND p1,ND p2)

Line 1264 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 1258 ND nd_reduce2(int mod,ND d,ND g,NDV p,NM mul,NDC dn)

Line 1287 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 1265 ND nd_reduce2(int mod,ND d,ND g,NDV p,NM mul,NDC dn)

Line 1295 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 1278 int nd_nf(int mod,ND d,ND g,NDV *ps,int full,NDC dn,ND

Line 1309 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 1312 int nd_nf(int mod,ND d,ND g,NDV *ps,int full,NDC dn,ND

Line 1348 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) ) {

if ( !mod && g && !nd_vc && ((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 1455 int nd_nf_pbucket(int mod,ND g,NDV *ps,int full,ND *rp

Line 1501 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 1537 void free_pbucket(PGeoBucket b) {

Line 1591 void free_pbucket(PGeoBucket b) {

nd_free(b->body[i]);

b->body[i] = 0;

}

GC_free(b);

GCFREE(b);

}

void add_pbucket_symbolic(PGeoBucket g,ND d)

Line 1785 int do_diagonalize(int sugar,int m)

Line 1839 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 1797 int do_diagonalize(int sugar,int m)

Line 1860 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 1811 int do_diagonalize(int sugar,int m)

Line 1876 int do_diagonalize(int sugar,int m)

return 1;

}

LIST compute_splist()

{

NODE g,tn0,tn,node;

LIST l0;

ND_pairs d,t;

int i;

Q i1,i2;

g = 0; d = 0;

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

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

g = update_base(g,i);

}

for ( t = d, tn0 = 0; t; t = NEXT(t) ) {

NEXTNODE(tn0,tn);

STOQ(t->i1,i1); STOQ(t->i2,i2);

node = mknode(2,i1,i2); MKLIST(l0,node);

BDY(tn) = l0;

}

if ( tn0 ) NEXT(tn) = 0; MKLIST(l0,tn0);

return l0;

}

/* 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 1822 NODE nd_gb(int m,int ishomo,int checkonly)

Line 1910 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 1854 again:

Line 1944 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 1863 again:

Line 1954 again:

d = nd_reconstruct(0,d);

goto again;

} else if ( nf ) {

if ( checkonly ) return 0;

if ( checkonly || gensyz ) return 0;

if ( nd_newelim ) {

if ( nd_module ) {

if ( MPOS(HDL(nf)) > 1 ) return 0;

} else if ( !(HDL(nf)[nd_exporigin] & nd_mask[0]) ) 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,NULLP,NULLP,NULLP,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);

nh = ndv_newps(m,nfv,0,0);

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

diag_count = 0;

stat = do_diagonalize(sugar,m);

Line 1881 again:

Line 1986 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((long)BDY(t));

else

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

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

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

return g;

}

/* splist = [[i1,i2],...] */

int check_splist(int m,NODE splist)

{

NODE t,p;

ND_pairs d,r,l;

int stat;

ND h,nf;

for ( d = 0, t = splist; t; t = NEXT(t) ) {

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

NEXTND_pairs(d,r);

r->i1 = QTOS((Q)ARG0(p)); r->i2 = QTOS((Q)ARG1(p));

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

SG(r) = TD(LCM(r)); /* XXX */

}

if ( d ) NEXT(r) = 0;

while ( d ) {

again:

l = nd_minp(d,&d);

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

if ( !stat ) {

NEXT(l) = d; d = l;

d = nd_reconstruct(0,d);

goto again;

}

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

if ( !stat ) {

NEXT(l) = d; d = l;

d = nd_reconstruct(0,d);

goto again;

} else if ( nf ) return 0;

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

}

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

return 1;

}

int check_splist_f4(int m,NODE splist)

{

UINT *s0vect;

PGeoBucket bucket;

NODE p,rp0,t;

ND_pairs d,r,l,ll;

int col,stat;

for ( d = 0, t = splist; t; t = NEXT(t) ) {

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

NEXTND_pairs(d,r);

r->i1 = QTOS((Q)ARG0(p)); r->i2 = QTOS((Q)ARG1(p));

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

SG(r) = TD(LCM(r)); /* XXX */

}

if ( d ) NEXT(r) = 0;

while ( d ) {

l = nd_minsugarp(d,&d);

bucket = create_pbucket();

stat = nd_sp_f4(m,0,l,bucket);

if ( !stat ) {

for ( ll = l; NEXT(ll); ll = NEXT(ll) );

NEXT(ll) = d; d = l;

d = nd_reconstruct(0,d);

continue;

}

if ( bucket->m < 0 ) continue;

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

if ( !col ) {

for ( ll = l; NEXT(ll); ll = NEXT(ll) );

NEXT(ll) = d; d = l;

d = nd_reconstruct(0,d);

continue;

}

if ( nd_f4_red(m,l,0,s0vect,col,rp0,0) ) return 0;

}

return 1;

}

int do_diagonalize_trace(int sugar,int m)

{

int i,nh,stat;

Line 1906 int do_diagonalize_trace(int sugar,int m)

Line 2092 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 1928 int do_diagonalize_trace(int sugar,int m)

Line 2124 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 1956 void nd_subst_vector(VL vl,P p,NODE subst,P *r)

Line 2154 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 1966 NODE nd_gb_trace(int m,int ishomo)

Line 2164 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 2036 again:

Line 2236 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 2047 again:

Line 2248 again:

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

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

}

nh = ndv_newps(0,nfv,nfqv);

if ( nd_gentrace ) {

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

if ( !UNIQ(cont) ) {

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

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

nd_tracelist = t;

}

nh = ndv_newps(0,nfv,nfqv,0);

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

diag_count = 0;

if ( DP_Print > 2 ) fprintf(asir_out,"|");

Line 2059 again:

Line 2268 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 2069 again:

Line 2278 again:

}

FREENDP(l);

}

if ( nd_demand )

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

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

else

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

BDY(t) = (pointer)nd_ps_trace[(long)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 2094 int ndv_compare_rev(NDV *p1,NDV *p2)

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

if ( nd_nora ) return f;

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

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

Line 2361 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 2175 ND_pairs nd_newpairs( NODE g, int t )

Line 2422 ND_pairs nd_newpairs( NODE g, int t )

{

NODE h;

UINT *dl;

int ts,s;

int ts,s,i,t0,min,max;

ND_pairs r,r0;

dl = DL(nd_psh[t]);

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

if ( nd_module && nd_intersect && (MPOS(dl) > 1) ) return 0;

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

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

continue;

if ( nd_gbblock ) {

t0 = (long)BDY(h);

for ( i = 0; nd_gbblock[i] >= 0; i += 2 ) {

min = nd_gbblock[i]; max = nd_gbblock[i+1];

if ( t0 >= min && t0 <= max && t >= min && t <= max )

break;

}

if ( nd_gbblock[i] >= 0 )

continue;

}

NEXTND_pairs(r0,r);

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

r->i2 = t;

Line 2209 ND_pairs crit_B( ND_pairs d, int s )

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

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

return dm0;

}

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

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

{

int len;

RHist r;

NDV b;

NODE tn;

LIST l;

Q iq;

if ( nd_psn == nd_pslen ) {

nd_pslen *= 2;

nd_ps = (NDV *)REALLOC((char *)nd_ps,nd_pslen*sizeof(NDV));

nd_ps_gz = (NDV *)REALLOC((char *)nd_ps_gz,nd_pslen*sizeof(NDV));

nd_ps_trace = (NDV *)REALLOC((char *)nd_ps_trace,nd_pslen*sizeof(NDV));

nd_psh = (RHist *)REALLOC((char *)nd_psh,nd_pslen*sizeof(RHist));

nd_bound = (UINT **)

REALLOC((char *)nd_bound,nd_pslen*sizeof(UINT *));

nd_ps_sym = (NDV *)REALLOC((char *)nd_ps_sym,nd_pslen*sizeof(NDV));

nd_ps_trace_sym = (NDV *)REALLOC((char *)nd_ps_trace_sym,nd_pslen*sizeof(NDV));

}

NEWRHist(r); nd_psh[nd_psn] = r;

nd_ps[nd_psn] = a;

if ( aq ) {

nd_ps_trace[nd_psn] = aq;

nd_ps_gz[nd_psn] = ndvtondvgz(aq);

register_hcf(aq);

nd_bound[nd_psn] = ndv_compute_bound(aq);

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

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

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

if ( !m ) register_hcf(a);

nd_bound[nd_psn] = ndv_compute_bound(a);

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

if ( !m ) nd_ps_gz[nd_psn] = ndvtondvgz(a);

}

if ( nd_demand ) {

if ( aq ) {

ndv_save(nd_ps_trace[nd_psn],nd_psn);

nd_ps_trace_sym[nd_psn] = ndv_symbolic(m,nd_ps_trace[nd_psn]);

nd_ps_trace[nd_psn] = 0;

} else {

ndv_save(nd_ps[nd_psn],nd_psn);

nd_ps_sym[nd_psn] = ndv_symbolic(m,nd_ps[nd_psn]);

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

}

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

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

/* return 1 if success, 0 if failure (HC(a mod p)) */

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

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

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

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

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

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

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

nd_hcf = 0;

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

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

nd_ps_gz[i] = ndvtondvgz(a);

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

register_hcf(a);

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

ndv_mod(mod,am);

if ( DL_COMPARE(HDL(am),HDL(a)) )

return 0;

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 ) nd_ps_gz[i] = ndvtondvgz(a);

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;

if ( nd_demand ) {

if ( trace ) {

ndv_save(nd_ps_trace[i],i);

nd_ps_trace_sym[i] = ndv_symbolic(mod,nd_ps_trace[i]);

nd_ps_trace[i] = 0;

} else {

ndv_save(nd_ps[i],i);

nd_ps_sym[i] = ndv_symbolic(mod,nd_ps[i]);

nd_ps[i] = 0;

}

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

return 1;

}

struct order_spec *append_block(struct order_spec *spec,

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

Line 2861 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 2622 NODE postprocess_algcoef(VL av,NODE alist,NODE r)

Line 2933 NODE postprocess_algcoef(VL av,NODE alist,NODE r)

return u0;

}

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

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

{

VL tv,fv,vv,vc,av;

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

int e,max,nvar,i;

NDV b;

int ishomo,nalg,mrank,trank;

int ishomo,nalg,mrank,trank,wmax,len;

NMV a;

Alg alpha,dp;

P p,zp;

Q dmy;

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

Line 2948 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,nzlist;

LIST l1,l2,l3,l4,l5;

int j;

Q jq,bpe;

int *perm;

EPOS oepos;

int obpe,oadv,ompos,cbpe;

nd_module = 0;

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

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

}

nd_init_ord(ord);

mrank = 0;

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

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

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

if ( nd_module ) {

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

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

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

max = MAX(e,max);

}

nd_setup_parameters(nvar,max);

nd_setup_parameters(nvar,nd_nzlist?0: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);

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

}

if ( fd0 ) NEXT(fd) = 0;

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

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

if ( !ishomo && homo ) {

for ( t = fd0, wmax = max; t; t = NEXT(t) ) {

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

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

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

}

homogenize_order(ord,nvar,&ord1);

nd_init_ord(ord1);

nd_setup_parameters(nvar+1,wmax);

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

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

}

ndv_setup(m,0,fd0,(nd_gbblock||nd_splist||nd_check_splist)?1:0,0);

if ( nd_gentrace ) {

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

}

if ( nd_splist ) {

*rp = compute_splist();

return;

}

if ( nd_check_splist ) {

if ( f4 ) {

if ( check_splist_f4(m,nd_check_splist) ) *rp = (LIST)ONE;

else *rp = 0;

} else {

if ( check_splist(m,nd_check_splist) ) *rp = (LIST)ONE;

else *rp = 0;

}

return;

}

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

if ( !x ) {

*rp = 0; return;

}

if ( !ishomo && homo ) {

/* dehomogenization */

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

nd_init_ord(ord);

nd_setup_parameters(nvar,0);

}

nd_demand = 0;

x = ndv_reducebase(x);

if ( nd_module && nd_intersect ) {

for ( j = nd_psn-1, x = 0; j >= 0; j-- )

if ( MPOS(DL(nd_psh[j])) > 1 ) {

MKNODE(xx,(pointer)j,x); x = xx;

}

conv_ilist(nd_demand,0,x,0);

goto FINAL;

}

if ( nd_gentrace && f4 ) { nzlist = nd_alltracelist; }

x = ndv_reducebase(x,perm);

if ( nd_gentrace && !f4 ) { tl1 = nd_alltracelist; nd_alltracelist = 0; }

x = ndv_reduceall(m,x);

cbpe = nd_bpe;

if ( nd_gentrace && !f4 ) {

tl2 = nd_alltracelist; nd_alltracelist = 0;

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

tl3 = nd_alltracelist; nd_alltracelist = 0;

if ( nd_gensyz ) {

nd_gb(m,0,1,1,0);

tl4 = nd_alltracelist; nd_alltracelist = 0;

} else tl4 = 0;

}

nd_bpe = cbpe;

nd_setup_parameters(nd_nvar,0);

FINAL:

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

else if ( retdp ) BDY(r) = ndvtodp(m,BDY(t));

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

}

if ( r0 ) NEXT(r) = 0;

if ( nalg )

if ( !m && nd_nalg )

r0 = postprocess_algcoef(av,alist,r0);

MKLIST(*rp,r0);

if ( nd_gentrace ) {

if ( f4 ) {

STOQ(16,bpe);

tr = mknode(4,*rp,(!ishomo&&homo)?ONE:0,BDY(nzlist),bpe); MKLIST(*rp,tr);

} else {

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

STOQ(nd_bpe,bpe);

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

}

#if 0

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

#endif

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

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

Obj obj;

NumberField nf;

struct order_spec *ord1;

int *perm;

parse_nd_option(current_option);

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

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

switch ( ord->id ) {

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

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

nvar += nalg;

}

nd_init_ord(ord);

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

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

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

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

max = MAX(e,max);

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

Line 3199 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 {

#if 0

/* bug ? */

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

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

#else

conv_ilist(0,0,x,&perm);

#endif

}

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

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

}

if ( r0 ) NEXT(r) = 0;

if ( nalg )

if ( !m && nd_nalg )

r0 = postprocess_algcoef(av,alist,r0);

MKLIST(*rp,r0);

}

NDV recompute_trace(NODE trace,NDV *p,int m);

void nd_gr_recompute_trace(LIST f,LIST v,int m,struct order_spec *ord,LIST tlist,LIST *rp);

NDV recompute_trace(NODE ti,NDV *p,int mod)

{

int c,c1,c2,i;

NM mul,m,tail;

ND d,r,rm;

NODE sj;

NDV red;

Obj mj;

static int afo=0;

afo++;

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

CM(mul) = 1;

tail = 0;

for ( i = 0, d = r = 0; ti; ti = NEXT(ti), i++ ) {

sj = BDY((LIST)BDY(ti));

if ( ARG0(sj) ) {

red = p[QTOS((Q)ARG1(sj))];

mj = (Obj)ARG2(sj);

if ( OID(mj) != O_DP ) ndl_zero(DL(mul));

else dltondl(nd_nvar,BDY((DP)mj)->dl,DL(mul));

rm = ndv_mul_nm(mod,mul,red);

if ( !r ) r = rm;

else {

for ( m = BDY(r); m && !ndl_equal(m->dl,BDY(rm)->dl); m = NEXT(m), LEN(r)-- ) {

if ( d ) {

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

} else {

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

}

if ( !m ) return 0; /* failure */

else {

BDY(r) = m;

c1 = invm(HCM(rm),mod); c2 = mod-HCM(r);

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

nd_mul_c(mod,rm,c);

r = nd_add(mod,r,rm);

}

if ( tail ) NEXT(tail) = 0;

d = nd_add(mod,d,r);

nd_mul_c(mod,d,invm(HCM(d),mod));

return ndtondv(mod,d);

}

void nd_gr_recompute_trace(LIST f,LIST v,int m,struct order_spec *ord,LIST tlist,LIST *rp)

{

VL tv,fv,vv,vc,av;

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

int e,max,nvar,i;

NDV b;

int ishomo,nalg;

Alg alpha,dp;

P p,zp;

Q dmy;

LIST f1,f2;

Obj obj;

NumberField nf;

struct order_spec *ord1;

NODE permtrace,intred,ind,perm,trace,ti;

int len,n,j;

NDV *db,*pb;

parse_nd_option(current_option);

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

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

switch ( ord->id ) {

case 1:

if ( ord->nv != nvar )

error("nd_check : invalid order specification");

break;

default:

break;

}

nd_init_ord(ord);

nd_bpe = QTOS((Q)ARG7(BDY(tlist)));

nd_setup_parameters(nvar,0);

len = length(BDY(f));

db = (NDV *)MALLOC(len*sizeof(NDV *));

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

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

b = ptondv(CO,vv,zp);

ndv_mod(m,b);

ndv_mul_c(m,b,invm(HCM(b),m));

db[i] = b;

}

permtrace = BDY((LIST)ARG2(BDY(tlist)));

intred = BDY((LIST)ARG3(BDY(tlist)));

ind = BDY((LIST)ARG4(BDY(tlist)));

perm = BDY((LIST)ARG0(permtrace));

trace = NEXT(permtrace);

for ( i = length(perm)-1, t = trace; t; t = NEXT(t) ) {

j = QTOS((Q)ARG0(BDY((LIST)BDY(t))));

if ( j > i ) i = j;

}

n = i+1;

pb = (NDV *)MALLOC(n*sizeof(NDV *));

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

ti = BDY((LIST)BDY(t));

pb[QTOS((Q)ARG0(ti))] = db[QTOS((Q)ARG1(ti))];

}

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

ti = BDY((LIST)BDY(t));

pb[QTOS((Q)ARG0(ti))] = recompute_trace(BDY((LIST)ARG1(ti)),pb,m);

if ( !pb[QTOS((Q)ARG0(ti))] ) { *rp = 0; return; }

if ( DP_Print ) {

fprintf(asir_out,"."); fflush(asir_out);

}

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

ti = BDY((LIST)BDY(t));

pb[QTOS((Q)ARG0(ti))] = recompute_trace(BDY((LIST)ARG1(ti)),pb,m);

if ( !pb[QTOS((Q)ARG0(ti))] ) { *rp = 0; return; }

if ( DP_Print ) {

fprintf(asir_out,"*"); fflush(asir_out);

}

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

NEXTNODE(r0,r);

b = pb[QTOS((Q)BDY(t))];

ndv_mul_c(m,b,invm(HCM(b),m));

#if 0

BDY(r) = ndvtop(m,CO,vv,pb[QTOS((Q)BDY(t))]);

#else

BDY(r) = ndvtodp(m,pb[QTOS((Q)BDY(t))]);

#endif

}

if ( r0 ) NEXT(r) = 0;

MKLIST(*rp,r0);

if ( DP_Print ) fprintf(asir_out,"\n");

}

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

{

VL tv,fv,vv,vc,av;

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

Line 3376 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,mrank,trank;

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

Alg alpha,dp;

P poly;

LIST f1,f2,zpl;

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

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

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,bpe;

nd_module = 0;

parse_nd_option(current_option);

if ( DP_Multiple )

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

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

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

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

nd_init_ord(ord);

mrank = 0;

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

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

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

if ( nd_module ) {

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

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

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

}

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

if ( nd_module ) {

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

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

else zpl = (LIST)BDY(t);

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

} else {

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

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

Line 3479 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 ) {

tl1 = tl2 = tl3 = tl4 = 0;

if ( Demand )

nd_demand = 1;

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

ret = ndv_setup(m,1,fd0,nd_gbblock?1:0,0);

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

if ( nd_gentrace ) {

if ( !cand ) {

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

}

if ( ret )

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

if ( !ret || !cand ) {

/* failure */

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

else m = get_lprime(++mindex);

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

Line 3504 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; }

get_eg(&eg0);

if ( nocheck )

break;

get_eg(&eg0);

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

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

if ( nd_gentrace ) {

/* success */

tl3 = nd_alltracelist; nd_alltracelist = 0;

break;

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

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

nd_bpe = cbpe;

nd_setup_parameters(nd_nvar,0);

for ( r = cand; r; r = NEXT(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 )

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

STOQ(nd_bpe,bpe);

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

}

/* XXX : module element is not considered */

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

Line 3623 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 3170 void ndv_removecont(int mod,NDV p)

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

len = p->len;

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

for ( m = BDY(p), i = 0, max = 1; i < len; NMV_OADV(m), i++ )

max = MAX(max,TD(DL(m)));

mr0 = nmv_adv>oadv?(NMV)REALLOC(BDY(p),len*nmv_adv):BDY(p);

m = (NMV)((char *)mr0+(len-1)*oadv);

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 3193 void ndv_homogenize(NDV p,int obpe,int oadv,EPOS oepos

Line 3812 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 3201 void ndv_dehomogenize(NDV p,struct order_spec *ord)

Line 3821 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 3208 void ndv_dehomogenize(NDV p,struct order_spec *ord)

Line 3829 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 3363 void nd_free(ND p)

Line 3988 void nd_free(ND p)

void ndv_free(NDV p)

{

GC_free(BDY(p));

GCFREE(BDY(p));

}

void nd_append_red(UINT *d,int i)

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

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

else if ( max < 65536 ) nd_bpe = 16;

else nd_bpe = 32;

}

if ( !do_weyl && weight_check && (current_dl_weight_vector || nd_matrix) ) {

UINT t;

int st;

int *v;

/* t = max(weights) */

t = 0;

if ( current_dl_weight_vector )

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

if ( (st=current_dl_weight_vector[i]) < 0 ) st = -st;

if ( t < st ) t = st;

}

if ( nd_matrix )

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

for ( j = 0, v = nd_matrix[i]; j < nd_nvar; j++ ) {

if ( (st=v[j]) < 0 ) st = -st;

if ( t < st ) t = st;

}

/* i = bitsize of t */

for ( i = 0; t; t >>=1, i++ );

/* i += bitsize of nd_nvar */

for ( t = nd_nvar; t; t >>=1, i++);

/* nd_bpe+i = bitsize of max(weights)*max(exp)*nd_nvar */

if ( (nd_bpe+i) >= 31 )

error("nd_setup_parameters : too large weight");

}

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

Line 3533 ND_pairs nd_reconstruct(int trace,ND_pairs d)

Line 4183 ND_pairs nd_reconstruct(int trace,ND_pairs d)

prev_ndp_free_list = _ndp_free_list;

_nm_free_list = 0;

_ndp_free_list = 0;

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

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

ndv_realloc(nd_ps[i],obpe,oadv,oepos);

ndv_realloc(nd_ps_sym[i],obpe,oadv,oepos);

ndv_realloc(nd_ps_gz[i],obpe,oadv,oepos);

}

if ( trace )

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

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

ndv_realloc(nd_ps_trace[i],obpe,oadv,oepos);

ndv_realloc(nd_ps_trace_sym[i],obpe,oadv,oepos);

}

s0 = 0;

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

NEXTND_pairs(s0,s);

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

Line 4292 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 3671 int nd_sp(int mod,int trace,ND_pairs p,ND *rp)

Line 4330 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 3757 void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta

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

} else

} else if ( nd_vc )

mulp(nd_vc,CP(m0),CP(m1),&CP(m));

else

mulq(CQ(m0),CQ(m1),&CQ(m));

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

homo = n&1 ? 1 : 0;

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

Line 4443 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 3810 void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta

Line 4478 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 3820 void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta

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

ndl_addto(DL(tab[u]),d);

if ( mod ) {

c0 = CM(tab[u]); DMAR(c0,c,0,mod,c1); CM(tab[u]) = c1;

} else {

} else if ( nd_vc )

mulp(nd_vc,CP(tab[u]),(P)q,&CP(tab[u]));

else {

mulq(CQ(tab[u]),q,&q1); CQ(tab[u]) = q1;

}

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

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

ndl_add(DL(tab[u]),d,DL(t));

if ( mod ) {

c0 = CM(tab[u]); DMAR(c0,c,0,mod,c1); CM(t) = c1;

} else

} else if ( nd_vc )

mulp(nd_vc,CP(tab[u]),(P)q,&CP(t));

else

mulq(CQ(tab[u]),q,&CQ(t));

*p = t;

}

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

Line 4513 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 4033 NDV ndv_dup(int mod,NDV p)

Line 4713 NDV ndv_dup(int mod,NDV p)

return d;

}

NDV ndvtondvgz(NDV p)

{

NDV r;

int len,i;

NMV t;

r = ndv_dup(0,p);

len = LEN(p);

for ( t = BDY(r), i = 0; i < len; i++, NMV_ADV(t) ) CZ(t) = ztogz(CQ(t));

return r;

}

NDV ndvgztondv(NDV p)

{

NDV r;

int len,i;

NMV t;

r = ndv_dup(0,p);

len = LEN(p);

for ( t = BDY(r), i = 0; i < len; i++, NMV_ADV(t) ) CQ(t) = gztoz(CZ(t));

return r;

}

NDV ndv_symbolic(int mod,NDV p)

{

NDV d;

NMV t,m,m0;

int i,len;

if ( !p ) return 0;

len = LEN(p);

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

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

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

CQ(m) = ONE;

}

MKNDV(NV(p),m0,len,d);

SG(d) = SG(p);

return d;

}

ND nd_dup(ND p)

{

ND d;

Line 4050 ND nd_dup(ND p)

Line 4772 ND nd_dup(ND p)

return d;

}

ND ndtondgz(ND p)

{

ND r;

NM t;

r = nd_dup(p);

for ( t = BDY(r); t; t = NEXT(t) ) CZ(t) = ztogz(CQ(t));

return r;

}

ND ndgztond(ND p)

{

ND r;

NM t;

r = nd_dup(p);

for ( t = BDY(r); t; t = NEXT(t) ) CQ(t) = gztoz(CZ(t));

return r;

}

/* XXX if p->len == 0 then it represents 0 */

void ndv_mod(int mod,NDV p)

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

Line 4894 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 4301 NDV ndtondv(int mod,ND p)

Line 5048 NDV ndtondv(int mod,ND p)

if ( !p ) return 0;

len = LEN(p);

if ( mod )

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

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

else

m0 = m = MALLOC(len*nmv_adv);

#if 0

Line 4337 ND ndvtond(int mod,NDV p)

Line 5084 ND ndvtond(int mod,NDV p)

return d;

}

DP ndvtodp(int mod,NDV p)

{

MP m,m0;

DP d;

NMV t;

int i,len;

if ( !p ) return 0;

m0 = 0;

len = p->len;

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

NEXTMP(m0,m);

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

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

}

NEXT(m) = 0;

MKDP(nd_nvar,m0,d);

SG(d) = SG(p);

return d;

}

DP ndtodp(int mod,ND p)

{

MP m,m0;

DP d;

NM t;

int i,len;

if ( !p ) return 0;

m0 = 0;

len = p->len;

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

NEXTMP(m0,m);

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

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

}

NEXT(m) = 0;

MKDP(nd_nvar,m0,d);

SG(d) = SG(p);

return d;

}

void ndv_print(NDV p)

{

NMV m;

Line 4372 void ndv_print_q(NDV p)

Line 5161 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 4400 NODE ndv_reducebase(NODE x)

Line 5194 NODE ndv_reducebase(NODE x)

void nd_init_ord(struct order_spec *ord)

{

nd_module = (ord->id >= 256);

nd_matrix = 0;

nd_matrix_len = 0;

switch ( ord->id ) {

case 0:

switch ( ord->ord.simple ) {

Line 4453 void nd_init_ord(struct order_spec *ord)

Line 5249 void nd_init_ord(struct order_spec *ord)

/* module order */

case 256:

nd_istop = ord->istop;

nd_ispot = ord->ispot;

nd_pot_nelim = ord->pot_nelim;

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 4472 void nd_init_ord(struct order_spec *ord)

Line 5271 void nd_init_ord(struct order_spec *ord)

break;

case 257:

/* block order */

nd_ispot = ord->ispot;

nd_pot_nelim = ord->pot_nelim;

nd_dcomp = -1;

nd_isrlex = 0;

ndl_compare_function = ndl_module_block_compare;

break;

case 258:

/* matrix order */

nd_ispot = ord->ispot;

nd_pot_nelim = ord->pot_nelim;

nd_dcomp = -1;

nd_isrlex = 0;

nd_matrix_len = ord->ord.matrix.row;

nd_matrix = ord->ord.matrix.matrix;

ndl_compare_function = ndl_module_matrix_compare;

break;

case 259:

/* composite order */

nd_ispot = ord->ispot;

nd_pot_nelim = ord->pot_nelim;

nd_dcomp = -1;

nd_isrlex = 0;

nd_worb_len = ord->ord.composite.length;

nd_worb = ord->ord.composite.w_or_b;

ndl_compare_function = ndl_module_composite_compare;

Line 4497 BlockMask nd_create_blockmask(struct order_spec *ord)

Line 5308 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 4521 EPOS nd_create_epos(struct order_spec *ord)

Line 5332 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 4534 EPOS nd_create_epos(struct order_spec *ord)

Line 5345 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 4558 EPOS nd_create_epos(struct order_spec *ord)

Line 5369 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 4570 EPOS nd_create_epos(struct order_spec *ord)

Line 5381 EPOS nd_create_epos(struct order_spec *ord)

/* external interface */

void nd_nf_p(P f,LIST g,LIST v,int m,struct order_spec *ord,P *rp)

void nd_nf_p(Obj f,LIST g,LIST v,int m,struct order_spec *ord,Obj *rp)

{

NODE t,in0,in;

ND nd,nf;

ND ndf,nf;

NDV ndv;

NDV ndvf;

VL vv,tv;

int stat,nvar,max,e;

int stat,nvar,max,mrank;

union oNDC dn;

Q cont;

P pp;

LIST ppl;

if ( !f ) {

*rp = 0;

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

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

pltovl(v,&vv);

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

/* get the degree bound */

/* max=65536 implies nd_bpe=32 */

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

max = 65536;

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

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

max = MAX(e,max);

}

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

e = getdeg(tv->v,f);

max = MAX(e,max);

}

nd_module = 0;

/* nd_module will be set if ord is a module ordering */

nd_init_ord(ord);

nd_setup_parameters(nvar,max);

if ( nd_module && OID(f) != O_LIST )

error("nd_nf_p : the first argument must be a list");

if ( nd_module ) mrank = length(BDY((LIST)f));

/* conversion to ndv */

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

NEXTNODE(in0,in);

ptozp((P)BDY(t),1,&cont,&pp);

if ( nd_module ) {

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

if ( !BDY(t) || OID(BDY(t)) != O_LIST

|| length(BDY((LIST)BDY(t))) != mrank )

error("nd_nf_p : inconsistent basis element");

if ( !m ) pltozpl((LIST)BDY(t),&cont,&ppl);

else ppl = (LIST)BDY(t);

BDY(in) = (pointer)pltondv(CO,vv,ppl);

} else {

if ( !m ) ptozp((P)BDY(t),1,&cont,&pp);

else pp = (P)BDY(t);

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

}

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

}

NEXTNODE(in0,in);

if ( in0 ) NEXT(in) = 0;

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

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

NEXT(in) = 0;

if ( nd_module ) ndvf = pltondv(CO,vv,(LIST)f);

else ndvf = ptondv(CO,vv,(P)f);

if ( m ) ndv_mod(m,ndvf);

ndf = (pointer)ndvtond(m,ndvf);

/* dont sort, dont removecont */

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

nd_psn--;

nd_scale=2;

while ( 1 ) {

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

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

if ( !stat )

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

error("nd_nf_p : exponent too large");

if ( !stat ) {

if ( nd_module ) *rp = (Obj)ndvtopl(m,CO,vv,ndtondv(m,nf),mrank);

nd_psn++;

else *rp = (Obj)ndvtop(m,CO,vv,ndtondv(m,nf));

nd_reconstruct(0,0);

nd_psn--;

} else

break;

}

*rp = ndvtop(m,CO,vv,ndtondv(m,nf));

}

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

Line 4686 Q *nm_ind_pair_to_vect(int mod,UINT *s0,int n,NM_ind_p

Line 5499 Q *nm_ind_pair_to_vect(int mod,UINT *s0,int n,NM_ind_p

return r;

}

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

IndArray nm_ind_pair_to_vect_compress(int mod,UINT *s0,int n,int *s0hash,NM_ind_pair pair)

{

NM m;

NMV mr;

Line 4695 IndArray nm_ind_pair_to_vect_compress(int mod,UINT *s0

Line 5508 IndArray nm_ind_pair_to_vect_compress(int mod,UINT *s0

unsigned char *ivc;

unsigned short *ivs;

UINT *v,*ivi,*s0v;

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

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

IndArray r;

struct oEGT eg0,eg1;

m = pair->mul;

d = DL(m);

p = nd_ps[pair->index];

p = nd_demand?nd_ps_sym[pair->index]:nd_ps[pair->index];

len = LEN(p);

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

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

get_eg(&eg0);

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

h = ndl_hash_value(t);

for ( ; h != s0hash[i] || !ndl_equal(t,s); s += nd_wpd, i++ );

v[j] = i;

}

get_eg(&eg1); add_eg(&eg_search,&eg0,&eg1);

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

r->head = v[0];

diff = 0;

Line 4776 int ndv_reduce_vect_q(Q *svect,int trace,int col,IndAr

Line 5593 int ndv_reduce_vect_q(Q *svect,int trace,int col,IndAr

k = ivect->head;

if ( svect[k] ) {

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

redv = trace?nd_ps_trace[rp0[i]->index]:nd_ps[rp0[i]->index];

redv = nd_demand?ndv_load(rp0[i]->index)

:(trace?nd_ps_trace[rp0[i]->index]:nd_ps[rp0[i]->index]);

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

igcd_cofactor(svect[k],CQ(mr),&gcd,&cs,&cr);

chsgnq(cs,&mcs);

Line 4828 int ndv_reduce_vect_q(Q *svect,int trace,int col,IndAr

Line 5646 int ndv_reduce_vect_q(Q *svect,int trace,int col,IndAr

return maxrs;

}

int ndv_reduce_vect_gz(GZ *gvect,int trace,int col,IndArray *imat,NM_ind_pair *rp0,int nred)

{

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

GZ cs,mcs,c1,c2,cr,gcd,t;

IndArray ivect;

unsigned char *ivc;

unsigned short *ivs;

unsigned int *ivi;

NDV redv;

NMV mr;

NODE rp;

int maxrs;

double hmag;

struct oVECT v;

maxrs = 0;

for ( i = 0; i < col && !gvect[i]; i++ );

if ( i == col ) return maxrs;

hmag = (double)n_bits_gz(gvect[i])*nd_scale;

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

ivect = imat[i];

k = ivect->head;

if ( gvect[k] ) {

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

redv = nd_ps_gz[rp0[i]->index];

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

gcdgz(gvect[k],CZ(mr),&gcd);

divsgz(gvect[k],gcd,&cs);

divsgz(CZ(mr),gcd,&cr);

chsgngz(cs,&mcs);

if ( !UNIGZ(cr) ) {

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

mulgz(gvect[j],cr,&c1); gvect[j] = c1;

}

gvect[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;

mulgz(CZ(mr),mcs,&c2); addgz(gvect[pos],c2,&t); gvect[pos] = t;

}

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;

mulgz(CZ(mr),mcs,&c2); addgz(gvect[pos],c2,&t); gvect[pos] = t;

}

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;

mulgz(CZ(mr),mcs,&c2); addgz(gvect[pos],c2,&t); gvect[pos] = t;

}

break;

}

for ( j = k+1; j < col && !gvect[j]; j++ );

if ( j == col ) break;

if ( hmag && ((double)n_bits_gz(gvect[j]) > hmag) ) {

v.len = col; v.body = (pointer)gvect; gcdvgz(&v,&gcd);

#if 1

for ( l = 0; l < col; l++ ) { divsgz(gvect[l],gcd,&t); gvect[l] = t; }

#endif

hmag = (double)n_bits_gz(gvect[j])*nd_scale;

}

for ( j = 0; j < col && !gvect[j]; j++ );

if ( j < col ) {

v.len = col; v.body = (pointer)gvect; gcdvgz(&v,&gcd);

for ( l = 0; l < col; l++ ) { divsgz(gvect[l],gcd,&t); gvect[l] = t; }

}

if ( DP_Print ) {

fprintf(asir_out,"-"); fflush(asir_out);

}

return maxrs;

}

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;

Line 4854 int ndv_reduce_vect(int m,UINT *svect,int col,IndArray

Line 5754 int ndv_reduce_vect(int m,UINT *svect,int col,IndArray

case 1:

ivc = ivect->index.c;

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

pos = prev+ivc[j]; c1 = CM(mr); c2 = svect[pos];

pos = prev+ivc[j]; c1 = CM(mr); prev = pos;

prev = pos;

if ( c1 ) {

DMA(c1,c,c2,up,lo);

c2 = svect[pos];

if ( up ) { DSAB(m,up,lo,dmy,c3); svect[pos] = c3;

DMA(c1,c,c2,up,lo);

} else svect[pos] = lo;

if ( up ) { DSAB(m,up,lo,dmy,c3); svect[pos] = c3;

} else svect[pos] = lo;

}

break;

case 2:

ivs = ivect->index.s;

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

pos = prev+ivs[j]; c1 = CM(mr); c2 = svect[pos];

pos = prev+ivs[j]; c1 = CM(mr);

prev = pos;

DMA(c1,c,c2,up,lo);

if ( c1 ) {

if ( up ) { DSAB(m,up,lo,dmy,c3); svect[pos] = c3;

c2 = svect[pos];

} else svect[pos] = lo;

DMA(c1,c,c2,up,lo);

if ( up ) { DSAB(m,up,lo,dmy,c3); svect[pos] = c3;

} else svect[pos] = lo;

}

break;

case 4:

ivi = ivect->index.i;

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

pos = prev+ivi[j]; c1 = CM(mr); c2 = svect[pos];

pos = prev+ivi[j]; c1 = CM(mr);

prev = pos;

DMA(c1,c,c2,up,lo);

if ( c1 ) {

if ( up ) { DSAB(m,up,lo,dmy,c3); svect[pos] = c3;

c2 = svect[pos];

} else svect[pos] = lo;

DMA(c1,c,c2,up,lo);

if ( up ) { DSAB(m,up,lo,dmy,c3); svect[pos] = c3;

} else svect[pos] = lo;

}

break;

}

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

Line 5858 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)GC_malloc_atomic_ignore_off_page(nmv_adv*len);

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

#if 0

ndv_alloc += nmv_adv*len;

#endif

Line 4980 NDV vect_to_ndv_q(Q *vect,int spcol,int col,int *rhead

Line 5888 NDV vect_to_ndv_q(Q *vect,int spcol,int col,int *rhead

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

if ( !len ) return 0;

else {

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

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

#if 0

ndv_alloc += nmv_adv*len;

#endif

Line 4999 NDV vect_to_ndv_q(Q *vect,int spcol,int col,int *rhead

Line 5907 NDV vect_to_ndv_q(Q *vect,int spcol,int col,int *rhead

}

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

{

int j,k,len;

UINT *p;

Q c;

NDV r;

NMV mr0,mr;

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

if ( !len ) return 0;

else {

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

#if 0

ndv_alloc += nmv_adv*len;

#endif

mr = mr0;

p = s0vect;

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

if ( !rhead[j] ) {

if ( c = vect[k++] ) {

ndl_copy(p,DL(mr)); CZ(mr) = c; NMV_ADV(mr);

}

MKNDV(nd_nvar,mr0,len,r);

return r;

}

/* for plain vector */

NDV plain_vect_to_ndv_q(Q *vect,int col,UINT *s0vect)

Line 5012 NDV plain_vect_to_ndv_q(Q *vect,int col,UINT *s0vect)

Line 5948 NDV plain_vect_to_ndv_q(Q *vect,int col,UINT *s0vect)

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

if ( !len ) return 0;

else {

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

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

#if 0

ndv_alloc += nmv_adv*len;

#endif

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

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

NDV *ps;

s0 = 0; rp0 = 0; col = 0;

ps = trace?nd_ps_trace:nd_ps;

if ( nd_demand )

ps = trace?nd_ps_trace_sym:nd_ps_sym;

else

ps = trace?nd_ps_trace:nd_ps;

while ( 1 ) {

head = remove_head_pbucket_symbolic(bucket);

if ( !head ) break;

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

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

NODE r,g,tn0,tn,node;

ND_pairs d,l,t;

ND_pairs d,l,t,ll0,ll;

LIST l0,l1;

ND spol,red;

NDV nf,redv;

NM s0,s;

NODE rp0,srp0,nflist;

NODE rp0,srp0,nflist,nzlist;

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

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

UINT c;

UINT **spmat;

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

Line 5109 NODE nd_f4(int m)

Line 6049 NODE nd_f4(int m)

int sugar;

PGeoBucket bucket;

struct oEGT eg0,eg1,eg_f4;

Q i1,i2,sugarq;

#if 0

ndv_alloc = 0;

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

}

nzlist = 0;

while ( d ) {

get_eg(&eg0);

l = nd_minsugarp(d,&d);

sugar = SG(l);

if ( nd_nzlist ) {

for ( tn = nd_nzlist; tn; tn = NEXT(tn) ) {

node = BDY((LIST)BDY(tn));

if ( QTOS((Q)ARG0(node)) == sugar ) break;

}

if ( !tn ) error("nd_f4 : inconsistent non-zero list");

for ( t = l, ll0 = 0; t; t = NEXT(t) ) {

for ( tn = BDY((LIST)ARG1(node)); tn; tn = NEXT(tn) ) {

i1s = QTOS((Q)ARG0(BDY((LIST)BDY(tn))));

i2s = QTOS((Q)ARG1(BDY((LIST)BDY(tn))));

if ( t->i1 == i1s && t->i2 == i2s ) break;

}

if ( tn ) {

if ( !ll0 ) ll0 = t;

else NEXT(ll) = t;

ll = t;

}

if ( ll0 ) NEXT(ll) = 0;

l = ll0;

}

bucket = create_pbucket();

stat = nd_sp_f4(m,0,l,bucket);

if ( !stat ) {

Line 5142 NODE nd_f4(int m)

Line 6104 NODE nd_f4(int m)

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,0,s0vect,col,rp0,nd_gentrace?&ll:0);

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

else

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

/* adding new bases */

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

nf = (NDV)BDY(r);

Line 5158 NODE nd_f4(int m)

Line 6117 NODE nd_f4(int m)

nd_removecont(m,nf1);

nf = ndtondv(m,nf1);

}

nh = ndv_newps(m,nf,0);

nh = ndv_newps(m,nf,0,1);

d = update_pairs(d,g,nh);

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

g = update_base(g,nh);

}

if ( nd_gentrace ) {

for ( t = ll, tn0 = 0; t; t = NEXT(t) ) {

NEXTNODE(tn0,tn);

STOQ(t->i1,i1); STOQ(t->i2,i2);

node = mknode(2,i1,i2); MKLIST(l0,node);

BDY(tn) = l0;

}

if ( tn0 ) NEXT(tn) = 0; MKLIST(l0,tn0);

STOQ(sugar,sugarq); node = mknode(2,sugarq,l0); MKLIST(l1,node);

MKNODE(node,l1,nzlist); nzlist = node;

}

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

if ( nd_gentrace ) {

MKLIST(l0,reverse_node(nzlist));

MKNODE(nd_alltracelist,l0,0);

}

#if 0

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

#endif

conv_ilist(nd_demand,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 5193 NODE nd_f4_trace(int m)

Line 6167 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 5258 NODE nd_f4_trace(int m)

Line 6232 NODE nd_f4_trace(int m)

nfv = ndv_dup(0,nfqv);

ndv_mod(m,nfv);

ndv_removecont(m,nfv);

nh = ndv_newps(0,nfv,nfqv);

nh = ndv_newps(0,nfv,nfqv,1);

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[(long)BDY(r)];

#if 0

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

#endif

conv_ilist(nd_demand,1,g,indp);

return g;

}

NODE nd_f4_pseudo_trace(int m,int **indp)

{

int i,nh,stat,index;

NODE r,g;

ND_pairs d,l,l0,t;

ND spol,red;

NDV nf,redv,nfqv,nfv;

NM s0,s;

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;

int *rhead;

int spcol,sprow;

int sugar;

PGeoBucket bucket;

struct oEGT eg0,eg1,eg_f4;

g = 0; d = 0;

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

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

g = update_base(g,i);

}

while ( d ) {

get_eg(&eg0);

l = nd_minsugarp(d,&d);

sugar = SG(l);

bucket = create_pbucket();

stat = nd_sp_f4(m,0,l,bucket);

if ( !stat ) {

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

NEXT(t) = d; d = l;

d = nd_reconstruct(1,d);

continue;

}

if ( bucket->m < 0 ) continue;

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

if ( !col ) {

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

NEXT(t) = d; d = l;

d = nd_reconstruct(1,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);

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

if ( !l0 ) continue;

l = l0;

/* over Q */

while ( 1 ) {

bucket = create_pbucket();

stat = nd_sp_f4(0,1,l,bucket);

if ( !stat ) {

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

NEXT(t) = d; d = l;

d = nd_reconstruct(1,d);

continue;

}

if ( bucket->m < 0 ) continue;

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

if ( !col ) {

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

NEXT(t) = d; d = l;

d = nd_reconstruct(1,d);

continue;

}

nflist = nd_f4_red(0,l,1,s0vect,col,rp0,0);

}

/* adding new bases */

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

nfqv = (NDV)BDY(r);

ndv_removecont(0,nfqv);

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

if ( nd_nalg ) {

ND nf1;

nf1 = ndvtond(m,nfqv);

nd_monic(0,&nf1);

nd_removecont(0,nf1);

nfqv = ndtondv(0,nf1); nd_free(nf1);

}

nfv = ndv_dup(0,nfqv);

ndv_mod(m,nfv);

ndv_removecont(m,nfv);

nh = ndv_newps(0,nfv,nfqv,1);

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

g = update_base(g,nh);

}

#if 0

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

#endif

conv_ilist(0,1,g,indp);

return g;

}

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

{

IndArray *imat;

Line 5278 NODE nd_f4_red(int m,ND_pairs sp0,int trace,UINT *s0ve

Line 6355 NODE nd_f4_red(int m,ND_pairs sp0,int trace,UINT *s0ve

NODE r0,rp;

ND_pairs sp;

NM_ind_pair *rvect;

UINT *s;

int *s0hash;

init_eg(&eg_search);

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

nred = length(rp0);

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

Line 5286 NODE nd_f4_red(int m,ND_pairs sp0,int trace,UINT *s0ve

Line 6366 NODE nd_f4_red(int m,ND_pairs sp0,int trace,UINT *s0ve

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

/* construction of index arrays */

fprintf(stderr,"%dx%d,",nsp+nred,col);

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

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

for ( i = 0, s = s0vect; i < col; i++, s += nd_wpd )

s0hash[i] = ndl_hash_value(s);

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

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

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

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

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

}

if ( m )

r0 = nd_f4_red_main(m,sp0,nsp,s0vect,col,rvect,rhead,imat,nred,nz);

else

r0 = nd_f4_red_q_main(sp0,nsp,trace,s0vect,col,rvect,rhead,imat,nred);

r0 = nd_f4_red_gz_main(sp0,nsp,trace,s0vect,col,rvect,rhead,imat,nred);

print_eg("search",&eg_search);

return r0;

}

Line 5348 NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s

Line 6433 NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s

fflush(asir_out);

}

/* free index arrays */

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

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

/* elimination (2nd step) */

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

Line 5361 NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s

Line 6446 NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s

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

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

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

GC_free(spmat[i]);

GCFREE(spmat[i]);

}

if ( r0 ) NEXT(r) = 0;

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

for ( ; i < sprow; i++ ) GCFREE(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 ) {

Line 5429 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U

Line 6514 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U

fflush(asir_out);

}

/* free index arrays */

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

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

/* elimination (2nd step) */

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

rank = nd_gauss_elim_q(spmat,spsugar,sprow,spcol,colstat);

w = (pointer *)ALLOCA(rank*sizeof(pointer));

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

#if 0

w[rank-i-1] = (pointer)vect_to_ndv_q(spmat[i],spcol,col,rhead,s0vect);

SG((NDV)w[rank-i-1]) = spsugar[i];

/* GC_free(spmat[i]); */

#else

w[i] = (pointer)vect_to_ndv_q(spmat[i],spcol,col,rhead,s0vect);

SG((NDV)w[i]) = spsugar[i];

#endif

/* GCFREE(spmat[i]); */

}

#if 0

qsort(w,rank,sizeof(NDV),

Line 5450 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U

Line 6540 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U

}

if ( r0 ) NEXT(r) = 0;

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

/* for ( ; i < sprow; i++ ) GCFREE(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 ) {

Line 5461 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U

Line 6551 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U

}

return r0;

}

NODE nd_f4_red_gz_main(ND_pairs sp0,int nsp,int trace,UINT *s0vect,int col,

NM_ind_pair *rvect,int *rhead,IndArray *imat,int nred)

{

int spcol,sprow,a;

int i,j,k,l,rank;

NODE r0,r;

ND_pairs sp;

ND spol;

GZ **spmat;

GZ *svect,*v;

int *colstat;

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

int maxrs;

int *spsugar;

pointer *w;

spcol = col-nred;

get_eg(&eg0);

/* elimination (1st step) */

spmat = (GZ **)ALLOCA(nsp*sizeof(GZ *));

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

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

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

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

if ( !spol ) continue;

spol = ndtondgz(spol);

nd_to_vect_q(s0vect,col,spol,(Q *)svect);

maxrs = ndv_reduce_vect_gz(svect,trace,col,imat,rvect,nred);

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

if ( i < col ) {

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

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++ ) GCFREE(imat[i]->index.c); */

/* elimination (2nd step) */

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

rank = nd_gauss_elim_gz(spmat,spsugar,sprow,spcol,colstat);

w = (pointer *)ALLOCA(rank*sizeof(pointer));

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

#if 0

w[rank-i-1] = (pointer)vect_to_ndv_gz(spmat[i],spcol,col,rhead,s0vect);

w[rank-i-1] = ndvgztondv(w[rank-i-1]);

SG((NDV)w[rank-i-1]) = spsugar[i];

#else

w[i] = (pointer)vect_to_ndv_gz((Q *)spmat[i],spcol,col,rhead,s0vect);

w[i] = ndvgztondv(w[i]);

SG((NDV)w[i]) = spsugar[i];

#endif

/* GCFREE(spmat[i]); */

}

#if 0

qsort(w,rank,sizeof(NDV),

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

#endif

r0 = 0;

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

NEXTNODE(r0,r); BDY(r) = w[i];

}

if ( r0 ) NEXT(r) = 0;

/* for ( ; i < sprow; i++ ) GCFREE(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;

}

#else

void printm(Q **mat,int row,int col)

{

int i,j;

Line 5582 NDV nd_recv_ndv()

Line 6757 NDV nd_recv_ndv()

len = nd_recv_int();

if ( !len ) return 0;

else {

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

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

#if 0

ndv_alloc += len*nmv_adv;

#endif

Line 5613 int ox_exec_f4_red(Q proc)

Line 6788 int ox_exec_f4_red(Q proc)

return s;

}

#if 0

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

{

int nsp,nred;

Line 5775 void nd_exec_f4_red_dist()

Line 6951 void nd_exec_f4_red_dist()

}

fflush(nd_write);

}

#endif

int nd_gauss_elim_q(Q **mat0,int *sugar,int row,int col,int *colstat)

{

int mod,i,j,t,c,rank,rank0,inv;

int i,j,t,c,rank,inv;

int *ci,*ri;

Q dn;

MAT m,nm;

int **wmat;

/* XXX */

mod = 99999989;

wmat = (int **)ALLOCA(row*sizeof(int *));

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

wmat[i] = (int *)ALLOCA(col*sizeof(int));

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

if ( mat0[i][j] ) {

t = rem(NM(mat0[i][j]),mod);

if ( SGN(mat0[i][j]) < 0 ) t = mod-t;

wmat[i][j] = t;

} else

wmat[i][j] = 0;

}

rank0 = nd_gauss_elim_mod(wmat,sugar,0,row,col,mod,colstat);

NEWMAT(m); m->row = row; m->col = col; m->body = (pointer **)mat0;

rank = generic_gauss_elim(m,&nm,&dn,&ri,&ci);

if ( rank != rank0 )

error("afo");

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

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

mat0[i][j] = 0;

Line 5812 int nd_gauss_elim_q(Q **mat0,int *sugar,int row,int co

Line 6971 int nd_gauss_elim_q(Q **mat0,int *sugar,int row,int co

for ( j = 0; j < c; j++ )

mat0[i][ci[j]] = (Q)BDY(nm)[i][j];

}

inv = invm(rem(NM(dn),mod),mod);

return rank;

if ( SGN(dn) < 0 ) inv = mod-inv;

}

int nd_gauss_elim_gz(GZ **mat0,int *sugar,int row,int col,int *colstat)

{

int i,j,t,c,rank,inv;

int *ci,*ri;

GZ *dn;

MAT m,nm;

NEWMAT(m); m->row = row; m->col = col; m->body = (pointer **)mat0;

dn = (GZ *)MALLOC(row*sizeof(GZ));

rank = gz_generic_gauss_elim2(m,&nm,dn,&ri,&ci);

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

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

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

if ( mat0[i][j] ) {

mat0[i][j] = 0;

t = rem(NM(mat0[i][j]),mod);

c = col-rank;

if ( SGN(mat0[i][j]) < 0 ) t = mod-t;

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

} else

mat0[i][ri[i]] = dn[i];

t = 0;

for ( j = 0; j < c; j++ )

c = dmar(t,inv,0,mod);

mat0[i][ci[j]] = (GZ)BDY(nm)[i][j];

if ( wmat[i][j] != c )

}

error("afo");

}

return rank;

}

Line 6004 void ndv_save(NDV p,int index)

Line 7172 void ndv_save(NDV p,int index)

fclose(s);

}

void nd_save_mod(ND p,int index)

{

FILE *s;

char name[BUFSIZ];

int nv,sugar,len,c;

NM m;

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

s = fopen(name,"w");

if ( !p ) {

len = 0;

write_int(s,&len);

fclose(s);

return;

}

nv = NV(p);

sugar = SG(p);

len = LEN(p);

write_int(s,&nv); write_int(s,&sugar); write_int(s,&len);

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

c = CM(m); write_int(s,&c);

write_intarray(s,DL(m),nd_wpd);

}

fclose(s);

}

NDV ndv_load(int index)

{

FILE *s;

Line 6048 NDV ndv_load(int index)

Line 7242 NDV ndv_load(int index)

return d;

}

ND nd_load_mod(int index)

{

FILE *s;

char name[BUFSIZ];

int nv,sugar,len,i,c;

ND d;

NM m0,m;

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

s = fopen(name,"r");

/* if the file does not exist, it means p[index]=0 */

if ( !s ) return 0;

read_int(s,&nv);

if ( !nv ) { fclose(s); return 0; }

read_int(s,&sugar);

read_int(s,&len);

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

NEXTNM(m0,m);

read_int(s,&c); CM(m) = c;

read_intarray(s,DL(m),nd_wpd);

}

NEXT(m) = 0;

MKND(nv,m0,len,d);

SG(d) = sugar;

fclose(s);

return d;

}

void nd_det(int mod,MAT f,P *rp)

{

VL fv,tv;

Line 6112 void nd_det(int mod,MAT f,P *rp)

Line 7336 void nd_det(int mod,MAT f,P *rp)

m = (pointer **)w;

}

for ( i = 0, max = 0; i < n; i++ )

for ( i = 0, max = 1; i < n; i++ )

for ( j = 0; j < n; j++ )

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

e = getdeg(tv->v,(P)m[i][j]);

Line 6120 void nd_det(int mod,MAT f,P *rp)

Line 7344 void nd_det(int mod,MAT f,P *rp)

}

nd_setup_parameters(nvar,max);

dm = (NDV **)almat_pointer(n,n);

for ( i = 0, max = 0; i < n; i++ )

for ( i = 0, max = 1; i < n; i++ )

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

dm[i][j] = ptondv(CO,fv,m[i][j]);

if ( mod ) ndv_mod(mod,dm[i][j]);

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

Line 7640 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 6429 int nd_monic(int mod,ND *p)

Line 7653 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,NULLP,NULLP,NULLP,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,u;

int i,s;

char *key;

Obj value;

nd_gentrace = 0; nd_gensyz = 0; nd_nora = 0; nd_gbblock = 0;

nd_newelim = 0; nd_intersect = 0; nd_nzlist = 0;

nd_splist = 0; nd_check_splist = 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;

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

nd_nora = value?1:0;

else if ( !strcmp(key,"gbblock") ) {

if ( !value || OID(value) != O_LIST )

error("nd_* : invalid value for gbblock option");

u = BDY((LIST)value);

nd_gbblock = MALLOC((2*length(u)+1)*sizeof(int));

for ( i = 0; u; u = NEXT(u) ) {

p = BDY((LIST)BDY(u));

s = nd_gbblock[i++] = QTOS((Q)BDY(p));

nd_gbblock[i++] = s+QTOS((Q)BDY(NEXT(p)))-1;

}

nd_gbblock[i] = -1;

} else if ( !strcmp(key,"newelim") )

nd_newelim = value?1:0;

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

nd_intersect = value?1:0;

else if ( !strcmp(key,"trace") ) {

u = BDY((LIST)value);

nd_nzlist = BDY((LIST)ARG2(u));

nd_bpe = QTOS((Q)ARG3(u));

} else if ( !strcmp(key,"splist") )

nd_splist = value?1:0;

else if ( !strcmp(key,"check_splist") ) {

nd_check_splist = BDY((LIST)value);

}

ND mdptond(DP d);

ND nd_mul_nm(int mod,NM m0,ND p);

ND *btog(NODE ti,ND **p,int nb,int mod);

ND btog_one(NODE ti,ND *p,int nb,int mod);

MAT nd_btog(LIST f,LIST v,int m,struct order_spec *ord,LIST tlist,MAT *rp);

VECT nd_btog_one(LIST f,LIST v,int m,struct order_spec *ord,LIST tlist,int pos,MAT *rp);

/* d:monomial */

ND mdptond(DP d)

{

NM m;

ND r;

if ( OID(d) == 1 )

r = ptond(CO,CO,(P)d);

else {

NEWNM(m);

dltondl(NV(d),BDY(d)->dl,DL(m));

CQ(m) = (Q)BDY(d)->c;

NEXT(m) = 0;

MKND(NV(d),m,1,r);

}

return r;

}

ND nd_mul_nm(int mod,NM m0,ND p)

{

UINT *d0;

int c0,c1,c;

NM tm,mr,mr0;

ND r;

if ( !p ) return 0;

d0 = DL(m0);

c0 = CM(m0);

mr0 = 0;

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

NEXTNM(mr0,mr);

c = CM(tm); DMAR(c0,c,0,mod,c1); CM(mr) = c1;

ndl_add(d0,DL(tm),DL(mr));

}

NEXT(mr) = 0;

MKND(NV(p),mr0,LEN(p),r);

return r;

}

ND *btog(NODE ti,ND **p,int nb,int mod)

{

PGeoBucket *r;

int i,ci;

NODE t,s;

ND m,tp;

ND *pi,*rd;

P c;

r = (PGeoBucket *)MALLOC(nb*sizeof(PGeoBucket));

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

r[i] = create_pbucket();

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

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

if ( ARG0(s) ) {

m = mdptond((DP)ARG2(s));

ptomp(mod,(P)HCQ(m),&c);

if ( ci = ((MQ)c)->cont ) {

HCM(m) = ci;

pi = p[QTOS((Q)ARG1(s))];

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

tp = nd_mul_nm(mod,BDY(m),pi[i]);

add_pbucket(mod,r[i],tp);

}

ci = 1;

} else {

ptomp(mod,(P)ARG3(s),&c); ci = ((MQ)c)->cont;

ci = invm(ci,mod);

}

rd = (ND *)MALLOC(nb*sizeof(ND));

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

rd[i] = normalize_pbucket(mod,r[i]);

if ( ci != 1 )

for ( i = 0; i < nb; i++ ) nd_mul_c(mod,rd[i],ci);

return rd;

}

ND btog_one(NODE ti,ND *p,int nb,int mod)

{

PGeoBucket r;

int i,ci,j;

NODE t,s;

ND m,tp;

ND pi,rd;

P c;

r = create_pbucket();

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

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

if ( ARG0(s) ) {

m = mdptond((DP)ARG2(s));

ptomp(mod,(P)HCQ(m),&c);

if ( ci = ((MQ)c)->cont ) {

HCM(m) = ci;

pi = p[j=QTOS((Q)ARG1(s))];

if ( !pi ) {

pi = nd_load_mod(j);

tp = nd_mul_nm(mod,BDY(m),pi);

nd_free(pi);

add_pbucket(mod,r,tp);

} else {

tp = nd_mul_nm(mod,BDY(m),pi);

add_pbucket(mod,r,tp);

}

ci = 1;

} else {

ptomp(mod,(P)ARG3(s),&c); ci = ((MQ)c)->cont;

ci = invm(ci,mod);

}

rd = normalize_pbucket(mod,r);

free_pbucket(r);

if ( ci != 1 ) nd_mul_c(mod,rd,ci);

return rd;

}

MAT nd_btog(LIST f,LIST v,int mod,struct order_spec *ord,LIST tlist,MAT *rp)

{

int i,j,n,m,nb,pi0,pi1,nvar;

VL fv,tv,vv;

NODE permtrace,perm,trace,intred,ind,t,pi,ti;

ND **p;

ND *c;

ND u;

P inv;

MAT mat;

parse_nd_option(current_option);

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

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

switch ( ord->id ) {

case 1:

if ( ord->nv != nvar )

error("nd_check : invalid order specification");

break;

default:

break;

}

nd_init_ord(ord);

#if 0

nd_bpe = QTOS((Q)ARG7(BDY(tlist)));

#else

nd_bpe = 32;

#endif

nd_setup_parameters(nvar,0);

permtrace = BDY((LIST)ARG2(BDY(tlist)));

intred = BDY((LIST)ARG3(BDY(tlist)));

ind = BDY((LIST)ARG4(BDY(tlist)));

perm = BDY((LIST)BDY(permtrace)); trace =NEXT(permtrace);

for ( i = length(perm)-1, t = trace; t; t = NEXT(t) ) {

j = QTOS((Q)BDY(BDY((LIST)BDY(t))));

if ( j > i ) i = j;

}

n = i+1;

nb = length(BDY(f));

p = (ND **)MALLOC(n*sizeof(ND *));

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

pi = BDY((LIST)BDY(t));

pi0 = QTOS((Q)ARG0(pi)); pi1 = QTOS((Q)ARG1(pi));

p[pi0] = c = (ND *)MALLOC(nb*sizeof(ND));

ptomp(mod,(P)ARG2(pi),&inv);

u = ptond(CO,vv,(P)ONE);

HCM(u) = ((MQ)inv)->cont;

c[pi1] = u;

}

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

printf("%d ",i); fflush(stdout);

ti = BDY((LIST)BDY(t));

p[j=QTOS((Q)ARG0(ti))] = btog(BDY((LIST)ARG1(ti)),p,nb,mod);

if ( j == 441 )

printf("afo");

}

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

printf("%d ",i); fflush(stdout);

ti = BDY((LIST)BDY(t));

p[j=QTOS((Q)ARG0(ti))] = btog(BDY((LIST)ARG1(ti)),p,nb,mod);

if ( j == 441 )

printf("afo");

}

m = length(ind);

MKMAT(mat,nb,m);

for ( j = 0, t = ind; j < m; j++, t = NEXT(t) )

for ( i = 0, c = p[QTOS((Q)BDY(t))]; i < nb; i++ )

BDY(mat)[i][j] = ndtodp(mod,c[i]);

return mat;

}

VECT nd_btog_one(LIST f,LIST v,int mod,struct order_spec *ord,

LIST tlist,int pos,MAT *rp)

{

int i,j,n,m,nb,pi0,pi1,nvar;

VL fv,tv,vv;

NODE permtrace,perm,trace,intred,ind,t,pi,ti;

ND *p;

ND *c;

ND u;

P inv;

VECT vect;

parse_nd_option(current_option);

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

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

switch ( ord->id ) {

case 1:

if ( ord->nv != nvar )

error("nd_check : invalid order specification");

break;

default:

break;

}

nd_init_ord(ord);

#if 0

nd_bpe = QTOS((Q)ARG7(BDY(tlist)));

#else

nd_bpe = 32;

#endif

nd_setup_parameters(nvar,0);

permtrace = BDY((LIST)ARG2(BDY(tlist)));

intred = BDY((LIST)ARG3(BDY(tlist)));

ind = BDY((LIST)ARG4(BDY(tlist)));

perm = BDY((LIST)BDY(permtrace)); trace =NEXT(permtrace);

for ( i = length(perm)-1, t = trace; t; t = NEXT(t) ) {

j = QTOS((Q)BDY(BDY((LIST)BDY(t))));

if ( j > i ) i = j;

}

n = i+1;

nb = length(BDY(f));

p = (ND *)MALLOC(n*sizeof(ND *));

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

pi = BDY((LIST)BDY(t));

pi0 = QTOS((Q)ARG0(pi)); pi1 = QTOS((Q)ARG1(pi));

if ( pi1 == pos ) {

ptomp(mod,(P)ARG2(pi),&inv);

u = ptond(CO,vv,(P)ONE);

HCM(u) = ((MQ)inv)->cont;

p[pi0] = u;

}

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

printf("%d ",i); fflush(stdout);

ti = BDY((LIST)BDY(t));

p[j=QTOS((Q)ARG0(ti))] = btog_one(BDY((LIST)ARG1(ti)),p,nb,mod);

if ( Demand ) {

nd_save_mod(p[j],j); nd_free(p[j]); p[j] = 0;

}

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

printf("%d ",i); fflush(stdout);

ti = BDY((LIST)BDY(t));

p[j=QTOS((Q)ARG0(ti))] = btog_one(BDY((LIST)ARG1(ti)),p,nb,mod);

if ( Demand ) {

nd_save_mod(p[j],j); nd_free(p[j]); p[j] = 0;

}

m = length(ind);

MKVECT(vect,m);

for ( j = 0, t = ind; j < m; j++, t = NEXT(t) ) {

u = p[QTOS((Q)BDY(t))];

if ( !u ) {

u = nd_load_mod(QTOS((Q)BDY(t)));

BDY(vect)[j] = ndtodp(mod,u);

nd_free(u);

} else

BDY(vect)[j] = ndtodp(mod,u);

}

return vect;

}

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