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.234 and 1.245

version 1.234, 2017/02/21 09:20:23

version 1.245, 2018/03/29 01:32:52

Line 1

/* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.233 2017/02/07 08:30:30 noro Exp $ */

/* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.244 2018/03/05 06:43:09 noro Exp $ */

#include "nd.h"

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

static int nd_f4red,nd_rank0,nd_last_nonzero;

NumberField get_numberfield();

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

Line 98 void Pox_cmo_rpc(NODE,Obj *);

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

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

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

Line 561 int ndl_matrix_compare(UINT *d1,UINT *d2)

Line 565 int ndl_matrix_compare(UINT *d1,UINT *d2)

{

int i,j,s,row;

int *v;

Q **mat;

Q *w;

Q t,t1,t2;

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

nd_work_vector[j] = GET_EXP(d1,j)-GET_EXP(d2,j);

if ( nd_top_weight ) {

if ( OID(nd_top_weight) == O_VECT ) {

mat = (Q **)&BDY((VECT)nd_top_weight);

row = 1;

} else {

mat = (Q **)BDY((MAT)nd_top_weight);

row = ((MAT)nd_top_weight)->row;

}

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

w = (Q *)mat[i];

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

STOQ(nd_work_vector[j],t1);

mulq(w[j],t1,&t2);

addq(t,t2,&t1);

t = t1;

}

if ( t ) {

s = SGN(t);

if ( s > 0 ) return 1;

else if ( s < 0 ) return -1;

}

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

v = nd_matrix[i];

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

Line 597 int ndl_matrix_compare(UINT *d1,UINT *d2)

Line 601 int ndl_matrix_compare(UINT *d1,UINT *d2)

if ( s > 0 ) return 1;

else if ( s < 0 ) return -1;

}

if ( !ndl_equal(d1,d2) )

error("afo");

return 0;

}

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

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

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

if ( nd_module_rank && (c = ndl_module_weight_compare(d1,d2)) ) return c;

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;

}

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

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

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

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

hindex = head_pbucket(mod,bucket);

Line 1645 int ndv_check_membership(int m,NODE input,int obpe,int

Line 1650 int ndv_check_membership(int m,NODE input,int obpe,int

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

Line 1661 again:

Line 1666 again:

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

Line 2034 int do_diagonalize(int sugar,int m)

Line 2039 int do_diagonalize(int sugar,int m)

ndv_free(nfv);

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 2050 int do_diagonalize(int sugar,int m)

Line 2055 int do_diagonalize(int sugar,int m)

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

Line 2128 again:

Line 2133 again:

goto again;

} else if ( nf ) {

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

Line 2141 again:

Line 2146 again:

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

Line 2163 again:

Line 2168 again:

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

}

conv_ilist(nd_demand,0,g,indp);

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

return g;

}

Line 2183 again:

Line 2188 again:

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:

Line 2212 again:

Line 2217 again:

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

Line 2298 int do_diagonalize_trace(int sugar,int m)

Line 2303 int do_diagonalize_trace(int sugar,int m)

if ( !stat ) return 0;

ndv_free(nfv);

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

Line 2423 again:

Line 2428 again:

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

}

if ( nd_gentrace ) {

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

if ( !UNIQ(cont) ) {

t = mknode(4,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 ) {

Line 2459 again:

Line 2464 again:

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

Line 2497 NODE ndv_reduceall(int m,NODE f)

union oNDC dn;

Q q,num,den;

NODE node;

LIST l;

Q iq,jq;

int *perm;

union oNDC hc;

P cont,cont1;

Line 2501 NODE ndv_reduceall(int m,NODE f)

Line 2506 NODE ndv_reduceall(int m,NODE f)

if ( nd_nora ) return f;

n = length(f);

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

Line 2522 NODE ndv_reduceall(int m,NODE f)

Line 2527 NODE ndv_reduceall(int m,NODE f)

ndv_free(nd_ps[i]);

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;

}

Line 2537 NODE ndv_reduceall(int m,NODE f)

Line 2542 NODE ndv_reduceall(int m,NODE f)

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

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

NEXTNODE(a0,a);

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;

}

Line 2552 ND_pairs update_pairs( ND_pairs d, NODE /* of index */

Line 2557 ND_pairs update_pairs( ND_pairs d, NODE /* of index */

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

Line 2603 ND_pairs nd_newpairs( NODE g, int t )

Line 2608 ND_pairs nd_newpairs( NODE g, int t )

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 2667 ND_pairs crit_B( ND_pairs d, int s )

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

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

return dm0;

}

int nd_tdeg(NDV c)

{

int wmax = 0;

int i,len;

NMV a;

len = LEN(c);

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

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

return wmax;

}

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

{

int len;

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

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

if ( aq ) {

nd_ps_trace[nd_psn] = aq;

if ( !m ) {

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

#if 1

SG(r) = SG(aq);

#else

SG(r) = nd_tdeg(aq);

#endif

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

} else {

if ( !m ) register_hcf(a);

nd_bound[nd_psn] = ndv_compute_bound(a);

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

#if 1

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

SG(r) = SG(a);

#else

SG(r) = nd_tdeg(a);

#endif

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

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

}

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 2989 int ndv_setup(int mod,int trace,NODE f,int dont_sort,i

Line 3017 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 3030 int ndv_setup(int mod,int trace,NODE f,int dont_sort,i

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

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

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

ndv_mod(trace,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);

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;

}

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

Line 3090 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 3117 void preprocess_algcoef(VL vv,VL av,struct order_spec

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

if ( NID(hc) == N_DA ) {

invdalg(hc,&inv);

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

muldalg(inv,(DAlg)m->c,&da); m->c = (P)da;

muldalg(inv,(DAlg)m->c,&da); m->c = (Obj)da;

}

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

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

}

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

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

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

int e,max,nvar,i;

NDV b;

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

NMV a;

Alg alpha,dp;

P p,zp;

Q dmy;

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

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

struct order_spec *ord1;

NODE tr,tl1,tl2,tl3,tl4,nzlist;

LIST l1,l2,l3,l4,l5;

int j;

Q jq,bpe;

Q jq,bpe,last_nonzero;

int *perm;

EPOS oepos;

int obpe,oadv,ompos,cbpe;

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

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

ishomo = 1;

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

if ( nd_module ) {

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

else zpl = (LIST)BDY(t);

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

} else {

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

else zp = (P)BDY(t);

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

}

if ( ishomo )

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

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

}

if ( fd0 ) NEXT(fd) = 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) )

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

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

}

homogenize_order(ord,nvar,&ord1);

nd_init_ord(ord1);

nd_setup_parameters(nvar+1,wmax);

nd_setup_parameters(nvar+1,nd_nzlist?0:wmax);

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

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

}

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

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

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;

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

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

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

else *rp = 0;

}

return;

}

x = f4?nd_f4(m,0,&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;

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

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

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

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;

}

Line 3349 FINAL:

Line 3378 FINAL:

NEXTNODE(r0,r);

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

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

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

}

if ( r0 ) NEXT(r) = 0;

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

STOQ(nd_last_nonzero,last_nonzero);

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

} else {

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

tl3 = reverse_node(tl3);

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

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

}

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

Line 3480 void nd_gr_recompute_trace(LIST f,LIST v,int m,struct

Line 3511 void nd_gr_recompute_trace(LIST f,LIST v,int m,struct

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

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

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;

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

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

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

nd_mul_c(mod,rm,c);

} else {

GZ t,u;

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

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

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

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)

Line 3548 void nd_gr_recompute_trace(LIST f,LIST v,int m,struct

Line 3579 void nd_gr_recompute_trace(LIST f,LIST v,int m,struct

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

Line 3564 void nd_gr_recompute_trace(LIST f,LIST v,int m,struct

Line 3595 void nd_gr_recompute_trace(LIST f,LIST v,int m,struct

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

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

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

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

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

ishomo = 1;

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

if ( nd_module ) {

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

else zpl = (LIST)BDY(t);

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

} else {

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

else zp = (P)BDY(t);

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

}

if ( ishomo )

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

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

}

if ( MaxDeg > 0 ) nocheck = 1;

while ( 1 ) {

tl1 = tl2 = tl3 = tl4 = 0;

if ( Demand )

nd_demand = 1;

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

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

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

break;

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

if ( nd_gentrace ) {

tl3 = nd_alltracelist; nd_alltracelist = 0;

} else tl3 = 0;

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

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;

}

if ( ret ) break;

else if ( trace > 1 ) {

/* failure */

*rp = 0; return;

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

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

}

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

fprintf(asir_out,"check=%.3fsec,",eg_check.exectime+eg_check.gctime);

/* dp->p */

nd_bpe = cbpe;

nd_setup_parameters(nd_nvar,0);

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

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

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

}

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

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

NEWMP(mr);

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

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

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

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

*r = dp;

}

Line 3924 void ndl_print(UINT *dl)

Line 3956 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 3986 void nd_removecont(int mod,ND p)

Line 4018 void nd_removecont(int mod,ND p)

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

else {

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

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

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 4007 void nd_removecont2(ND p1,ND p2)

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

Line 4074 void ndv_removecont(int mod,NDV p)

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

Line 4109 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 4125 void nd_heu_nezgcdnpz(VL vl,P *pl,int m,int full,P *pr

Line 4157 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 4162 void removecont_array(P *p,int n,int full)

Line 4194 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 4183 void removecont_array_q(Q *c,int n)

Line 4215 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 4302 UINT *ndv_compute_bound(NDV p)

Line 4334 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 4331 UINT *nd_compute_bound(ND p)

Line 4363 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 4365 int nd_get_exporigin(struct order_spec *ord)

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

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

}

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

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

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

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

Line 4491 ND_pairs nd_reconstruct(int trace,ND_pairs d)

Line 4527 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 4688 ND weyl_ndv_mul_nm(int mod,NM m0,NDV p) {

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

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

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

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

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

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

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

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

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

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

} 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 4930 ND nd_quo(int mod,PGeoBucket bucket,NDV d)

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

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

hindex = head_pbucket(mod,bucket);

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

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

Line 5068 NDV ndv_dup(int mod,NDV p)

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)

Line 5091 ND nd_dup(ND p)

Line 5127 ND nd_dup(ND p)

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;

}

Line 5128 void ndv_mod(int mod,NDV p)

Line 5164 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); lmtolf(gfs,&CZ(d));

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

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

if ( gfs ) {

NMV_ADV(d);

lmtolf(gfs,&CZ(d));

dlen++;

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

NMV_ADV(d);

dlen++;

}

else

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

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

Line 5229 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 5254 ND ptond(VL vl,VL dvl,P p)

Line 5295 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 5304 P ndvtop(int mod,VL vl,VL dvl,NDV p)

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

if ( mod == -1 ) {

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

} else if ( mod == -2 ) {

c = gztoz(CZ(m));

c = (P)gztoz(CZ(m));

} else if ( mod > 0 ) {

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

} else

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

Line 5377 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 5413 ND ndvtond(int mod,NDV p)

Line 5454 ND ndvtond(int mod,NDV p)

DP ndvtodp(int mod,NDV p)

{

MP m,m0;

DP d;

NMV t;

int i,len;

Line 5422 DP ndvtodp(int mod,NDV p)

Line 5463 DP ndvtodp(int mod,NDV p)

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

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

}

NEXT(m) = 0;

MKDP(nd_nvar,m0,d);

SG(d) = SG(p);

return d;

}

Line 5434 DP ndvtodp(int mod,NDV p)

Line 5475 DP ndvtodp(int mod,NDV p)

DP ndtodp(int mod,ND p)

{

MP m,m0;

DP d;

NM t;

int i,len;

Line 5443 DP ndtodp(int mod,ND p)

Line 5484 DP ndtodp(int mod,ND p)

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

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

}

NEXT(m) = 0;

MKDP(nd_nvar,m0,d);

SG(d) = SG(p);

return d;

}

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

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

Line 5570 void nd_init_ord(struct order_spec *ord)

nd_module_rank = ord->module_rank;

nd_module_weight = ord->module_top_weight;

}

nd_matrix = 0;

nd_matrix_len = 0;

switch ( ord->id ) {

case 0:

switch ( ord->ord.simple ) {

Line 5726 void nd_nf_p(Obj f,LIST g,LIST v,int m,struct order_sp

Line 5767 void nd_nf_p(Obj f,LIST g,LIST v,int m,struct order_sp

/* max=65536 implies nd_bpe=32 */

max = 65536;

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

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

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

return i;

}

#if defined(__GNUC__) && SIZEOF_LONG==8

#define MOD128(a,c,m) ((a)=(((c)!=0||((a)>=(m)))?(((((U128)(c))<<64)+(a))%(m)):(a)))

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

{

NM m;

UINT *t,*s;

int i;

for ( i = 0; i < n; i++ ) 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++ );

r[i] = (U64)CM(m);

}

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

return i;

}

#endif

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

{

NM m;

Line 5820 unsigned long *nd_to_vect_2(UINT *s0,int n,int *s0hash

Line 5882 unsigned long *nd_to_vect_2(UINT *s0,int n,int *s0hash

NM m;

unsigned long *v;

int i,j,h,size;

UINT *s,*t;

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

v = (unsigned long *)MALLOC_ATOMIC_IGNORE_OFF_PAGE(size);

bzero(v,size);

for ( i = j = 0, s = s0, m = BDY(p); m; j++, m = NEXT(m) ) {

t = DL(m);

h = ndl_hash_value(t);

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

v[i/BLEN] |= 1L <<(i%BLEN);

}

return v;

}

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

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

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

if ( j == 0 ) head = i;

v[i/BLEN] |= 1L <<(i%BLEN);

}

return head;

}

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

Line 5929 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 5876 Q *nm_ind_pair_to_vect(int mod,UINT *s0,int n,NM_ind_p

Line 5938 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 5891 struct oEGT eg0,eg1;

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

h = ndl_hash_value(t);

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

v[j] = i;

}

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

Line 6030 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 6036 int ndv_reduce_vect_gz(GZ *gvect,int trace,int col,Ind

Line 6102 int ndv_reduce_vect_gz(GZ *gvect,int trace,int col,Ind

NODE rp;

int maxrs;

double hmag;

struct oVECT v;

maxrs = 0;

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

Line 6049 int ndv_reduce_vect_gz(GZ *gvect,int trace,int col,Ind

Line 6115 int ndv_reduce_vect_gz(GZ *gvect,int trace,int col,Ind

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;

}

Line 6085 int ndv_reduce_vect_gz(GZ *gvect,int trace,int col,Ind

Line 6151 int ndv_reduce_vect_gz(GZ *gvect,int trace,int col,Ind

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 6132 int ndv_reduce_vect(int m,UINT *svect,int col,IndArray

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

ivc = ivect->index.c;

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

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

if ( c1 ) {

c2 = svect[pos];

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

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

} else svect[pos] = lo;

}

break;

case 2:

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

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

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

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

prev = pos;

if ( c1 ) {

c2 = svect[pos];

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

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

} else svect[pos] = lo;

}

break;

case 4:

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

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

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

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

prev = pos;

if ( c1 ) {

c2 = svect[pos];

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

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

} else svect[pos] = lo;

}

break;

}

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

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

return maxrs;

}

#if defined(__GNUC__) && SIZEOF_LONG==8

int ndv_reduce_vect64(int m,U64 *svect,U64 *cvect,int col,IndArray *imat,NM_ind_pair *rp0,int nred)

{

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

U64 a,c,c1,c2;

IndArray ivect;

unsigned char *ivc;

unsigned short *ivs;

unsigned int *ivi;

NDV redv;

NMV mr;

NODE rp;

int maxrs;

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

maxrs = 0;

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

ivect = imat[i];

k = ivect->head;

a = svect[k]; c = cvect[k];

MOD128(a,c,m);

svect[k] = a; cvect[k] = 0;

if ( c = svect[k] ) {

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

c = m-c; redv = nd_ps[rp0[i]->index];

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

svect[k] = 0; prev = k;

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]; c1 = CM(mr); prev = pos;

if ( c1 ) {

c2 = svect[pos]+c1*c;

if ( c2 < svect[pos] ) cvect[pos]++;

svect[pos] = c2;

}

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); prev = pos;

if ( c1 ) {

c2 = svect[pos]+c1*c;

if ( c2 < svect[pos] ) cvect[pos]++;

svect[pos] = c2;

}

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); prev = pos;

if ( c1 ) {

c2 = svect[pos]+c1*c;

if ( c2 < svect[pos] ) cvect[pos]++;

svect[pos] = c2;

}

break;

}

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

a = svect[i]; c = cvect[i]; MOD128(a,c,m); svect[i] = a;

}

return maxrs;

}

#endif

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

{

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

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

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

}

#if defined(__GNUC__) && SIZEOF_LONG==8

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

{

int j,k,len;

UINT *p;

UINT 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_ATOMIC_IGNORE_OFF_PAGE(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 = (UINT)vect[k++] ) {

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

}

MKNDV(nd_nvar,mr0,len,r);

return r;

}

#endif

NDV vect_to_ndv_2(unsigned long *vect,int col,UINT *s0vect)

{

int j,k,len;

Line 6445 NDV vect_to_ndv_2(unsigned long *vect,int col,UINT *s0

Line 6612 NDV vect_to_ndv_2(unsigned long *vect,int col,UINT *s0

mr = mr0;

p = s0vect;

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

if ( vect[j/BLEN] & (1L<<(j%BLEN)) ) {

ndl_copy(p,DL(mr)); CM(mr) = 1; NMV_ADV(mr);

}

MKNDV(nd_nvar,mr0,len,r);

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

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

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 6616 int nd_symbolic_preproc(PGeoBucket bucket,int trace,UI

Line 6784 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 6635 int nd_symbolic_preproc(PGeoBucket bucket,int trace,UI

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

return col;

}

void print_ndp(ND_pairs l)

{

ND_pairs t;

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

printf("[%d,%d] ",t->i1,t->i2);

printf("\n");

}

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

{

int i,nh,stat,index,f4red;

NODE r,g,tn0,tn,node;

ND_pairs d,l,t,ll0,ll;

ND_pairs d,l,t,ll0,ll,lh;

LIST l0,l1;

ND spol,red;

NDV nf,redv;

NM s0,s;

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

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

IndArray *imat;

int *rhead;

int spcol,sprow;

int sugar;

int sugar,sugarh;

PGeoBucket bucket;

struct oEGT eg0,eg1,eg_f4;

Q i1,i2,sugarq;

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

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

#endif

g = 0; d = 0;

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

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

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

g = update_base(g,i);

}

nzlist = 0;

nzlist_t = nd_nzlist;

f4red = 0;

f4red = 1;

while ( d || nzlist_t ) {

nd_last_nonzero = 0;

while ( d ) {

get_eg(&eg0);

if ( nd_nzlist ) {

l = nd_minsugarp(d,&d);

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

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

if ( nzlist_t ) {

node = BDY((LIST)BDY(nzlist_t));

sugar = (int)ARG0(node);

sugarh = QTOS((Q)ARG0(node));

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

if ( !tn ) {

nzlist_t = NEXT(nzlist_t);

continue;

}

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

l = nd_ipairtospair(tn);

lh = nd_ipairtospair(tn);

} else {

l = nd_minsugarp(d,&d);

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

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

}

bucket = create_pbucket();

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

if ( !stat ) {

if ( !nd_nzlist ) {

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

NEXT(t) = d; d = l;

d = nd_reconstruct(0,d);

}

continue;

}

if ( bucket->m < 0 ) continue;

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

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

}

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

if ( DP_Print )

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

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

sugar,eg_f4.exectime+eg_f4.gctime);

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

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

if ( checkonly && nflist ) return 0;

/* adding new bases */

if ( nflist ) nd_last_nonzero = f4red;

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

nf = (NDV)BDY(r);

ndv_removecont(m,nf);

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

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

nf = ndtondv(m,nf1);

}

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

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

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

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

}

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;

}

if ( nd_nzlist ) nzlist_t = NEXT(nzlist_t);

f4red++;

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

if ( nd_f4red && f4red > nd_f4red ) break;

if ( nd_rank0 && !nflist ) break;

}

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;

}

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

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

}

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

if ( DP_Print )

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

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

sugar,eg_f4.exectime+eg_f4.gctime);

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

if ( !l0 ) continue;

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

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

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

}

int rref(matrix mat,int *sugar)

{

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

Line 6974 int rref(matrix mat,int *sugar)

Line 7048 int rref(matrix mat,int *sugar)

pivot = (int *)MALLOC_ATOMIC(row*sizeof(int));

i = 0;

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

wj = j/BLEN; bj = 1L<<(j%BLEN);

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

if ( a[k][wj] & bj ) break;

if ( k == row ) continue;

pivot[i] = j;

if ( k != i ) {

t = a[i]; a[i] = a[k]; a[k] = t;

s = sugar[i]; sugar[i] = sugar[k]; sugar[k] = s;

}

ai = a[i];

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

ak = a[k];

if ( ak[wj] & bj ) {

for ( l = wj; l < wcol; l++ )

ak[l] ^= ai[l];

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

}

i++;

}

i++;

}

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

j = pivot[k]; wj = j/BLEN; bj = 1L<<(j%BLEN);

ak = a[k];

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

as = a[s];

if ( as[wj] & bj ) {

for ( l = wj; l < wcol; l++ )

as[l] ^= ak[l];

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

}

return i;

}

Line 7018 void print_matrix(matrix mat)

Line 7092 void print_matrix(matrix mat)

col = mat->col;

printf("%d x %d\n",row,col);

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

ai = mat->a[i];

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

if ( ai[j/BLEN] & (1L<<(j%BLEN)) ) putchar('1');

else putchar('0');

}

putchar('\n');

}

putchar('\n');

}

NDV vect_to_ndv_2(unsigned long *vect,int col,UINT *s0vect);

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

Line 7115 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 7050 void red_by_vect_2(matrix mat,int *sugar,unsigned long

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

bj = 1L<<rhead%BLEN;

a = mat->a;

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

ai = a[i];

if ( ai[wj]&bj ) {

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

ai[pos[j]] ^= v[pos[j]];

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

}

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

Line 7064 NODE nd_f4_red_2(ND_pairs sp0,UINT *s0vect,int col,NOD

Line 7138 NODE nd_f4_red_2(ND_pairs sp0,UINT *s0vect,int col,NOD

int nsp,nred,i,i0,k,rank,row;

NODE r0,rp;

ND_pairs sp;

ND spol;

NM_ind_pair rt;

int *s0hash;

UINT *s;

int *pivot,*sugar,*head;

matrix mat;

NM m;

NODE r;

struct oEGT eg0,eg1,eg2,eg_elim1,eg_elim2;

int rhead,rsugar,size;

unsigned long *v;

get_eg(&eg0);

Line 7081 init_eg(&eg_search);

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

mat->a[i] = nd_to_vect_2(s0vect,col,s0hash,spol);

sugar[i] = SG(spol);

i++;

}

mat->row = i;

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

rt = (NM_ind_pair)BDY(rp);

bzero(v,size);

rhead = nd_nm_to_vect_2(s0vect,col,s0hash,nd_ps[rt->index],rt->mul,v);

rsugar = SG(nd_ps[rt->index])+TD(DL(rt->mul));

red_by_vect_2(mat,sugar,v,rhead,rsugar);

}

get_eg(&eg1);

init_eg(&eg_elim1); add_eg(&eg_elim1,&eg0,&eg1);

rank = rref(mat,sugar);

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

NEXTNODE(r0,r);

BDY(r) = (pointer)vect_to_ndv_2(mat->a[i],col,s0vect);

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

}

if ( r0 ) NEXT(r) = 0;

get_eg(&eg2);

init_eg(&eg_elim2); add_eg(&eg_elim2,&eg1,&eg2);

if ( DP_Print ) {

fprintf(asir_out,"elim1=%fsec,elim2=%fsec\n",

fprintf(asir_out,"elim1=%.3fsec,elim2=%.3fsec,",

eg_elim1.exectime+eg_elim1.gctime,eg_elim2.exectime+eg_elim2.gctime);

fflush(asir_out);

}

return r0;

}

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

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

int *s0hash;

if ( m == 2 && nd_rref2 )

return nd_f4_red_2(sp0,s0vect,col,rp0,nz);

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

if ( DP_Print ) {

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

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

}

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

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

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

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 > 0 || m == -1 )

if ( m > 0 )

#if defined(__GNUC__) && SIZEOF_LONG==8

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

#else

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

#endif

else if ( m == -1 )

r0 = nd_f4_red_sf_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);

#endif

#if 0

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

#endif

return r0;

}

/* for small finite fields */

/* for Fp, 2<=p<2^16 */

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 7193 NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s

Line 7280 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(int));

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 7219 NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s

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

}

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

fprintf(asir_out,"elim1=%.3fsec,",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));

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

if ( m == -1 )

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

else

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

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

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,"elim2=%.3fsec,",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);

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

}

if ( nz ) {

for ( i = 0; i < rank-1; i++ ) NEXT(spactive[i]) = spactive[i+1];

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

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

return r0;

}

#if defined(__GNUC__) && SIZEOF_LONG==8

/* for Fp, 2^15=<p<2^29 */

NODE nd_f4_red_mod64_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)

{

int spcol,sprow,a;

int i,j,k,l,rank;

NODE r0,r;

ND_pairs sp;

ND spol;

U64 **spmat;

U64 *svect,*cvect;

U64 *v;

int *colstat;

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

int maxrs;

int *spsugar;

ND_pairs *spactive;

spcol = col-nred;

get_eg(&eg0);

/* elimination (1st step) */

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

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

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

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

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;

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

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

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

if ( i < col ) {

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

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

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

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

if ( nz )

spactive[sprow] = sp;

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=%.3fsec,",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_mod64(spmat,spsugar,spactive,sprow,spcol,m,colstat);

r0 = 0;

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

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

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

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

GCFREE(spmat[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=%.3fsec,",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,"%.3fsec,",eg_f4.exectime+eg_f4.gctime);

}

if ( nz ) {

for ( i = 0; i < rank-1; i++ ) NEXT(spactive[i]) = spactive[i+1];

if ( rank > 0 ) {

NEXT(spactive[rank-1]) = 0;

*nz = spactive[0];

} else

*nz = 0;

}

return r0;

}

#endif

/* for small finite fields */

NODE nd_f4_red_sf_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)

{

int spcol,sprow,a;

int i,j,k,l,rank;

NODE r0,r;

ND_pairs sp;

ND spol;

int **spmat;

UINT *svect,*v;

int *colstat;

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

int maxrs;

int *spsugar;

ND_pairs *spactive;

spcol = col-nred;

get_eg(&eg0);

/* elimination (1st step) */

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

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

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

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;

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

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

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

if ( i < col ) {

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

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

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

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

if ( nz )

spactive[sprow] = sp;

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=%.3fsec,",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_sf(spmat,spsugar,sprow,spcol,m,colstat);

r0 = 0;

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

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

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

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

GCFREE(spmat[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=%.3fsec,",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,"%.3fsec,",eg_f4.exectime+eg_f4.gctime);

}

if ( nz ) {

for ( i = 0; i < rank-1; i++ ) NEXT(spactive[i]) = spactive[i+1];

if ( rank > 0 ) {

NEXT(spactive[rank-1]) = 0;

*nz = spactive[0];

} else

*nz = 0;

}

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)

{

Line 7279 NODE nd_f4_red_lf_main(int m,ND_pairs sp0,int nsp,int

Line 7534 NODE nd_f4_red_lf_main(int m,ND_pairs sp0,int nsp,int

spcol = col-nred;

get_eg(&eg0);

/* elimination (1st step) */

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

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

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

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

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

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;

Line 7299 NODE nd_f4_red_lf_main(int m,ND_pairs sp0,int nsp,int

Line 7554 NODE nd_f4_red_lf_main(int m,ND_pairs sp0,int nsp,int

}

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

fprintf(asir_out,"elim1=%.3fsec,",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));

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

rank = nd_gauss_elim_lf(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_lf(spmat[i],spcol,col,rhead,s0vect);

Line 7318 NODE nd_f4_red_lf_main(int m,ND_pairs sp0,int nsp,int

Line 7573 NODE nd_f4_red_lf_main(int m,ND_pairs sp0,int nsp,int

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

#endif

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

}

#if 0

qsort(w,rank,sizeof(NDV),

Line 7334 NODE nd_f4_red_lf_main(int m,ND_pairs sp0,int nsp,int

Line 7589 NODE nd_f4_red_lf_main(int m,ND_pairs sp0,int nsp,int

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,"elim2=%.3fsec,",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);

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

}

return r0;

}

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

Line 7617 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(int));

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 7382 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U

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

}

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

fprintf(asir_out,"elim1=%.3fsec,",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));

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 7416 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U

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

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,"elim2=%.3fsec,",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);

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

}

return r0;

}

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

Line 7698 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(int));

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;

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;

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

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

}

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

fprintf(asir_out,"elim1=%.3fsec,",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));

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

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

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

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,"elim2=%.3fsec,",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);

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

}

return r0;

}

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

Line 7790 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 7550 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,UINT *s0vec

Line 7805 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 7642 NDV nd_recv_ndv()

Line 7897 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(int));

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 7937 int nd_gauss_elim_mod(int **mat0,int *sugar,ND_pairs *

Line 8009 int nd_gauss_elim_mod(int **mat0,int *sugar,ND_pairs *

return rank;

}

#if defined(__GNUC__) && SIZEOF_LONG==8

int nd_gauss_elim_mod64(U64 **mat,int *sugar,ND_pairs *spactive,int row,int col,int md,int *colstat)

{

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

U64 inv;

U64 a;

UINT c;

U64 *t,*pivot,*pk;

UINT *ck;

UINT **cmat;

UINT *ct;

ND_pairs pair;

cmat = (UINT **)MALLOC(row*sizeof(UINT *));

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

cmat[i] = MALLOC_ATOMIC(col*sizeof(UINT));

bzero(cmat[i],col*sizeof(UINT));

}

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

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

a = mat[i][j]; c = cmat[i][j];

MOD128(a,c,md);

mat[i][j] = a; cmat[i][j] = 0;

}

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

if ( mat[i][j] )

break;

if ( i == row ) {

colstat[j] = 0;

continue;

} else

colstat[j] = 1;

if ( i != rank ) {

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

ct = cmat[i]; cmat[i] = cmat[rank]; cmat[rank] = ct;

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

if ( spactive ) {

pair = spactive[i]; spactive[i] = spactive[rank];

spactive[rank] = pair;

}

/* column j is normalized */

s = sugar[rank];

inv = invm((UINT)mat[rank][j],md);

/* normalize pivot row */

for ( k = j, pk = mat[rank]+j, ck = cmat[rank]+j; k < col; k++, pk++, ck++ ) {

a = *pk; c = *ck; MOD128(a,c,md); *pk = (a*inv)%md; *ck = 0;

}

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

if ( a = mat[i][j] ) {

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

red_by_vect64(md,mat[i]+j,cmat[i]+j,mat[rank]+j,(int)(md-a),col-j);

}

rank++;

}

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

if ( colstat[j] ) {

for ( k = j, pk = mat[l]+j, ck = cmat[l]+j; k < col; k++, pk++, ck++ ) {

a = *pk; c = *ck; MOD128(a,c,md); *pk = a; *ck = 0;

}

s = sugar[l];

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

a = mat[i][j]; c = cmat[i][j]; MOD128(a,c,md); mat[i][j] = a; cmat[i][j] = 0;

if ( a ) {

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

red_by_vect64(md,mat[i]+j,cmat[i]+j,mat[l]+j,(int)(md-a),col-j);

}

l--;

}

for ( i = 0; i < row; i++ ) GCFREE(cmat[i]);

GCFREE(cmat);

return rank;

}

#endif

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

{

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

Line 8053 void nd_save_mod(ND p,int index)

Line 8204 void nd_save_mod(ND p,int index)

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

}

Line 8118 ND nd_load_mod(int index)

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

}

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

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

chsgnq(ONE,&mone);

for ( j = 0, sgn = 1; j < n; j++ ) {

if ( DP_Print ) {

fprintf(stderr,".",j);

fprintf(asir_out,".",j);

}

for ( i = j; i < n && !dm[i][j]; i++ );

if ( i == n ) {

*rp = 0;

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

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

nd_det_reconstruct(dm,n,j,d);

for ( i = j+1, mj = dm[j], mjj = mj[j]; i < n; i++ ) {

/* if ( DP_Print ) fprintf(stderr," i=%d\n ",i); */

/* if ( DP_Print ) fprintf(asir_out," i=%d\n ",i); */

mi = dm[i]; mij = mi[j];

if ( mod )

ndv_mul_c(mod,mij,mod-1);

else

ndv_mul_c_q(mij,mone);

for ( k = j+1; k < n; k++ ) {

/* if ( DP_Print ) fprintf(stderr,"k=%d ",k); */

/* if ( DP_Print ) fprintf(asir_out,"k=%d ",k); */

bucket = create_pbucket();

if ( mi[k] ) {

nmv = BDY(mjj); len = LEN(mjj);

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

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

u = nd_quo(mod,bucket,d);

mi[k] = ndtondv(mod,u);

}

/* if ( DP_Print ) fprintf(stderr,"\n",k); */

/* if ( DP_Print ) fprintf(asir_out,"\n",k); */

}

d = mjj;

}

if ( DP_Print ) {

fprintf(stderr,"\n",k);

fprintf(asir_out,"\n",k);

}

if ( sgn < 0 )

if ( mod )

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

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

is_lc = 1;

while ( 1 ) {

NEWMP(mp0); mp = mp0;

mp->c = (P)CQ(m);

mp->c = (Obj)CQ(m);

mp->dl = nd_separate_d(DL(m),DL(ma));

NEWNM(mb);

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

alg = nd_separate_d(DL(m),DL(mb));

if ( !ndl_equal(DL(ma),DL(mb)) )

break;

NEXTMP(mp0,mp); mp->c = (P)CQ(m); mp->dl = alg;

NEXTMP(mp0,mp); mp->c = (Obj)CQ(m); mp->dl = alg;

}

NEXT(mp) = 0;

MKDP(nd_nalg,mp0,nm);

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

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

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

Line 8595 void finalize_tracelist(int i,P cont)

Line 8746 void finalize_tracelist(int i,P cont)

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

Line 8632 void parse_nd_option(NODE opt)

Line 8783 void parse_nd_option(NODE opt)

nd_nora = value?1:0;

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

if ( value && OID(value) == O_LIST ) {

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

if ( value ) {

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

u = BDY((LIST)value);

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

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

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

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

nd_f4red = QTOS((Q)value);

}

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

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

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

}

ND mdptond(DP d);

Line 8684 ND mdptond(DP d)

Line 8837 ND mdptond(DP d)

ND r;

if ( OID(d) == 1 )

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

else {

NEWNM(m);

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

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

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

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

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

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

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;

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

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

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;

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

ci = invm(ci,mod);

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

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

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

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

((MQ)inv)->cont = invm(((MQ)inv)->cont,mod);

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;

}

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

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

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

((MQ)inv)->cont = invm(((MQ)inv)->cont,mod);

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;

}

Line 9012 void nd_f4_lf_trace(LIST f,LIST v,int trace,int homo,s

Line 9161 void nd_f4_lf_trace(LIST f,LIST v,int trace,int homo,s

nocheck = 0;

mindex = 0;

if ( Demand ) nd_demand = 1;

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

else nd_demand = 0;

nd_demand = 0;

/* setup modulus */

if ( trace < 0 ) {

trace = -trace;

nocheck = 1;

}

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

nd_init_ord(ord);

mrank = 0;

Line 9070 void nd_f4_lf_trace(LIST f,LIST v,int trace,int homo,s

Line 9213 void nd_f4_lf_trace(LIST f,LIST v,int trace,int homo,s

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

}

if ( MaxDeg > 0 ) nocheck = 1;

while ( 1 ) {

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

if ( Demand )

if ( ret )

nd_demand = 1;

cand = nd_f4_lf_trace_main(m,&perm);

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

if ( !ret || !cand ) {

if ( ret )

*rp = 0; return;

cand = nd_f4_lf_trace_main(m,&perm);

if ( !ret || !cand ) {

/* failure */

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

else m = get_lprime(++mindex);

continue;

}

if ( !ishomo && homo ) {

/* dehomogenization */

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

nd_init_ord(ord);

nd_setup_parameters(nvar,0);

}

nd_demand = 0;

cand = ndv_reducebase(cand,perm);

cand = ndv_reduceall(-2,cand);

cbpe = nd_bpe;

get_eg(&eg0);

if ( nocheck )

break;

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

else if ( trace > 1 ) {

/* failure */

*rp = 0; return;

} else {

/* try the next modulus */

m = get_lprime(++mindex);

/* reset the parameters */

if ( !ishomo && homo ) {

nd_init_ord(ord1);

nd_setup_parameters(nvar+1,wmax);

} else {

nd_init_ord(ord);

nd_setup_parameters(nvar,max);

}

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

fprintf(asir_out,"check=%.3fsec\n",eg_check.exectime+eg_check.gctime);

/* dp->p */

nd_bpe = cbpe;

nd_setup_parameters(nd_nvar,0);

Line 9178 NODE nd_f4_lf_trace_main(int m,int **indp)

Line 9299 NODE nd_f4_lf_trace_main(int m,int **indp)

}

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

if ( DP_Print )

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

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

sugar,eg_f4.exectime+eg_f4.gctime);

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

if ( !l0 ) continue;

Line 9215 NODE nd_f4_lf_trace_main(int m,int **indp)

Line 9336 NODE nd_f4_lf_trace_main(int m,int **indp)

}

if ( r || rm ) return 0;

}

conv_ilist(nd_demand,1,g,indp);

return g;

}

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