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.28 and 1.38

version 1.28, 2020/06/30 01:52:17

version 1.38, 2020/10/26 02:41:05

Line 1

/* $OpenXM: OpenXM_contrib2/asir2018/engine/nd.c,v 1.27 2020/06/25 02:53:31 noro Exp $ */

/* $OpenXM: OpenXM_contrib2/asir2018/engine/nd.c,v 1.37 2020/10/06 06:31:19 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 66 static int *nd_poly_weight,*nd_module_weight;

static NODE nd_tracelist;

static NODE nd_alltracelist;

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

static int nd_f4_td,nd_sba_f4step,nd_sba_pot,nd_sba_largelcm;

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

static DL *nd_sba_hm;

static NODE *nd_sba_pos;

NumberField get_numberfield();

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

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

Line 787 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 1221 void print_sig(SIG s)

Line 1224 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 1235 INLINE int ndl_find_reducer_s(UINT *dg,SIG sig)

Line 1240 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 1250 INLINE int ndl_find_reducer_s(UINT *dg,SIG sig)

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

quo->pos = nd_psh[i]->sig->pos;

ret = comp_sig(sig,quo);

if ( ret > 0 ) { singular = 0; break; }

if ( ret == 0 ) { singular = 1; }

if ( ret == 0 ) { /* fprintf(asir_out,"s"); fflush(asir_out); */ singular = 1; }

}

if ( singular ) return -1;

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

Line 2482 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 2543 ND_pairs remove_spair_s(ND_pairs d,SIG sig)

Line 2552 ND_pairs remove_spair_s(ND_pairs d,SIG sig)

return (ND_pairs)root.next;

}

int _dl_redble_ext(DL,DL,DL,int);

int small_lcm(ND_pairs l)

{

SIG sig;

int i;

NODE t;

static DL lcm,mul,quo;

static int nvar;

if ( nd_sba_largelcm ) return 0;

if ( nvar < nd_nvar ) {

nvar = nd_nvar; NEWDL(lcm,nvar); NEWDL(quo,nvar); NEWDL(mul,nvar);

}

sig = l->sig;

_ndltodl(l->lcm,lcm);

#if 0

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

if ( sig->pos == nd_psh[i]->sig->pos &&

_dl_redble(DL(nd_psh[i]->sig),DL(sig),nd_nvar) ) {

_dl_redble_ext(DL(nd_psh[i]->sig),DL(sig),quo,nd_nvar) ) {

_copydl(nd_nvar,DL(sig),quo);

_subfromdl(nd_nvar,DL(nd_psh[i]->sig),quo);

_ndltodl(DL(nd_psh[i]),mul);

_addtodl(nd_nvar,quo,mul);

if ( (*cmpdl)(nd_nvar,lcm,mul) > 0 )

Line 2568 int small_lcm(ND_pairs l)

Line 2580 int small_lcm(ND_pairs l)

}

if ( i < nd_psn ) return 1;

else return 0;

#else

for ( t = nd_sba_pos[sig->pos]; t; t = t->next ) {

i = (long)BDY(t);

if ( _dl_redble_ext(DL(nd_psh[i]->sig),DL(sig),quo,nd_nvar) ) {

_ndltodl(DL(nd_psh[i]),mul);

_addtodl(nd_nvar,quo,mul);

if ( (*cmpdl)(nd_nvar,lcm,mul) > 0 )

break;

}

if ( t ) return 1;

else return 0;

#endif

}

ND_pairs remove_large_lcm(ND_pairs d)

Line 2590 ND_pairs remove_large_lcm(ND_pairs d)

Line 2615 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,nh,sugar,stat;

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 2603 NODE nd_sba_buch(int m,int ishomo,int **indp)

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

P cont;

LIST list;

SIG sig;

NODE syzlist;

NODE *syzlist;

int Nredundant;

DL lcm,quo,mul;

struct oEGT eg1,eg2,eg_update,eg_remove;

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

init_eg(&eg_remove);

syzlist = 0;

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

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

NEWSIG(sig); sig->pos = j;

_copydl(nd_nvar,nd_sba_hm[i],sig->dl);

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

}

sugar = 0;

NEWDL(lcm,nd_nvar); NEWDL(quo,nd_nvar); NEWDL(mul,nd_nvar);

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 2648 again:

Line 2683 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 2662 again:

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

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

syzlist = insert_sig(syzlist,sig);

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

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

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 3111 ND_pairs update_pairs( ND_pairs d, NODE /* of index */

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

Line 3203 ND_pairs nd_newpairs( NODE g, int t )

return r0;

}

int comp_sig(SIG s1,SIG s2)

{

#if 0

if ( nd_sba_pot ) {

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

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

else return (*cmpdl)(nd_nvar,s1->dl,s2->dl);

#else

} else {

static DL m1,m2;

static int nvar;

int ret;

if ( nvar != nd_nvar ) {

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

}

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

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

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

if ( ret != 0 ) return ret;

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

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

else return 0;

}

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

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

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

if ( ret != 0 ) return ret;

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

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

else return 0;

#endif

}

int _create_spair_s(int i1,int i2,ND_pairs sp,SIG sig1,SIG sig2)

Line 3272 ND_pairs merge_pairs_s(ND_pairs p1,ND_pairs p2)

Line 3308 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 3323 ND_pairs insert_pair_s(ND_pairs l,ND_pairs s)

Line 3360 ND_pairs insert_pair_s(ND_pairs l,ND_pairs s)

}

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

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

{

int i;

if ( d1->td > d2->td )

return 0;

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

if ( d1->d[i] > d2->d[i] )

break;

if ( i >= 0 )

return 0;

else

return 1;

}

ND_pairs nd_newpairs_s(int t, NODE *syz)

{

NODE h,s;

UINT *dl;

int ts,ret,i;

ND_pairs r,r0,_sp,sp;

SIG _sig1,_sig2,spsig,tsig;

SIG spsig,tsig;

static int nvar;

static SIG _sig1,_sig2;

struct oEGT eg1,eg2,eg3,eg4;

NEWND_pairs(_sp);

NEWSIG(_sig1); NEWSIG(_sig2);

if ( !_sig1 || nvar != nd_nvar ) {

nvar = nd_nvar; NEWSIG(_sig1); NEWSIG(_sig2);

}

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; s; s = s->next ) {

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

tsig = (SIG)s->body;

if ( tsig->pos == spsig->pos && _dl_redble(DL(tsig),DL(spsig),nd_nvar) )

if ( _dl_redble(DL(tsig),DL(spsig),nd_nvar) )

break;

}

if ( s == 0 ) {

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

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

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

NEWDL(nd_sba_hm[i],nd_nvar);

_ndltodl(DL(nd_psh[i]),nd_sba_hm[i]);

}

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

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

j = nd_psh[i]->sig->pos;

nd_sba_pos[j] = append_one(nd_sba_pos[j],i);

}

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

return 1;

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

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

int *perm;

EPOS oepos;

int obpe,oadv,ompos,cbpe;

struct oEGT eg0,eg1,egconv;

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 4281 void nd_sba(LIST f,LIST v,int m,int homo,int retdp,int

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

x = ndv_reducebase(x,perm);

x = ndv_reduceall(m,x);

nd_setup_parameters(nd_nvar,0);

get_eg(&eg0);

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

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

print_eg("conv",&egconv); fprintf(asir_out,"\n");

}

void nd_gr_postproc(LIST f,LIST v,int m,struct order_spec *ord,int do_check,LIST *rp)

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

Line 4860 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 5530 ND_pairs nd_reconstruct(int trace,ND_pairs d)

Line 5587 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 7852 NODE nd_f4(int m,int checkonly,int **indp)

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

if ( nflist ) nd_last_nonzero = f4red;

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

nf = (NDV)BDY(r);

if ( nd_f4_td ) SG(nf) = nd_tdeg(nf);

ndv_removecont(m,nf);

if ( !m && nd_nalg ) {

ND nf1;

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

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

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_sugarweight = 0; nd_f4red =0; nd_rank0 = 0;

nd_f4red =0;

nd_f4_td = 0; nd_sba_f4step = 2; nd_sba_pot = 0; nd_sba_largelcm = 0;

nd_rank0 = 0;

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

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

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

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

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

nd_gentrace = value?1:0;

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

nd_gensyz = value?1:0;

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

nd_nora = value?1:0;

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

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

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++] = ZTOS((Q)BDY(p));

nd_gbblock[i++] = s+ZTOS((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") )

Line 9444 void parse_nd_option(NODE opt)

Line 9605 void parse_nd_option(NODE opt)

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

nd_lf = value?1:0;

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

if ( value ) {

u = BDY((LIST)value);

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

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

}

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

nd_f4red = ZTOS((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] = ZTOS((Q)BDY(u));

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

nd_f4_td = value?1:0;

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

nd_sba_f4step = value?ZTOS((Q)value):0;

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

nd_sba_pot = value?1:0;

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

nd_sba_largelcm = value?1:0;

}

ND mdptond(DP d);

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

Line 10612 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 10540 NODE nd_f4_red_mod64_main_s(int m,ND_pairs sp0,int nsp

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

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

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

if ( !spol ) {

*syzlistp = insert_sig(*syzlistp,sp->sig);

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

continue;

}

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

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

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

spsig[sprow] = sp->sig;

sprow++;

} else {

*syzlistp = insert_sig(*syzlistp,sp->sig);

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

}

nd_free(spol);

}

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

Line 10719 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 = insert_sig(*syzlistp,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 10737 int nd_symbolic_preproc_s(PGeoBucket bucket,int trace,

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

NODE *syzlist;

SIG sig;

struct oEGT eg0,eg1,eg_f4;

Z i1,i2,sugarq;

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

NODE syzlist;

Nf4_red=0;

g = 0; d = 0;

d = 0;

syzlist = 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 >= nd_sba_f4step ) {

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 {

syzlist = insert_sig(syzlist,sig);

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

if ( nd_f4_td ) SG(nfv) = nd_tdeg(nfv);

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

}

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>