OpenXM_contrib2/asir2018/engine/nd.c - diff

Return to nd.c CVS log

Up to [local] / OpenXM_contrib2 / asir2018 / engine

Diff for /OpenXM_contrib2/asir2018/engine/nd.c between version 1.29 and 1.37

version 1.29, 2020/07/02 09:24:17

version 1.37, 2020/10/06 06:31:19

Line 1

/* $OpenXM: OpenXM_contrib2/asir2018/engine/nd.c,v 1.28 2020/06/30 01:52:17 noro Exp $ */

/* $OpenXM: OpenXM_contrib2/asir2018/engine/nd.c,v 1.36 2020/09/27 04:35:04 noro Exp $ */

#include "nd.h"

Line 18 NM _nm_free_list;

ND _nd_free_list;

ND_pairs _ndp_free_list;

NODE nd_hcf;

int Nsyz;

int Nsyz,Nsamesig;

Obj nd_top_weight;

Line 50 static NDV *nd_ps_trace;

static NDV *nd_ps_sym;

static NDV *nd_ps_trace_sym;

static RHist *nd_psh;

static int nd_psn,nd_pslen;

static int nd_psn,nd_pslen,nd_nbase;

static RHist *nd_red;

static int *nd_work_vector;

static int **nd_matrix;

Line 786 int ndl_module_compare(UINT *d1,UINT *d2)

extern DMMstack dmm_stack;

void _addtodl(int n,DL d1,DL d2);

void _adddl(int n,DL d1,DL d2,DL d3);

int _eqdl(int n,DL d1,DL d2);

int ndl_module_schreyer_compare(UINT *m1,UINT *m2)

Line 1222 void print_sig(SIG s)

Line 1223 void print_sig(SIG s)

fprintf(asir_out,">>*e%d",s->pos);

}

// assuming increasing order wrt signature

INLINE int ndl_find_reducer_s(UINT *dg,SIG sig)

{

RHist r;

Line 1236 INLINE int ndl_find_reducer_s(UINT *dg,SIG sig)

Line 1239 INLINE int ndl_find_reducer_s(UINT *dg,SIG sig)

tmp = (UINT *)MALLOC(wpd*sizeof(UINT));

}

d = ndl_hash_value(dg);

#if 1

for ( r = nd_red[d], k = 0; r; r = NEXT(r), k++ ) {

if ( ndl_equal(dg,DL(r)) ) {

return r->index;

}

#endif

singular = 0;

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

r = nd_psh[i];

Line 2476 get_eg(&eg2); add_eg(&eg_update,&eg1,&eg2);

Line 2481 get_eg(&eg2); add_eg(&eg_update,&eg1,&eg2);

}

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

FREENDP(l);

}

conv_ilist(nd_demand,0,g,indp);

if ( !checkonly && DP_Print ) { printf("nd_gb done. Number of nd_add=%d\n",Nnd_add); fflush(stdout); }

print_eg("update",&eg_update);

return g;

if ( DP_Print )

print_eg("update",&eg_update);

return g;

}

ND_pairs update_pairs_s(ND_pairs d,NODE g,int t,NODE *syz);

ND_pairs update_pairs_s(ND_pairs d,int t,NODE *syz);

ND_pairs nd_newpairs_s( NODE g, int t ,NODE *syz);

ND_pairs nd_newpairs_s(int t ,NODE *syz);

int nd_nf_pbucket_s(int mod,ND g,NDV *ps,int full,ND *nf);

int nd_nf_s(int mod,ND d,ND g,NDV *ps,int full,ND *nf);

Line 2606 ND_pairs remove_large_lcm(ND_pairs d)

Line 2613 ND_pairs remove_large_lcm(ND_pairs d)

struct oEGT eg_create,eg_newpairs,eg_merge;

NODE conv_ilist_s(int demand,int trace,int **indp);

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

{

int i,j,nh,sugar,stat;

NODE r,g,t;

NODE r,t,g;

ND_pairs d;

ND_pairs l;

ND h,nf,s,head,nf1;

Line 2622 NODE nd_sba_buch(int m,int ishomo,int **indp)

Line 2631 NODE nd_sba_buch(int m,int ishomo,int **indp)

NODE *syzlist;

int Nredundant;

DL lcm,quo,mul;

struct oEGT eg1,eg2,eg_update,eg_remove,eg_large;

struct oEGT eg1,eg2,eg_update,eg_remove,eg_large,eg_nf,eg_nfzero;

init_eg(&eg_remove);

syzlist = (NODE *)MALLOC(nd_psn*sizeof(NODE));

Nsyz = 0;

Nnd_add = 0;

Nredundant = 0;

g = 0; d = 0;

d = 0;

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

d = update_pairs_s(d,g,i,syzlist);

d = update_pairs_s(d,i,syzlist);

g = append_one(g,i);

}

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

for ( j = i+1; j < nd_psn; j++ ) {

Line 2645 init_eg(&eg_remove);

Line 2653 init_eg(&eg_remove);

init_eg(&eg_create);

init_eg(&eg_merge);

init_eg(&eg_large);

init_eg(&eg_nf);

init_eg(&eg_nfzero);

while ( d ) {

again:

if ( DP_Print ) {

Line 2671 again:

Line 2681 again:

d = nd_reconstruct(0,d);

goto again;

}

get_eg(&eg1);

#if USE_GEOBUCKET

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

#else

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

#endif

get_eg(&eg2);

if ( !stat ) {

NEXT(l) = d; d = l;

d = nd_reconstruct(0,d);

Line 2685 again:

Line 2697 again:

FREENDP(l);

} else if ( nf ) {

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

add_eg(&eg_nf,&eg1,&eg2);

hc = HCU(nf);

nd_removecont(m,nf);

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

nh = ndv_newps(m,nfv,0);

d = update_pairs_s(d,g,nh,syzlist);

d = update_pairs_s(d,nh,syzlist);

g = append_one(g,nh);

nd_sba_pos[sig->pos] = append_one(nd_sba_pos[sig->pos],nh);

FREENDP(l);

} else {

add_eg(&eg_nfzero,&eg1,&eg2);

// syzygy

get_eg(&eg1);

d = remove_spair_s(d,sig);

Line 2704 get_eg(&eg2); add_eg(&eg_remove,&eg1,&eg2);

Line 2717 get_eg(&eg2); add_eg(&eg_remove,&eg1,&eg2);

FREENDP(l);

}

conv_ilist(nd_demand,0,g,indp);

g = conv_ilist_s(nd_demand,0,indp);

if ( DP_Print ) {

printf("\nnd_sba done. nd_add=%d,Nsyz=%d,Nredundant=%d\n",Nnd_add,Nsyz,Nredundant);

printf("\nnd_sba done. nd_add=%d,Nsyz=%d,Nsamesig=%d,Nredundant=%d\n",Nnd_add,Nsyz,Nsamesig,Nredundant);

fflush(stdout);

print_eg("create",&eg_create);

print_eg("merge",&eg_merge);

print_eg("remove",&eg_remove);

print_eg("nf",&eg_nf);

print_eg("nfzero",&eg_nfzero);

printf("\n");

}

return g;

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

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

ND_pairs merge_pairs_s(ND_pairs d,ND_pairs d1);

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

ND_pairs update_pairs_s( ND_pairs d, int t,NODE *syz)

{

ND_pairs d1;

struct oEGT eg1,eg2,eg3;

if ( !g ) return d;

if ( !t ) return d;

get_eg(&eg1);

d1 = nd_newpairs_s(g,t,syz);

d1 = nd_newpairs_s(t,syz);

get_eg(&eg2); add_eg(&eg_create,&eg1,&eg2);

d = merge_pairs_s(d,d1);

get_eg(&eg3); add_eg(&eg_merge,&eg2,&eg3);

Line 3186 ND_pairs nd_newpairs( NODE g, int t )

Line 3201 ND_pairs nd_newpairs( NODE g, int t )

return r0;

}

int comp_sig(SIG s1,SIG s2)

{

#if 0

Line 3201 int comp_sig(SIG s1,SIG s2)

Line 3215 int comp_sig(SIG s1,SIG s2)

if ( nvar != nd_nvar ) {

nvar = nd_nvar; NEWDL(m1,nvar); NEWDL(m2,nvar);

}

// _ndltodl(DL(nd_psh[s1->pos]),m1);

#if 0

// _ndltodl(DL(nd_psh[s2->pos]),m2);

_copydl(nd_nvar,nd_sba_hm[s1->pos],m1);

_copydl(nd_nvar,nd_sba_hm[s2->pos],m2);

_addtodl(nd_nvar,s1->dl,m1);

_addtodl(nd_nvar,s2->dl,m2);

#else

_adddl(nd_nvar,s1->dl,nd_sba_hm[s1->pos],m1);

_adddl(nd_nvar,s2->dl,nd_sba_hm[s2->pos],m2);

#endif

ret = (*cmpdl)(nd_nvar,m1,m2);

if ( ret != 0 ) return ret;

else if ( s1->pos > s2->pos ) return 1;

Line 3296 ND_pairs merge_pairs_s(ND_pairs p1,ND_pairs p2)

Line 3313 ND_pairs merge_pairs_s(ND_pairs p1,ND_pairs p2)

r->next = q2; r = q2; q2 = q2->next;

} else {

ret = DL_COMPARE(q1->lcm,q2->lcm);

Nsamesig++;

if ( ret < 0 ) {

r->next = q1; r = q1; q1 = q1->next;

q2 = q2->next;

Line 3362 INLINE int __dl_redble(DL d1,DL d2,int nvar)

Line 3380 INLINE int __dl_redble(DL d1,DL d2,int nvar)

return 1;

}

ND_pairs nd_newpairs_s( NODE g, int t, NODE *syz)

ND_pairs nd_newpairs_s(int t, NODE *syz)

{

NODE h,s;

UINT *dl;

Line 3380 ND_pairs nd_newpairs_s( NODE g, int t, NODE *syz)

Line 3398 ND_pairs nd_newpairs_s( NODE g, int t, NODE *syz)

r0 = 0;

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

ret = _create_spair_s(i,t,_sp,_sig1,_sig2);

// for ( h = g; h; h = NEXT(h) ) {

// ret = _create_spair_s((long)BDY(h),t,_sp,_sig1,_sig2);

if ( ret ) {

spsig = _sp->sig;

for ( s = syz[spsig->pos]; s; s = s->next ) {

Line 3682 ND_pairs nd_minsugarp_s( ND_pairs d, ND_pairs *prest )

Line 3698 ND_pairs nd_minsugarp_s( ND_pairs d, ND_pairs *prest )

int msugar;

ND_pairs t,last;

#if 0

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

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

#else

msugar = (d->sig->dl->td)+nd_sba_hm[d->sig->pos]->td;

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

if ( ((t->sig->dl->td)+nd_sba_hm[t->sig->pos]->td) == msugar ) last = t;

#endif

*prest = last->next;

last->next = 0;

return d;

Line 4263 void nd_sba(LIST f,LIST v,int m,int homo,int retdp,int

Line 4273 void nd_sba(LIST f,LIST v,int m,int homo,int retdp,int

nd_module = 0;

nd_demand = 0;

parse_nd_option(current_option);

Nsamesig = 0;

if ( DP_Multiple )

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

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

Line 4334 void nd_sba(LIST f,LIST v,int m,int homo,int retdp,int

Line 4344 void nd_sba(LIST f,LIST v,int m,int homo,int retdp,int

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

NEXTNODE(r0,r);

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

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

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

}

if ( r0 ) NEXT(r) = 0;

MKLIST(*rp,r0);

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

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

int i,j,l,s,ord_l;

struct order_pair *op;

NEWDL(dl,n);

NEWDL_NOINIT(dl,n);

dl->td = TD(ndl);

d = dl->d;

if ( nd_blockmask ) {

Line 5582 ND_pairs nd_reconstruct(int trace,ND_pairs d)

Line 5592 ND_pairs nd_reconstruct(int trace,ND_pairs d)

return s0;

}

void nd_reconstruct_s(int trace,ND_pairs *d)

{

int i,obpe,oadv,h;

static NM prev_nm_free_list;

static ND_pairs prev_ndp_free_list;

RHist mr0,mr;

RHist r;

RHist *old_red;

ND_pairs s0,s,t;

EPOS oepos;

obpe = nd_bpe;

oadv = nmv_adv;

oepos = nd_epos;

if ( obpe < 2 ) nd_bpe = 2;

else if ( obpe < 3 ) nd_bpe = 3;

else if ( obpe < 4 ) nd_bpe = 4;

else if ( obpe < 5 ) nd_bpe = 5;

else if ( obpe < 6 ) nd_bpe = 6;

else if ( obpe < 8 ) nd_bpe = 8;

else if ( obpe < 10 ) nd_bpe = 10;

else if ( obpe < 16 ) nd_bpe = 16;

else if ( obpe < 32 ) nd_bpe = 32;

else error("nd_reconstruct_s : exponent too large");

nd_setup_parameters(nd_nvar,0);

prev_nm_free_list = _nm_free_list;

prev_ndp_free_list = _ndp_free_list;

_nm_free_list = 0;

_ndp_free_list = 0;

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

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

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

}

if ( trace )

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

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

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

}

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

s0 = 0;

for ( t = d[i]; t; t = NEXT(t) ) {

NEXTND_pairs(s0,s);

s->i1 = t->i1;

s->i2 = t->i2;

s->sig = t->sig;

SG(s) = SG(t);

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

}

d[i] = s0;

}

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;

}

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

for ( r = old_red[i]; r; r = NEXT(r) ) {

NEWRHist(mr);

mr->index = r->index;

SG(mr) = SG(r);

ndl_reconstruct(DL(r),DL(mr),obpe,oepos);

h = ndl_hash_value(DL(mr));

NEXT(mr) = nd_red[h];

nd_red[h] = mr;

mr->sig = r->sig;

}

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

old_red = 0;

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

NEWRHist(r); SG(r) = SG(nd_psh[i]);

ndl_reconstruct(DL(nd_psh[i]),DL(r),obpe,oepos);

r->sig = nd_psh[i]->sig;

nd_psh[i] = r;

}

if ( s0 ) NEXT(s) = 0;

prev_nm_free_list = 0;

prev_ndp_free_list = 0;

#if 0

GC_gcollect();

#endif

}

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

{

int n,i,ei,oepw,omask0,j,s,ord_l,l;

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

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

if ( indp ) *indp = ind;

}

NODE conv_ilist_s(int demand,int trace,int **indp)

{

int n,i,j;

int *ind;

NODE g0,g;

n = nd_psn;

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

g0 = 0;

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

ind[i] = i;

NEXTNODE(g0,g);

BDY(g) = (pointer)(demand?ndv_load(i):(trace?nd_ps_trace[i]:nd_ps[i]));

}

if ( g0 ) NEXT(g) = 0;

if ( indp ) *indp = ind;

return g0;

}

void parse_nd_option(NODE opt)

{

NODE t,p,u;

Line 10495 int nd_gauss_elim_mod64_s(mp_limb_t **mat,int *sugar,N

Line 10609 int nd_gauss_elim_mod64_s(mp_limb_t **mat,int *sugar,N

UINT *ct;

ND_pairs pair;

SIG sg;

int *used;

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

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 ( j = 0; j < col; j++ ) {

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

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

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

MOD128(a,c,md);

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

}

imin = -1;

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

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

if ( !used[i] && mat[i][j] ) break;

if ( mat[i][j] && (imin < 0 || comp_sig(sig[imin],sig[i]) > 0) ) imin = i;

if ( i == row ) {

if ( imin == -1 ) {

colstat[j] = 0;

continue;

} else

} else {

colstat[j] = 1;

if ( imin != rank ) {

used[i] = 1;

t = mat[imin]; mat[imin] = mat[rank]; mat[rank] = t;

ct = cmat[imin]; cmat[imin] = cmat[rank]; cmat[rank] = ct;

s = sugar[imin]; sugar[imin] = sugar[rank]; sugar[rank] = s;

sg = sig[imin]; sig[imin] = sig[rank]; sig[rank] = sg;

if ( spactive ) {

pair = spactive[imin]; spactive[imin] = spactive[rank];

spactive[rank] = pair;

}

/* column j is normalized */

s = sugar[rank];

s = sugar[i];

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

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

/* normalize pivot row */

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

for ( k = j, pk = mat[i]+j, ck = cmat[i]+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++ ) {

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

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

if ( (a = mat[k][j]) != 0 ) {

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

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

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

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

Nf4_red++;

}

rank++;

}

#if 1

rank = 0;

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

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

if ( colstat[j] ) {

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

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

if ( mat[i][j] ) break;

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

if ( j == col ) sugar[i] = -1;

}

else rank++;

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 && comp_sig(sig[i],sig[l]) > 0 ) {

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

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

Nf4_red++;

}

l--;

}

#endif

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

GCFREE(cmat);

return rank;

Line 10621 NODE nd_f4_red_mod64_main_s(int m,ND_pairs sp0,int nsp

Line 10716 NODE nd_f4_red_mod64_main_s(int m,ND_pairs sp0,int nsp

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

rank = nd_gauss_elim_mod64_s(spmat,spsugar,0,sprow,col,m,colstat,spsig);

r0 = 0;

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

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

NEXTNODE(r0,r);

if ( spsugar[i] >= 0 ) {

BDY(r) = vect64_to_ndv_s(spmat[i],col,s0vect);

NEXTNODE(r0,r);

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

BDY(r) = vect64_to_ndv_s(spmat[i],col,s0vect);

((NDV)BDY(r))->sig = spsig[i];

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

((NDV)BDY(r))->sig = spsig[i];

} else

syzlistp[spsig[i]->pos] = insert_sig(syzlistp[spsig[i]->pos],spsig[i]);

GCFREE(spmat[i]);

}

if ( r0 ) NEXT(r) = 0;

for ( ; i < sprow; i++ ) {

GCFREE(spmat[i]);

syzlistp[spsig[i]->pos] = insert_sig(syzlistp[spsig[i]->pos],spsig[i]);

}

get_eg(&eg2); init_eg(&eg_f4_2); add_eg(&eg_f4_2,&eg1,&eg2); add_eg(&f4_elim2,&eg1,&eg2);

init_eg(&eg_f4); add_eg(&eg_f4,&eg0,&eg2);

if ( DP_Print ) {

Line 10789 int nd_symbolic_preproc_s(PGeoBucket bucket,int trace,

Line 10882 int nd_symbolic_preproc_s(PGeoBucket bucket,int trace,

NODE nd_sba_f4(int m,int **indp)

{

int i,nh,stat,index,f4red;

int i,nh,stat,index,f4red,f4step;

NODE r,g,tn0,tn,node;

int col,rank,len,k,j,a,sugar,nbase,psugar,ms;

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

NODE r,g,rp0,nflist;

LIST l0,l1;

ND_pairs d,l,t;

ND spol,red;

ND h,nf;

NDV nf,redv;

NDV nfv;

NM s0,s;

union oNDC hc;

NODE rp0,srp0,nflist;

UINT *s0vect;

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

UINT c;

UINT **spmat;

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

int *colstat;

IndArray *imat;

int *rhead;

int spcol,sprow;

int sugar,sugarh;

PGeoBucket bucket;

struct oEGT eg0,eg1,eg_f4;

Z i1,i2,sugarq;

NODE *syzlist;

SIG sig;

struct oEGT eg0,eg1,eg_f4;

struct oEGT eg2,eg_update,eg_remove,eg_large,eg_nf,eg_nfzero;

Nf4_red=0;

g = 0; d = 0;

d = 0;

syzlist = (NODE *)MALLOC(nd_psn*sizeof(NODE));

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

d = update_pairs_s(d,g,i,syzlist);

d = update_pairs_s(d,i,syzlist);

g = append_one(g,i);

}

nd_nbase = nd_psn;

f4red = 1;

psugar = 0;

f4step = 0;

while ( d ) {

l = nd_minsugarp_s(d,&d);

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

if ( !l ) continue;

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

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

if ( ms == psugar && f4step >= 2 ) {

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

again:

bucket = create_pbucket();

l = d; d = d->next;

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

if ( small_lcm(l) ) {

if ( !stat ) {

if ( DP_Print ) fprintf(asir_out,"M");

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

continue;

NEXT(t) = d; d = l;

}

d = nd_reconstruct(0,d);

sig = l->sig;

continue;

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

}

if ( !stat ) {

if ( bucket->m < 0 ) continue;

NEXT(l) = d; d = l;

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

d = nd_reconstruct(0,d);

if ( !col ) {

goto again;

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

}

NEXT(t) = d; d = l;

get_eg(&eg1);

d = nd_reconstruct(0,d);

#if USE_GEOBUCKET

continue;

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

}

#else

if ( DP_Print ) fprintf(asir_out,"sugar=%d,",sugar);

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

l = remove_large_lcm(l);

#endif

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

get_eg(&eg2);

/* adding new bases */

if ( !stat ) {

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

NEXT(l) = d; d = l;

ND tmp,tmpred;

d = nd_reconstruct(0,d);

SIG sig;

goto again;

} else if ( stat == -1 ) {

nf = (NDV)BDY(r);

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

sig = nf->sig;

FREENDP(l);

tmp = ndvtond(m,nf);

} else if ( nf ) {

stat = nd_nf_s(m,0,tmp,nd_ps,!Top,&tmpred);

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

if ( stat < 0 ) {

add_eg(&eg_nf,&eg1,&eg2);

// top reducible

hc = HCU(nf);

if ( DP_Print ) { fprintf(asir_out,"S"); fflush(asir_out); }

nd_removecont(m,nf);

} else if ( tmpred ) {

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

nf = ndtondv(m,tmpred);

nh = ndv_newps(m,nfv,0);

ndv_removecont(m,nf);

nh = ndv_newps(m,nf,0);

d = update_pairs_s(d,nh,syzlist);

d = update_pairs_s(d,g,nh,syzlist);

nd_sba_pos[sig->pos] = append_one(nd_sba_pos[sig->pos],nh);

g = append_one(g,nh);

FREENDP(l);

} else {

add_eg(&eg_nfzero,&eg1,&eg2);

// syzygy

get_eg(&eg1);

d = remove_spair_s(d,sig);

get_eg(&eg2); add_eg(&eg_remove,&eg1,&eg2);

syzlist[sig->pos] = insert_sig(syzlist[sig->pos],sig);

}

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

FREENDP(l);

}

} else {

if ( ms != psugar ) f4step = 1;

else f4step++;

again2:

psugar = ms;

l = nd_minsugarp_s(d,&d);

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

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

goto again2;

}

if ( bucket->m < 0 ) continue;

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

if ( !col ) {

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

;

NEXT(t) = d; d = l;

d = nd_reconstruct(0,d);

goto again2;

}

if ( DP_Print ) fprintf(asir_out,"\nsugar=%d,",psugar);

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

/* adding new bases */

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

nfv = (NDV)BDY(r);

ndv_removecont(m,nfv);

nh = ndv_newps(m,nfv,0);

d = update_pairs_s(d,nh,syzlist);

nd_sba_pos[nfv->sig->pos] = append_one(nd_sba_pos[nfv->sig->pos],nh);

}

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

for ( r = syzlist[i]; r; r = NEXT(r) )

d = remove_spair_s(d,(SIG)BDY(r));

d = remove_large_lcm(d);

if ( DP_Print ) {

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

}

f4red++;

}

// YYY

// for ( r = syzlist; r; r = NEXT(r) )

// d = remove_spair_s(d,(SIG)BDY(r));

if ( DP_Print ) {

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

}

f4red++;

if ( nd_f4red && f4red > nd_f4red ) break;

if ( nd_rank0 && !nflist ) break;

}

if ( DP_Print ) {

fprintf(asir_out,"number of red=%d,",Nf4_red);

fprintf(asir_out,"\nnumber of red=%d,",Nf4_red);

}

conv_ilist(nd_demand,0,g,indp);

g = conv_ilist_s(nd_demand,0,indp);

return g;

}

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