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.225 and 1.237

version 1.225, 2016/03/31 02:42:43

version 1.237, 2017/04/09 02:23:12

Line 1

/* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.224 2016/03/31 01:40:10 noro Exp $ */

/* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.236 2017/03/27 09:05:46 noro Exp $ */

#include "nd.h"

Line 60 static int nd_module_rank,nd_poly_weight_len;

static int *nd_poly_weight,*nd_module_weight;

static NODE nd_tracelist;

static NODE nd_alltracelist;

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

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

static int *nd_gbblock;

static NODE nd_nzlist,nd_check_splist;

static int nd_splist;

static int *nd_sugarweight;

static int nd_f4red,nd_rank0;

NumberField get_numberfield();

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

Line 93 ND ndgztond(ND p);

Line 95 ND ndgztond(ND p);

void Pdp_set_weight(NODE,VECT *);

void Pox_cmo_rpc(NODE,Obj *);

extern int Denominator,DP_Multiple;

ND nd_add_lf(ND p1,ND p2);

void nd_mul_c_lf(ND p,GZ mul);

void ndv_mul_c_lf(NDV p,GZ mul);

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

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

int nd_gauss_elim_lf(mpz_t **mat0,int *sugar,int row,int col,int *colstat);

NODE nd_f4_lf_trace_main(int m,int **indp);

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

extern int lf_lazy;

extern GZ current_mod_lf;

extern int Denominator,DP_Multiple,MaxDeg;

#define BLEN (8*sizeof(unsigned long))

typedef struct matrix {

Line 173 INLINE int nd_length(ND p)

Line 187 INLINE int nd_length(ND p)

}

extern int dp_negative_weight;

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

{

UINT u1,u2;

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

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

if ( nd_module && (MPOS(d1) != MPOS(d2)) ) return 0;

if ( TD(d1) < TD(d2) ) return 0;

if ( !dp_negative_weight && TD(d1) < TD(d2) ) return 0;

#if USE_UNROLL

switch ( nd_bpe ) {

case 3:

Line 459 int ndl_weight(UINT *d)

Line 475 int ndl_weight(UINT *d)

return t;

}

/* for sugarweight */

int ndl_weight2(UINT *d)

{

int t,u;

int i,j;

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

u = GET_EXP(d,i);

t += nd_sugarweight[i]*u;

}

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

t += current_module_weight_vector[MPOS(d)];

return t;

}

void ndl_weight_mask(UINT *d)

{

UINT t,u;

Line 620 int ndl_composite_compare(UINT *d1,UINT *d2)

Line 652 int ndl_composite_compare(UINT *d1,UINT *d2)

else if ( nd_work_vector[j] < 0 ) return -1;

break;

case 2:

end = start+len;

for ( j = start; j < end; j++ )

if ( nd_work_vector[j] > 0 ) return 1;

else if ( nd_work_vector[j] < 0 ) return -1;

Line 658 int ndl_module_weight_compare(UINT *d1,UINT *d2)

Line 691 int ndl_module_weight_compare(UINT *d1,UINT *d2)

s = 0;

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

s += (GET_EXP(d1,j)-GET_EXP(d2,j))*nd_poly_weight[j];

s += nd_module_weight[MPOS(d1)-1]-nd_module_weight[MPOS(d2)-1];

if ( MPOS(d1) >= 1 && MPOS(d2) >= 1 ) {

s += nd_module_weight[MPOS(d1)-1]-nd_module_weight[MPOS(d2)-1];

}

if ( s > 0 ) return 1;

else if ( s < 0 ) return -1;

else return 0;

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

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

if ( !p1 ) return p2;

else if ( !p2 ) return p1;

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

else if ( mod == -2 ) return nd_add_lf(p1,p2);

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

else {

can = 0;

Line 1343 ND nd_add_sf(ND p1,ND p2)

Line 1379 ND nd_add_sf(ND p1,ND p2)

}

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

{

int c,c1,c2;

Line 1353 ND nd_reduce2(int mod,ND d,ND g,NDV p,NM mul,NDC dn,Ob

Line 1390 ND nd_reduce2(int mod,ND d,ND g,NDV p,NM mul,NDC dn,Ob

if ( mod == -1 ) {

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

*divp = (Obj)ONE;

} else if ( mod == -2 ) {

GZ inv,t;

divlf(ONEGZ,HCZ(p),&inv);

chsgnlf(HCZ(g),&t);

mullf(inv,t,&CZ(mul));

*divp = (Obj)ONE;

} else if ( mod ) {

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

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

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

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

sugar0 = sugar = SG(g);

n = NV(g);

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

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

if ( d )

for ( tail = BDY(d); NEXT(tail); tail = NEXT(tail) );

for ( ; g; ) {

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

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

bucket = create_pbucket();

add_pbucket(mod,bucket,g);

d = 0;

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

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

while ( 1 ) {

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

if ( mod > 0 || mod == -1 )

hindex = head_pbucket(mod,bucket);

else if ( mod == -2 )

hindex = head_pbucket_lf(bucket);

else

hindex = head_pbucket_q(bucket);

if ( hindex < 0 ) {

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

if ( d ) SG(d) = sugar;

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

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

p = ps[index];

if ( mod == -1 )

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

else if ( mod ) {

else if ( mod == -2 ) {

GZ inv,t;

divlf(ONEGZ,HCZ(p),&inv);

chsgnlf(HCZ(g),&t);

mullf(inv,t,&CZ(mul));

} else if ( mod ) {

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

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

} else {

Line 1602 again:

Line 1655 again:

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

else

r = (NDV)BDY(t);

if ( m ) ndv_mod(m,r);

d = ndvtond(m,r);

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

if ( !stat ) {

Line 1835 int head_pbucket_q(PGeoBucket g)

Line 1889 int head_pbucket_q(PGeoBucket g)

}

int head_pbucket_lf(PGeoBucket g)

{

int j,i,c,k,nv;

GZ sum,t;

ND gi,gj;

k = g->m;

while ( 1 ) {

j = -1;

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

if ( !(gi = g->body[i]) ) continue;

if ( j < 0 ) {

j = i;

gj = g->body[j];

sum = HCZ(gj);

} else {

nv = NV(gi);

c = DL_COMPARE(HDL(gi),HDL(gj));

if ( c > 0 ) {

if ( sum ) HCZ(gj) = sum;

else g->body[j] = nd_remove_head(gj);

j = i;

gj = g->body[j];

sum = HCZ(gj);

} else if ( c == 0 ) {

addlf(sum,HCZ(gi),&t);

sum = t;

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

}

if ( j < 0 ) return -1;

else if ( sum ) {

HCZ(gj) = sum;

return j;

} else

g->body[j] = nd_remove_head(gj);

}

ND normalize_pbucket(int mod,PGeoBucket g)

{

int i;

Line 2003 NODE nd_gb(int m,int ishomo,int checkonly,int gensyz,i

Line 2097 NODE nd_gb(int m,int ishomo,int checkonly,int gensyz,i

while ( d ) {

again:

l = nd_minp(d,&d);

if ( MaxDeg > 0 && SG(l) > MaxDeg ) break;

if ( SG(l) != sugar ) {

if ( ishomo ) {

diag_count = 0;

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

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

while ( d ) {

again:

l = nd_minp(d,&d);

if ( MaxDeg > 0 && SG(l) > MaxDeg ) break;

if ( SG(l) != sugar ) {

#if 1

if ( ishomo ) {

Line 2358 again:

Line 2454 again:

FREENDP(l);

}

if ( nd_nalg ) {

print_eg("monic",&eg_monic);

if ( DP_Print ) {

print_eg("invdalg",&eg_invdalg);

print_eg("monic",&eg_monic);

print_eg("le",&eg_le);

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

Line 2526 ND_pairs nd_newpairs( NODE g, int t )

Line 2624 ND_pairs nd_newpairs( NODE g, int t )

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

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

SG(r) = MAX(s,ts) + TD(LCM(r));

/* experimental */

if ( nd_sugarweight )

r->sugar2 = ndl_weight2(r->lcm);

}

if ( r0 ) NEXT(r) = 0;

return r0;

}

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

ND_pairs nd_ipairtospair(NODE ipair)

{

int s1,s2;

NODE tn,t;

ND_pairs r,r0;

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

NEXTND_pairs(r0,r);

tn = BDY((LIST)BDY(t));

r->i1 = QTOS((Q)ARG0(tn));

r->i2 = QTOS((Q)ARG1(tn));

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

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

s2 = SG(nd_psh[r->i2])-TD(DL(nd_psh[r->i2]));

SG(r) = MAX(s1,s2) + TD(LCM(r));

/* experimental */

if ( nd_sugarweight )

r->sugar2 = ndl_weight2(r->lcm);

}

if ( r0 ) NEXT(r) = 0;

return r0;

}

/* kokokara */

ND_pairs crit_B( ND_pairs d, int s )

Line 2543 ND_pairs crit_B( ND_pairs d, int s )

Line 2668 ND_pairs crit_B( ND_pairs d, int s )

t = DL(nd_psh[s]);

prev = 0;

head = cur = d;

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

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

while ( cur ) {

tl = cur->lcm;

if ( ndl_reducible(tl,t) ) {

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

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

NEXT(m) = 0;

return m;

}

s = SG(m);

if ( !NoSugar ) {

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

if ( nd_sugarweight ) {

if ( (SG(p) < s)

s = m->sugar2;

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

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

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

if ( (p->sugar2 < s)

}

|| ((p->sugar2 == s) && (DL_COMPARE(LCM(p),LCM(m)) < 0)) ) {

ml = l; m = p; s = m->sugar2;

}

} else {

s = SG(m);

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

if ( (SG(p) < s)

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

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

}

} else {

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

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

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

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

int msugar,i;

ND_pairs t,dm0,dm,dr0,dr;

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

if ( nd_sugarweight ) {

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

for ( msugar = d->sugar2, t = NEXT(d); t; t = NEXT(t) )

dm0 = 0; dr0 = 0;

if ( t->sugar2 < msugar ) msugar = t->sugar2;

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

dm0 = 0; dr0 = 0;

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

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

if ( dm0 ) NEXT(dm) = t;

if ( i < nd_f4_nsp && t->sugar2 == msugar ) {

else dm0 = t;

if ( dm0 ) NEXT(dm) = t;

dm = t;

else dm0 = t;

i++;

dm = t;

} else {

i++;

if ( dr0 ) NEXT(dr) = t;

} else {

else dr0 = t;

if ( dr0 ) NEXT(dr) = t;

dr = t;

else dr0 = t;

}

dr = t;

}

} else {

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

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

dm0 = 0; dr0 = 0;

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

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

if ( dm0 ) NEXT(dm) = t;

else dm0 = t;

dm = t;

i++;

} else {

if ( dr0 ) NEXT(dr) = t;

else dr0 = t;

dr = t;

}

NEXT(dm) = 0;

if ( dr0 ) NEXT(dr) = 0;

*prest = dr0;

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

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

nd_ps[nd_psn] = a;

if ( aq ) {

nd_ps_trace[nd_psn] = aq;

if ( !nd_vc ) nd_ps_gz[nd_psn] = ndvtondvgz(aq);

if ( !m ) {

register_hcf(aq);

if ( !nd_vc ) nd_ps_gz[nd_psn] = ndvtondvgz(aq);

register_hcf(aq);

} else if ( m == -2 ) {

/* do nothing */

} else

error("ndv_newps : invalud modulus");

nd_bound[nd_psn] = ndv_compute_bound(aq);

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

} else {

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

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

if ( nd_demand ) {

if ( aq ) {

ndv_save(nd_ps_trace[nd_psn],nd_psn);

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

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

nd_ps_trace[nd_psn] = 0;

} else {

Line 2834 int ndv_setup(int mod,int trace,NODE f,int dont_sort,i

Line 2991 int ndv_setup(int mod,int trace,NODE f,int dont_sort,i

nd_tracelist = 0;

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

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

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

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

Line 2867 int ndv_setup(int mod,int trace,NODE f,int dont_sort,i

Line 3024 int ndv_setup(int mod,int trace,NODE f,int dont_sort,i

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

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

if ( trace ) {

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

if ( mod == -2 ) {

if ( !nd_vc ) nd_ps_gz[i] = ndvtondvgz(a);

/* over a large finite field */

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

/* trace = small modulus */

register_hcf(a);

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

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

ndv_mod(-2,a);

ndv_mod(mod,am);

if ( !dont_removecont) ndv_removecont(-2,a);

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

am = nd_ps[i] = ndv_dup(trace,w[i].p);

return 0;

ndv_mod(trace,am);

ndv_removecont(mod,am);

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

return 0;

ndv_removecont(trace,am);

} else {

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

if ( !nd_vc ) 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].p);

if ( !mod && !nd_vc ) nd_ps_gz[i] = ndvtondvgz(a);

Line 2894 int ndv_setup(int mod,int trace,NODE f,int dont_sort,i

Line 3064 int ndv_setup(int mod,int trace,NODE f,int dont_sort,i

if ( nd_demand ) {

if ( trace ) {

ndv_save(nd_ps_trace[i],i);

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

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

nd_ps_trace[i] = 0;

} else {

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

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

LIST f1,f2;

struct order_spec *current_spec;

VECT obj,obj0;

Obj tmp;

VECT tmp;

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

for ( nalg = 0, tv = av; tv; tv = NEXT(tv), nalg++);

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

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

/* simplification, making polynomials monic */

setfield_dalg(alist);

obj_algtodalg(f,&f1);

obj_algtodalg((Obj)f,(Obj *)&f1);

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

initd(ord); ptod(vv,vv,(P)BDY(t),&d);

hc = (DAlg)BDY(d)->c;

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

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

}

initd(ord); dtop(vv,vv,d,&poly); BDY(f) = (pointer)poly;

}

obj_dalgtoalg(f1,&f);

obj_dalgtoalg((Obj)f1,(Obj *)&f);

/* append alg vars to the var list */

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

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

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

}

MKLIST(f1,t);

*alistp = alist;

algobjtorat(f1,f1p);

algobjtorat((Obj)f1,(Obj *)f1p);

/* creating a new weight vector */

prev_weight_vector_obj = obj0 = current_dl_weight_vector_obj;

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

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

NODE s,t,u0,u;

P p;

VL tv;

Obj obj,tmp;

Obj obj;

VECT tmp;

NODE arg;

u0 = 0;

Line 3046 void nd_gr(LIST f,LIST v,int m,int homo,int retdp,int

Line 3218 void nd_gr(LIST f,LIST v,int m,int homo,int retdp,int

ndv_alloc = 0;

#endif

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

if ( m && nd_vc )

error("nd_{gr,f4} : computation over Fp(X) is unsupported. Use dp_gr_mod_main().");

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

switch ( ord->id ) {

case 1:

Line 3138 void nd_gr(LIST f,LIST v,int m,int homo,int retdp,int

Line 3312 void nd_gr(LIST f,LIST v,int m,int homo,int retdp,int

}

return;

}

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

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

if ( !x ) {

*rp = 0; return;

}

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

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

static int afo=0;

afo++;

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

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

CM(mul) = 1;

tail = 0;

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

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

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

}

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

else {

BDY(r) = m;

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

if ( mod > 0 || mod == -1 ) {

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

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

nd_mul_c(mod,rm,c);

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

nd_mul_c(mod,rm,c);

} else {

GZ t,u;

chsgnlf(HCZ(r),&t);

divlf(t,HCZ(rm),&u);

nd_mul_c_lf(rm,u);

}

r = nd_add(mod,r,rm);

}

if ( tail ) NEXT(tail) = 0;

d = nd_add(mod,d,r);

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

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

Q jq,bpe;

nd_module = 0;

nd_lf = 0;

parse_nd_option(current_option);

if ( nd_lf ) {

if ( f4 )

nd_f4_lf_trace(f,v,trace,homo,ord,rp);

else

error("nd_gr_trace is not implemented yet over a large finite field");

return;

}

if ( DP_Multiple )

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

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

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

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

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

}

if ( MaxDeg > 0 ) nocheck = 1;

while ( 1 ) {

tl1 = tl2 = tl3 = tl4 = 0;

if ( Demand )

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

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

tl3 = nd_alltracelist; nd_alltracelist = 0;

} else tl3 = 0;

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

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

if ( nd_vc || nd_gentrace || nd_gensyz )

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

else

ret = nd_f4(0,1,0)!=0;

if ( nd_gentrace && nd_gensyz ) {

tl4 = nd_alltracelist; nd_alltracelist = 0;

} else tl4 = 0;

Line 3734 void ndl_print(UINT *dl)

Line 3928 void ndl_print(UINT *dl)

for ( i = 0; i < n; i++ ) printf(i==n-1?"%d":"%d,",GET_EXP(dl,i));

}

printf(">>");

if ( MPOS(dl) )

if ( nd_module && MPOS(dl) )

printf("*e%d",MPOS(dl));

}

Line 3789 void nd_removecont(int mod,ND p)

Line 3983 void nd_removecont(int mod,ND p)

N q,r;

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

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

else if ( mod == -2 ) {

GZ inv;

divlf(ONEGZ,HCZ(p),&inv);

nd_mul_c_lf(p,inv);

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

else {

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

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

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

v.len = n;

v.body = (pointer *)w;

for ( m = BDY(p), i = 0; i < n; m = NEXT(m), i++ ) w[i] = CQ(m);

Line 3813 void nd_removecont2(ND p1,ND p2)

Line 4011 void nd_removecont2(ND p1,ND p2)

n1 = nd_length(p1);

n2 = nd_length(p2);

n = n1+n2;

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

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

v.len = n;

v.body = (pointer *)w;

i = 0;

Line 3840 void ndv_removecont(int mod,NDV p)

Line 4038 void ndv_removecont(int mod,NDV p)

if ( mod == -1 )

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

else if ( mod )

else if ( mod == -2 ) {

GZ inv;

divlf(ONEGZ,HCZ(p),&inv);

ndv_mul_c_lf(p,inv);

} else if ( mod )

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

else {

len = p->len;

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

w = (P *)MALLOC(len*sizeof(P));

c = (Q *)ALLOCA(len*sizeof(Q));

c = (Q *)MALLOC(len*sizeof(Q));

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

ptozp(CP(m),1,&c[i],&w[i]);

all_p = all_p && !NUM(w[i]);

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

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

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

t = (NMV)MALLOC(nmv_adv);

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

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

CQ(mr) = CQ(m);

Line 3927 void nd_heu_nezgcdnpz(VL vl,P *pl,int m,int full,P *pr

Line 4129 void nd_heu_nezgcdnpz(VL vl,P *pl,int m,int full,P *pr

NODE l;

P h,gcd,t;

tpl = (P *)ALLOCA(m*sizeof(P));

tpl = (P *)MALLOC(m*sizeof(P));

tpl1 = (P *)ALLOCA(m*sizeof(P));

tpl1 = (P *)MALLOC(m*sizeof(P));

bcopy(pl,tpl,m*sizeof(P));

gcd = (P)ONE;

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

Line 3964 void removecont_array(P *p,int n,int full)

Line 4166 void removecont_array(P *p,int n,int full)

if ( all_q ) {

removecont_array_q((Q *)p,n);

} else {

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

c = (Q *)MALLOC(n*sizeof(Q));

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

w = (P *)MALLOC(n*sizeof(P));

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

ptozp(p[i],1,&c[i],&w[i]);

}

Line 3985 void removecont_array_q(Q *c,int n)

Line 4187 void removecont_array_q(Q *c,int n)

N qn,rn,gn;

Q *q,*r;

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

q = (Q *)MALLOC(n*sizeof(Q));

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

r = (Q *)MALLOC(n*sizeof(Q));

v.id = O_VECT; v.len = n; v.body = (pointer *)c;

igcdv_estimate(&v,&d0);

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

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

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

}

void nd_mul_c_lf(ND p,GZ mul)

{

NM m;

GZ c;

if ( !p ) return;

if ( UNIGZ(mul) ) return;

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

mullf(CZ(m),mul,&c); CZ(m) = c;

}

void nd_mul_c_q(ND p,P mul)

{

NM m;

Line 4092 UINT *ndv_compute_bound(NDV p)

Line 4306 UINT *ndv_compute_bound(NDV p)

if ( !p )

return 0;

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

d1 = (UINT *)MALLOC(nd_wpd*sizeof(UINT));

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

d2 = (UINT *)MALLOC(nd_wpd*sizeof(UINT));

len = LEN(p);

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

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

Line 4121 UINT *nd_compute_bound(ND p)

Line 4335 UINT *nd_compute_bound(ND p)

if ( !p )

return 0;

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

d1 = (UINT *)MALLOC(nd_wpd*sizeof(UINT));

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

d2 = (UINT *)MALLOC(nd_wpd*sizeof(UINT));

len = LEN(p);

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

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

Line 4155 int nd_get_exporigin(struct order_spec *ord)

Line 4369 int nd_get_exporigin(struct order_spec *ord)

/* module d[0]:weight d[1]:w0,...,d[nd_exporigin-2]:w(n-1) */

return ord->ord.block.length+1+nd_module;

case 3: case 259:

#if 0

error("nd_get_exporigin : composite order is not supported yet.");

#else

return 1+nd_module;

#endif

}

Line 4281 ND_pairs nd_reconstruct(int trace,ND_pairs d)

Line 4499 ND_pairs nd_reconstruct(int trace,ND_pairs d)

ndl_reconstruct(LCM(t),LCM(s),obpe,oepos);

}

old_red = (RHist *)ALLOCA(REDTAB_LEN*sizeof(RHist));

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

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

old_red[i] = nd_red[i];

nd_red[i] = 0;

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

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

if ( mod == -1 ) {

CM(m1) = HCM(p2); CM(m2) = _chsgnsf(HCM(p1));

} else if ( mod ) {

} else if ( mod > 0 ) {

CM(m1) = HCM(p2); CM(m2) = mod-HCM(p1);

} else if ( mod == -2 ) {

CZ(m1) = HCZ(p2); chsgnlf(HCZ(p1),&CZ(m2));

} else if ( nd_vc ) {

ezgcdpz(nd_vc,HCP(p1),HCP(p2),&gp);

divsp(nd_vc,HCP(p2),gp,&CP(m1));

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

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

}

void ndv_mul_c_lf(NDV p,GZ mul)

{

NMV m;

GZ c;

int len,i;

if ( !p ) return;

len = LEN(p);

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

mullf(CZ(m),mul,&c); CZ(m) = c;

}

void ndv_mul_c_q(NDV p,Q mul)

{

NMV m;

Line 4463 ND weyl_ndv_mul_nm(int mod,NM m0,NDV p) {

Line 4696 ND weyl_ndv_mul_nm(int mod,NM m0,NDV p) {

d0 = DL(m0);

l = LEN(p);

for ( i = 0, tlen = 1; i < n2; i++ ) tlen *= (GET_EXP(d0,n2+i)+1);

tab = (NM *)ALLOCA(tlen*sizeof(NM));

tab = (NM *)MALLOC(tlen*sizeof(NM));

psum = (NM *)ALLOCA(tlen*sizeof(NM));

psum = (NM *)MALLOC(tlen*sizeof(NM));

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

m1 = (NMV)(((char *)BDY(p))+nmv_adv*(l-1));

for ( i = l-1; i >= 0; i--, NMV_PREV(m1) ) {

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

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

}

min = MIN(k,l);

if ( mod ) {

ctab = (UINT *)ALLOCA((min+1)*sizeof(UINT));

ctab = (UINT *)MALLOC((min+1)*sizeof(UINT));

mkwcm(k,l,mod,ctab);

} else {

ctab_q = (Q *)ALLOCA((min+1)*sizeof(Q));

ctab_q = (Q *)MALLOC((min+1)*sizeof(Q));

mkwc(k,l,ctab_q);

}

for ( j = min; j >= 0; j-- ) {

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

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

if ( !p ) return 0;

else if ( do_weyl )

if ( mod == -1 )

if ( mod < 0 )

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

else

return weyl_ndv_mul_nm(mod,m0,p);

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

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

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

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

}

} else if ( mod == -2 ) {

GZ cl;

cl = CZ(m0);

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

NEXTNM(mr0,mr);

mullf(CZ(m),cl,&CZ(mr));

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

}

} else if ( mod ) {

c = CM(m0);

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

Line 4697 ND nd_quo(int mod,PGeoBucket bucket,NDV d)

Line 4938 ND nd_quo(int mod,PGeoBucket bucket,NDV d)

else {

nv = NV(d);

mq0 = 0;

tm = (NMV)ALLOCA(nmv_adv);

tm = (NMV)MALLOC(nmv_adv);

while ( 1 ) {

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

if ( mod > 0 || mod == -1 )

hindex = head_pbucket(mod,bucket);

else if ( mod == -2 )

hindex = head_pbucket_lf(bucket);

else

hindex = head_pbucket_q(bucket);

if ( hindex < 0 ) break;

p = bucket->body[hindex];

NEXTNM(mq0,mq);

Line 4742 void ndv_realloc(NDV p,int obpe,int oadv,EPOS oepos)

Line 4988 void ndv_realloc(NDV p,int obpe,int oadv,EPOS oepos)

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

t = (NMV)MALLOC(nmv_adv);

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

CQ(t) = CQ(m);

for ( k = 0; k < nd_wpd; k++ ) DL(t)[k] = 0;

Line 4782 NDV ndv_dup(int mod,NDV p)

Line 5028 NDV ndv_dup(int mod,NDV p)

if ( !p ) return 0;

len = LEN(p);

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

m0 = m = (NMV)((mod>0 || mod==-1)?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) = CQ(t);

Line 4824 NDV ndv_symbolic(int mod,NDV p)

Line 5070 NDV ndv_symbolic(int mod,NDV p)

if ( !p ) return 0;

len = LEN(p);

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

m0 = m = (NMV)((mod>0||mod==-1)?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;

Line 4890 void ndv_mod(int mod,NDV p)

Line 5136 void ndv_mod(int mod,NDV p)

if ( mod == -1 )

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

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

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

if ( gfs ) {

CM(d) = r;

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

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

CM(d) = r;

NMV_ADV(d);

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

dlen++;

NMV_ADV(d);

dlen++;

}

else if ( mod == -2 )

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

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

if ( gfs ) {

lmtolf(gfs,&CZ(d));

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

NMV_ADV(d);

dlen++;

}

else

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

if ( nd_vc ) {

Line 4943 void pltozpl(LIST l,Q *cont,LIST *pp)

Line 5201 void pltozpl(LIST l,Q *cont,LIST *pp)

LIST r;

nd = BDY(l); n = length(nd);

pl = (P *)ALLOCA(n*sizeof(P));

pl = (P *)MALLOC(n*sizeof(P));

cl = (Q *)ALLOCA(n*sizeof(P));

cl = (Q *)MALLOC(n*sizeof(P));

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

ptozp((P)BDY(nd),1,&cl[i],&dmy);

qltozl(cl,n,&dvr);

Line 5009 ND ptond(VL vl,VL dvl,P p)

Line 5267 ND ptond(VL vl,VL dvl,P p)

return r;

} else {

for ( dc = DC(p), k = 0; dc; dc = NEXT(dc), k++ );

w = (DCP *)ALLOCA(k*sizeof(DCP));

w = (DCP *)MALLOC(k*sizeof(DCP));

for ( dc = DC(p), j = 0; j < k; dc = NEXT(dc), j++ ) w[j] = dc;

for ( i = 0, tvl = dvl, v = VR(p);

tvl && tvl->v != v; tvl = NEXT(tvl), i++ );

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

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

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

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

if ( mod == -1 ) {

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

} else if ( mod ) {

} else if ( mod == -2 ) {

c = gztoz(CZ(m));

} else if ( mod > 0 ) {

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

} else

c = CP(m);

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

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

if ( !p ) return 0;

else {

a = (P *)ALLOCA((rank+1)*sizeof(P));

a = (P *)MALLOC((rank+1)*sizeof(P));

for ( i = 0; i <= rank; i++ ) a[i] = 0;

len = LEN(p);

n = NV(p);

Line 5126 NDV ndtondv(int mod,ND p)

Line 5386 NDV ndtondv(int mod,ND p)

if ( !p ) return 0;

len = LEN(p);

if ( mod )

if ( mod > 0 || mod == -1 )

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

else

m0 = m = MALLOC(len*nmv_adv);

Line 5247 NODE ndv_reducebase(NODE x,int *perm)

Line 5507 NODE ndv_reducebase(NODE x,int *perm)

NODE t,t0;

len = length(x);

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

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

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

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

}

Line 5552 int nd_to_vect_q(UINT *s0,int n,ND d,Q *r)

Line 5812 int nd_to_vect_q(UINT *s0,int n,ND d,Q *r)

return i;

}

int nd_to_vect_lf(UINT *s0,int n,ND d,mpz_t *r)

{

NM m;

UINT *t,*s;

int i;

for ( i = 0; i < n; i++ ) { mpz_init(r[i]); mpz_set_ui(r[i],0); }

for ( i = 0, s = s0, m = BDY(d); m; m = NEXT(m) ) {

t = DL(m);

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

mpz_set(r[i],BDY(CZ(m)));

}

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

return i;

}

unsigned long *nd_to_vect_2(UINT *s0,int n,int *s0hash,ND p)

{

NM m;

Line 5579 int nd_nm_to_vect_2(UINT *s0,int n,int *s0hash,NDV p,N

Line 5855 int nd_nm_to_vect_2(UINT *s0,int n,int *s0hash,NDV p,N

d = DL(m);

len = LEN(p);

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

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

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

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

h = ndl_hash_value(t);

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

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

p = nd_ps[pair->index];

len = LEN(p);

r = (Q *)CALLOC(n,sizeof(Q));

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

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

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

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

Line 5889 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,int *s0hash,NM_ind_pair pair)

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

{

NM m;

NMV mr;

Line 5628 struct oEGT eg0,eg1;

Line 5904 struct oEGT eg0,eg1;

m = pair->mul;

d = DL(m);

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

if ( trace )

p = nd_demand?nd_ps_trace_sym[pair->index]:nd_ps_trace[pair->index];

else

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

len = LEN(p);

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

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

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

v = (unsigned int *)MALLOC(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);

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

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

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

if ( i == col ) return maxrs;

hmag = p_mag((P)svect[i])*nd_scale;

cvect = (Q *)ALLOCA(col*sizeof(Q));

cvect = (Q *)MALLOC(col*sizeof(Q));

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

ivect = imat[i];

k = ivect->head;

Line 5927 int ndv_reduce_vect_sf(int m,UINT *svect,int col,IndAr

Line 6207 int ndv_reduce_vect_sf(int m,UINT *svect,int col,IndAr

maxrs = 0;

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

ivect = imat[i];

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

k = ivect->head;

if ( c = svect[k] ) {

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

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

Line 5961 int ndv_reduce_vect_sf(int m,UINT *svect,int col,IndAr

Line 6241 int ndv_reduce_vect_sf(int m,UINT *svect,int col,IndAr

return maxrs;

}

ND nd_add_lf(ND p1,ND p2)

{

int n,c,can;

ND r;

NM m1,m2,mr0,mr,s;

GZ t;

if ( !p1 ) return p2;

else if ( !p2 ) return p1;

else {

can = 0;

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

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

switch ( c ) {

case 0:

addlf(CZ(m1),CZ(m2),&t);

s = m1; m1 = NEXT(m1);

if ( t ) {

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

} else {

can += 2; FREENM(s);

}

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

break;

case 1:

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

break;

case -1:

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

break;

}

if ( !mr0 )

if ( m1 ) mr0 = m1;

else if ( m2 ) mr0 = m2;

else return 0;

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

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

else NEXT(mr) = 0;

BDY(p1) = mr0;

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

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

FREEND(p2);

return p1;

}

int ndv_reduce_vect_lf(mpz_t *svect,int trace,int col,IndArray *imat,NM_ind_pair *rp0,int nred)

{

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

mpz_t c,mc,c1;

IndArray ivect;

unsigned char *ivc;

unsigned short *ivs;

unsigned int *ivi;

NDV redv;

NMV mr;

NODE rp;

int maxrs;

maxrs = 0;

lf_lazy = 1;

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

ivect = imat[i];

k = ivect->head;

mpz_mod(svect[k],svect[k],BDY(current_mod_lf));

if ( mpz_sgn(svect[k]) ) {

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

mpz_neg(svect[k],svect[k]);

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

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

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;

mpz_addmul(svect[pos],svect[k],BDY(CZ(mr)));

}

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;

mpz_addmul(svect[pos],svect[k],BDY(CZ(mr)));

}

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;

mpz_addmul(svect[pos],svect[k],BDY(CZ(mr)));

}

break;

}

mpz_set_ui(svect[k],0);

}

lf_lazy=0;

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

mpz_mod(svect[i],svect[i],BDY(current_mod_lf));

}

return maxrs;

}

int nd_gauss_elim_lf(mpz_t **mat0,int *sugar,int row,int col,int *colstat)

{

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

mpz_t a,a1,inv;

mpz_t *t,*pivot,*pk;

mpz_t **mat;

struct oEGT eg0,eg1,eg_forward,eg_mod,eg_back;

int size,size1;

mpz_init(inv);

mpz_init(a);

mat = (mpz_t **)mat0;

size = 0;

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

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

mpz_mod(mat[i][j],mat[i][j],BDY(current_mod_lf));

}

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

if ( mpz_sgn(mat[i][j]) )

break;

if ( i == row ) {

colstat[j] = 0;

continue;

} else

colstat[j] = 1;

if ( i != rank ) {

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

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

}

pivot = mat[rank];

s = sugar[rank];

mpz_invert(inv,pivot[j],BDY(current_mod_lf));

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

if ( mpz_sgn(*pk) ) {

mpz_mul(a,*pk,inv); mpz_mod(*pk,a,BDY(current_mod_lf));

}

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

t = mat[i];

if ( mpz_sgn(t[j]) ) {

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

mpz_neg(a,t[j]);

red_by_vect_lf(t+j,pivot+j,a,col-j);

}

rank++;

}

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

if ( colstat[j] ) {

pivot = mat[l];

s = sugar[l];

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

mpz_mod(pivot[k],pivot[k],BDY(current_mod_lf));

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

t = mat[i];

if ( mpz_sgn(t[j]) ) {

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

mpz_neg(a,t[j]);

red_by_vect_lf(t+j,pivot+j,a,col-j);

}

l--;

}

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

if ( colstat[j] ) {

t = mat[l];

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

mpz_mod(t[k],t[k],BDY(current_mod_lf));

}

l++;

}

return rank;

}

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

{

int j,k,len;

Line 6047 NDV vect_to_ndv_gz(GZ *vect,int spcol,int col,int *rhe

Line 6506 NDV vect_to_ndv_gz(GZ *vect,int spcol,int col,int *rhe

{

int j,k,len;

UINT *p;

Q c;

GZ c;

NDV r;

NMV mr0,mr;

Line 6071 NDV vect_to_ndv_gz(GZ *vect,int spcol,int col,int *rhe

Line 6530 NDV vect_to_ndv_gz(GZ *vect,int spcol,int col,int *rhe

}

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

{

int j,k,len;

UINT *p;

mpz_t c;

NDV r;

NMV mr0,mr;

for ( j = 0, len = 0; j < spcol; j++ ) if ( mpz_sgn(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] ) {

c[0] = vect[k++][0];

if ( mpz_sgn(c) ) {

ndl_copy(p,DL(mr)); MPZTOGZ(c,CZ(mr)); 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 6128 int nd_symbolic_preproc(PGeoBucket bucket,int trace,UI

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

NM_ind_pair pair;

ND red;

NDV *ps;

static int afo;

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

if ( nd_demand )

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

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

h = nd_psh[index];

NEWNM(mul);

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

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

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

return 0;

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

MKNM_ind_pair(pair,mul,index,sugar);

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

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

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

return col;

}

NODE nd_f4(int m,int **indp)

NODE nd_f4(int m,int checkonly,int **indp)

{

int i,nh,stat,index;

int i,nh,stat,index,f4red;

NODE r,g,tn0,tn,node;

ND_pairs d,l,t,ll0,ll;

LIST l0,l1;

ND spol,red;

NDV nf,redv;

NM s0,s;

NODE rp0,srp0,nflist,nzlist;

NODE rp0,srp0,nflist,nzlist,nzlist_t;

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

UINT c;

UINT **spmat;

Line 6191 NODE nd_f4(int m,int **indp)

Line 6681 NODE nd_f4(int m,int **indp)

#endif

g = 0; d = 0;

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

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

if ( !nd_nzlist ) d = update_pairs(d,g,i,0);

g = update_base(g,i);

}

nzlist = 0;

while ( d ) {

nzlist_t = nd_nzlist;

f4red = 0;

while ( d || nzlist_t ) {

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

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

sugar = (int)ARG0(node);

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

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

if ( !tn ) {

nzlist_t = NEXT(nzlist_t);

continue;

}

if ( tn ) {

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

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

l = nd_ipairtospair(tn);

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

} else {

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

l = nd_minsugarp(d,&d);

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

sugar = nd_sugarweight?l->sugar2:SG(l);

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

if ( MaxDeg > 0 && sugar > MaxDeg ) break;

}

if ( tn ) {

if ( !ll0 ) ll0 = t;

else NEXT(ll) = t;

ll = t;

}

if ( ll0 ) NEXT(ll) = 0;

l = ll0;

} else l = 0;

}

bucket = create_pbucket();

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

if ( !stat ) {

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

if ( !nd_nzlist ) {

NEXT(t) = d; d = l;

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

d = nd_reconstruct(0,d);

NEXT(t) = d; d = l;

d = nd_reconstruct(0,d);

}

continue;

}

if ( bucket->m < 0 ) continue;

Line 6242 NODE nd_f4(int m,int **indp)

Line 6727 NODE nd_f4(int m,int **indp)

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

sugar,eg_f4.exectime+eg_f4.gctime);

nflist = nd_f4_red(m,l,0,s0vect,col,rp0,nd_gentrace?&ll:0);

if ( checkonly && nflist ) return 0;

/* adding new bases */

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

nf = (NDV)BDY(r);

Line 6255 NODE nd_f4(int m,int **indp)

Line 6741 NODE nd_f4(int m,int **indp)

nf = ndtondv(m,nf1);

}

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

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

if ( !nd_nzlist ) d = update_pairs(d,g,nh,0);

g = update_base(g,nh);

}

if ( DP_Print ) {

fprintf(asir_out,"f4red=%d,gblen=%d,",f4red,length(g)); fflush(asir_out);

}

if ( nd_gentrace ) {

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

NEXTNODE(tn0,tn);

Line 6269 NODE nd_f4(int m,int **indp)

Line 6758 NODE nd_f4(int m,int **indp)

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

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

}

if ( nd_nzlist ) nzlist_t = NEXT(nzlist_t);

f4red++;

if ( nd_f4red && f4red >= nd_f4red ) break;

if ( nd_rank0 && !nflist ) break;

}

if ( nd_gentrace ) {

MKLIST(l0,reverse_node(nzlist));

Line 6311 NODE nd_f4_trace(int m,int **indp)

Line 6804 NODE nd_f4_trace(int m,int **indp)

get_eg(&eg0);

l = nd_minsugarp(d,&d);

sugar = SG(l);

if ( MaxDeg > 0 && sugar > MaxDeg ) break;

bucket = create_pbucket();

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

if ( !stat ) {

Line 6381 NODE nd_f4_trace(int m,int **indp)

Line 6875 NODE nd_f4_trace(int m,int **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;

}

int rref(matrix mat,int *sugar)

{

int row,col,i,j,k,l,s,wcol,wj;

Line 6566 void red_by_vect_2(matrix mat,int *sugar,unsigned long

Line 6957 void red_by_vect_2(matrix mat,int *sugar,unsigned long

row = mat->row;

col = mat->col;

wcol = (col+BLEN-1)/BLEN;

pos = (int *)ALLOCA(wcol*sizeof(int));

pos = (int *)MALLOC(wcol*sizeof(int));

bzero(pos,wcol*sizeof(int));

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

if ( v[i] ) pos[j++] = i;;

Line 6606 init_eg(&eg_search);

Line 6997 init_eg(&eg_search);

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

nred = length(rp0);

mat = alloc_matrix(nsp,col);

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

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

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

s0hash[i] = ndl_hash_value(s);

sugar = (int *)ALLOCA(nsp*sizeof(int));

sugar = (int *)MALLOC(nsp*sizeof(int));

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

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

if ( spol ) {

Line 6620 init_eg(&eg_search);

Line 7011 init_eg(&eg_search);

}

mat->row = i;

fprintf(asir_out,"%dx%d,",mat->row,mat->col); fflush(asir_out);

if ( DP_Print ) {

fprintf(asir_out,"%dx%d,",mat->row,mat->col); fflush(asir_out);

}

size = ((col+BLEN-1)/BLEN)*sizeof(unsigned long);

v = CALLOC((col+BLEN-1)/BLEN,sizeof(unsigned long));

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

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

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

init_eg(&eg_search);

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

nred = length(rp0);

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

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

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

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

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

/* construction of index arrays */

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

if ( DP_Print ) {

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

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

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

}

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

s0hash = (int *)MALLOC(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,s0hash,rvect[i]);

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

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

}

if ( m )

if ( m > 0 || m == -1 )

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

else if ( m == -2 )

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

else

#if defined(VISUAL)

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

#else

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

print_eg("search",&eg_search);

#endif

if ( DP_Print ) print_eg("search",&eg_search);

return r0;

}

/* for small finite fields */

NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s0vect,int col,

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

{

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

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

spcol = col-nred;

get_eg(&eg0);

/* elimination (1st step) */

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

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

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

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

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

spsugar = (int *)MALLOC(nsp*sizeof(int));

spactive = !nz?0:(ND_pairs *)ALLOCA(nsp*sizeof(ND_pairs));

spactive = !nz?0:(ND_pairs *)MALLOC(nsp*sizeof(ND_pairs));

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

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

if ( !spol ) continue;

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

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

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

/* elimination (2nd step) */

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

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

if ( m == -1 )

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

else

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

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

return r0;

}

NODE nd_f4_red_lf_main(int m,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;

mpz_t **spmat;

mpz_t *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 = (mpz_t **)MALLOC(nsp*sizeof(mpz_t *));

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

spsugar = (int *)MALLOC(nsp*sizeof(int));

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

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

if ( !spol ) continue;

nd_to_vect_lf(s0vect,col,spol,svect);

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

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

if ( i < col ) {

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

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

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

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 *)MALLOC(spcol*sizeof(int));

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

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

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

#if 0

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

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

#else

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

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;

}

#if 1

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

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

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

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

spcol = col-nred;

get_eg(&eg0);

/* elimination (1st step) */

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

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

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

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

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

spsugar = (int *)MALLOC(nsp*sizeof(int));

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

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

if ( !spol ) continue;

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

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

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

/* elimination (2nd step) */

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

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

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

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

w = (pointer *)MALLOC(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);

Line 6879 NODE nd_f4_red_gz_main(ND_pairs sp0,int nsp,int trace,

Line 7363 NODE nd_f4_red_gz_main(ND_pairs sp0,int nsp,int trace,

spcol = col-nred;

get_eg(&eg0);

/* elimination (1st step) */

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

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

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

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

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

spsugar = (int *)MALLOC(nsp*sizeof(int));

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

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

if ( !spol ) continue;

Line 6907 NODE nd_f4_red_gz_main(ND_pairs sp0,int nsp,int trace,

Line 7391 NODE nd_f4_red_gz_main(ND_pairs sp0,int nsp,int trace,

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

/* elimination (2nd step) */

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

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

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

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

w = (pointer *)MALLOC(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] = (pointer)vect_to_ndv_gz(spmat[i],spcol,col,rhead,s0vect);

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

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

#endif

Line 6971 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,UINT *s0vec

Line 7455 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,UINT *s0vec

row = nsp+nred;

/* make the matrix */

mat = (Q **)ALLOCA(row*sizeof(Q *));

mat = (Q **)MALLOC(row*sizeof(Q *));

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

sugar = (int *)MALLOC(row*sizeof(int));

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

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

if ( !spol ) continue;

Line 6986 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,UINT *s0vec

Line 7470 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,UINT *s0vec

sugar[row] = rvect[i]->sugar;

}

/* elimination */

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

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

rank = nd_gauss_elim_q(mat,sugar,row,col,colstat);

r0 = 0;

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

Line 7078 NDV nd_recv_ndv()

Line 7562 NDV nd_recv_ndv()

}

int ox_exec_f4_red(Q proc)

{

Obj obj;

STRING fname;

NODE arg;

int s;

extern int ox_need_conv,ox_file_io;

MKSTR(fname,"nd_exec_f4_red");

arg = mknode(2,proc,fname);

Pox_cmo_rpc(arg,&obj);

s = get_ox_server_id(QTOS(proc));

nd_write = iofp[s].out;

nd_read = iofp[s].in;

ox_need_conv = ox_file_io = 0;

return s;

}

#if 0

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

{

int nsp,nred;

int i,rank,s;

NODE rp,r0,r;

ND_pairs sp;

NM_ind_pair pair;

NMV nmv;

NM nm;

NDV nf;

Obj proc,dmy;

ox_launch_main(0,0,&proc);

s = ox_exec_f4_red((Q)proc);

nd_send_int(m);

nd_send_int(nd_nvar);

nd_send_int(nd_bpe);

nd_send_int(nd_wpd);

nd_send_int(nmv_adv);

saveobj(nd_write,dp_current_spec->obj); fflush(nd_write);

nd_send_int(nd_psn);

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

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

nd_send_int(nsp);

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

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

}

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

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

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

pair = (NM_ind_pair)BDY(rp);

nd_send_int(pair->index);

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

}

fflush(nd_write);

rank = nd_recv_int();

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

r0 = 0;

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

nf = nd_recv_ndv();

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

}

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

return r0;

}

/* server side */

void nd_exec_f4_red_dist()

{

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

NM_ind_pair *rp0;

NDV nf;

UINT *s0vect;

IndArray *imat;

int *rhead;

int **spmat;

UINT *svect,*v;

ND_pairs *sp0;

int *colstat;

int a,sprow,rank;

struct order_spec *ord;

Obj ordspec;

ND spol;

int maxrs;

int *spsugar;

nd_read = iofp[0].in;

nd_write = iofp[0].out;

m = nd_recv_int();

nd_nvar = nd_recv_int();

nd_bpe = nd_recv_int();

nd_wpd = nd_recv_int();

nmv_adv = nd_recv_int();

loadobj(nd_read,&ordspec);

create_order_spec(0,ordspec,&ord);

nd_init_ord(ord);

nd_setup_parameters(nd_nvar,0);

nd_psn = nd_recv_int();

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

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

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

nd_ps[i] = nd_recv_ndv();

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

}

nsp = nd_recv_int();

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

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

NEWND_pairs(sp0[i]);

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

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

}

col = nd_recv_int();

s0size = col*nd_wpd;

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

nd_recv_intarray(s0vect,s0size);

nred = nd_recv_int();

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

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

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

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

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

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

}

spcol = col-nred;

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

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

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

/* construction of index arrays */

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

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

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

}

/* elimination (1st step) */

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

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

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

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

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

if ( !spol ) continue;

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

if ( m == -1 )

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

else

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

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

if ( i < col ) {

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

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

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

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

sprow++;

}

nd_free(spol);

}

/* elimination (2nd step) */

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

if ( m == -1 )

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

else

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

nd_send_int(rank);

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

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

nd_send_ndv(nf);

}

fflush(nd_write);

}

#endif

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

{

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

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

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

int inv,t;

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

else if ( mod == -2 ) divlf(a.z,b.z,&c.z);

else if ( mod ) {

inv = invm(b.m,mod);

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

Line 8000 P ndctop(int mod,union oNDC c)

Line 8302 P ndctop(int mod,union oNDC c)

if ( mod == -1 ) {

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

} else if ( mod ) {

} else if ( mod > 0 ) {

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

} else

return (P)c.p;

Line 8045 void conv_ilist(int demand,int trace,NODE g,int **indp

Line 8347 void conv_ilist(int demand,int trace,NODE g,int **indp

void parse_nd_option(NODE opt)

{

NODE t,p,u;

int i,s;

int i,s,n;

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;

nd_sugarweight = 0;

nd_f4red =0;

nd_rank0 = 0;

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

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

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

Line 8063 void parse_nd_option(NODE opt)

Line 8368 void parse_nd_option(NODE opt)

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

nd_nora = value?1:0;

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

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

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

nd_gbblock = 0;

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

nd_newelim = value?1:0;

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

nd_intersect = value?1:0;

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

nd_lf = 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") )

} else if ( !strcmp(key,"f4red") ) {

nd_f4red = QTOS((Q)value);

} else if ( !strcmp(key,"rank0") ) {

nd_rank0 = value?1:0;

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

nd_splist = value?1:0;

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

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

nd_check_splist = BDY((LIST)value);

} else if ( !strcmp(key,"sugarweight") ) {

u = BDY((LIST)value);

n = length(u);

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

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

nd_sugarweight[i] = QTOS((Q)BDY(u));

}

Line 8268 MAT nd_btog(LIST f,LIST v,int mod,struct order_spec *o

Line 8586 MAT nd_btog(LIST f,LIST v,int mod,struct order_spec *o

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

Line 8367 VECT nd_btog_one(LIST f,LIST v,int mod,struct order_sp

Line 8681 VECT nd_btog_one(LIST f,LIST v,int mod,struct order_sp

}

return vect;

}

void ndv_print_lf(NDV p)

{

NMV m;

int i,len;

if ( !p ) printf("0\n");

else {

len = LEN(p);

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

printf("+");

mpz_out_str(asir_out,10,BDY(CZ(m)));

printf("*");

ndl_print(DL(m));

}

printf("\n");

}

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

{

VL tv,fv,vv,vc,av;

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

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

NDV c;

NMV a;

P p,zp;

Q dmy;

EPOS oepos;

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

Alg alpha,dp;

P poly;

LIST f1,f2,zpl;

Obj obj;

NumberField nf;

struct order_spec *ord1;

struct oEGT eg_check,eg0,eg1;

NODE tr,tl1,tl2,tl3,tl4;

LIST l1,l2,l3,l4,l5;

int *perm;

int j,ret;

Q jq,bpe;

nd_module = 0;

parse_nd_option(current_option);

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

if ( nd_vc )

error("nd_f4_lf_trace : computation over a rational function field is not implemented");

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

switch ( ord->id ) {

case 1:

if ( ord->nv != nvar )

error("nd_f4_lf_trace : invalid order specification");

break;

default:

break;

}

nd_ntrans = nvar;

nd_nalg = 0;

nocheck = 0;

mindex = 0;

/* do not use on-demand load/save */

nd_demand = 0;

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

nd_init_ord(ord);

mrank = 0;

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

trank = length(s);

mrank = MAX(mrank,trank);

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

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

max = MAX(e,max);

}

} else {

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

max = MAX(e,max);

}

nd_setup_parameters(nvar,max);

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

ishomo = 1;

/* XXX */

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

if ( nd_module ) {

c = (pointer)pltondv(CO,vv,(LIST)BDY(t));

} else {

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

}

if ( ishomo )

ishomo = ishomo && ndv_ishomo(c);

if ( c ) {

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

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

}

if ( in0 ) NEXT(in) = 0;

if ( fd0 ) NEXT(fd) = 0;

if ( !ishomo && homo ) {

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

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

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

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

}

homogenize_order(ord,nvar,&ord1);

nd_init_ord(ord1);

nd_setup_parameters(nvar+1,wmax);

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

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

}

if ( MaxDeg > 0 ) nocheck = 1;

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

if ( ret )

cand = nd_f4_lf_trace_main(m,&perm);

if ( !ret || !cand ) {

*rp = 0; return;

}

if ( !ishomo && homo ) {

/* dehomogenization */

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

nd_init_ord(ord);

nd_setup_parameters(nvar,0);

}

cand = ndv_reducebase(cand,perm);

cand = ndv_reduceall(-2,cand);

cbpe = nd_bpe;

get_eg(&eg0);

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

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

ret = nd_f4(-2,0,0);

}

if ( !ret ) {

/* failure */

*rp = 0; return;

}

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

if ( DP_Print )

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

/* dp->p */

nd_bpe = cbpe;

nd_setup_parameters(nd_nvar,0);

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

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

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

}

MKLIST(*rp,cand);

}

NODE nd_f4_lf_trace_main(int m,int **indp)

{

int i,nh,stat,index;

NODE r,rm,g;

ND_pairs d,l,l0,t;

ND spol,red;

NDV nf,redv,nfqv,nfv;

NM s0,s;

NODE rp0,srp0,nflist,nflist_lf;

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

if ( MaxDeg > 0 && sugar > MaxDeg ) break;

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 LF */

bucket = create_pbucket();

stat = nd_sp_f4(-2,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_lf = nd_f4_red(-2,l,1,s0vect,col,rp0,0);

/* adding new bases */

for ( rm = nflist, r = nflist_lf; r && rm; rm = NEXT(rm), r = NEXT(r) ) {

nfv = (NDV)BDY(rm);

nfqv = (NDV)BDY(r);

if ( DL_COMPARE(HDL(nfv),HDL(nfqv)) ) return 0;

ndv_removecont(m,nfv);

ndv_removecont(-2,nfqv);

nh = ndv_newps(-2,nfv,nfqv,1);

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

g = update_base(g,nh);

}

if ( r || rm ) return 0;

}

conv_ilist(nd_demand,1,g,indp);

return g;

}

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