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.46 and 1.64

version 1.46, 2021/01/25 00:39:52

version 1.64, 2022/03/09 07:50:51

Line 1

/* $OpenXM: OpenXM_contrib2/asir2018/engine/nd.c,v 1.45 2021/01/11 08:37:44 noro Exp $ */

/* $OpenXM: OpenXM_contrib2/asir2018/engine/nd.c,v 1.63 2022/01/13 08:15:02 noro Exp $ */

#include "nd.h"

void print_siglist(NODE l);

int Nnd_add,Nf4_red,NcriB,NcriMF,Ncri2,Npairs;

NODE nd_hpdata;

int Nnd_add,Nf4_red,NcriB,NcriMF,Ncri2,Npairs,Nnewpair;

struct oEGT eg_search,f4_symb,f4_conv,f4_elim1,f4_elim2;

int diag_period = 6;

Line 69 static NODE nd_tracelist;

Line 70 static NODE nd_tracelist;

static NODE nd_alltracelist;

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

static int nd_f4_td,nd_sba_f4step,nd_sba_pot,nd_sba_largelcm,nd_sba_dontsort,nd_sba_redundant_check;

static int nd_top,nd_sba_syz,nd_sba_inputisgb;

static int nd_top,nd_sba_syz,nd_sba_inputisgb,nd_sba_heu;

static int *nd_gbblock;

static NODE nd_nzlist,nd_check_splist;

static int nd_splist;

Line 92 struct comp_sig_spec {

Line 93 struct comp_sig_spec {

struct comp_sig_spec *nd_sba_modord;

DL ndltodl(int n,UINT *ndl);

NumberField get_numberfield();

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

void nd_det_reconstruct(NDV **dm,int n,int j,NDV d);

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

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

_ndltodl(tmp,DL(quo));

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

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

_adddl(nd_nvar,DL(quo),nd_sba_hm[quo->pos],DL2(quo));

ret = comp_sig(sig,quo);

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

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

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

}

Line 1707 int nd_nf_s(int mod,ND d,ND g,NDV *ps,int full,ND *rp)

Line 1711 int nd_nf_s(int mod,ND d,ND g,NDV *ps,int full,ND *rp)

nd_removecont2(d,g);

hmag = ((double)p_mag(HCP(g)))*nd_scale;

}

if ( nd_gentrace ) {

/* Trace=[div,index,mul,ONE] */

STOZ(index,iq);

nmtodp(mod,mul,&dmul);

node = mknode(4,div,iq,dmul,ONE);

}

MKLIST(hist,node);

MKNODE(node,hist,nd_tracelist); nd_tracelist = node;

} else if ( index == -1 ) {

// singular top reducible

return -1;

Line 2412 int do_diagonalize(int sugar,int m)

Line 2424 int do_diagonalize(int sugar,int m)

LIST l;

Z iq;

if ( diag_period == 0 ) return 1;

for ( i = nd_psn-1; i >= 0 && SG(nd_psh[i]) == sugar; i-- ) {

if ( nd_gentrace ) {

/* Trace = [1,index,1,1] */

Line 2467 LIST compute_splist()

Line 2480 LIST compute_splist()

return l0;

}

typedef struct oHPDATA {

int n;

P hn; // HP(t)=hn(t)/((1-t^w0)*...*(1-t^w(n-1)))

VECT x; // BDY(x)[i] = <<0,...,1,...,0>>

int *w;

} *HPDATA;

void make_reduced(VECT b,int nv);

void mhp_rec(VECT b,VECT x,P t,P *r);

P mhp_ctop(P *r,P *plist,int n);

DL monomial_colon(DL a,DL b,int n);

LIST dp_monomial_hilbert_poincare(VECT b,VECT x);

LIST dp_monomial_hilbert_poincare_weight(VECT b,VECT x,int *w);

void setup_hpdata(HPDATA final,HPDATA current)

{

int n,i,wlen;

DL *p;

VECT b,x;

DL dl;

LIST weight;

LIST ret;

int *w;

NODE nd;

final->n = n = nd_nvar;

final->hn = (P)BDY(nd_hpdata);

#if 0

if ( NEXT(nd_hpdata) != 0 && (weight=(LIST)BDY(NEXT(nd_hpdata))) != 0 ) {

wlen = length(BDY(weight));

if ( n != wlen )

error("setup_hpdata : inconsistent weight length");

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

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

w[i] = ZTOS((Z)BDY(nd));

} else

w = 0;

#else

w = current_dl_weight_vector;

#endif

MKVECT(x,n);

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

NEWDL(dl,n); dl->d[i] = 1; dl->td = 1; BDY(x)[i] = dl;

}

final->x = x;

final->w = w;

MKVECT(b,nd_psn); p = (DL *)BDY(b);

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

p[i] = ndltodl(n,nd_psh[i]->dl);

}

if ( w ) {

ret = dp_monomial_hilbert_poincare_weight(b,x,w);

} else

ret = dp_monomial_hilbert_poincare(b,x);

current->n = n;

current->hn = (P)BDY(BDY(ret));

current->x = x;

current->w = w;

}

int comp_hn(P a, P b)

{

P s;

DCP dc;

subp(CO,a,b,&s);

if ( !s ) return -1;

else if ( OID(s) == 1 ) return 0;

else {

for ( dc = DC(s); NEXT(dc); dc = NEXT(dc) );

return (int)ZTOS((Z)dc->d);

}

void update_hpdata(HPDATA current,int nh)

{

NODE data1,nd,t;

DL new,dl;

int len,i,n;

Z dz;

DL *p;

VECT b,head;

P tv,td,s,hn,hpoly;

LIST list1;

n = nd_nvar;

new = ndltodl(n,nd_psh[nh]->dl);

MKVECT(b,nh); p = (DL *)BDY(b);

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

p[i] = monomial_colon(ndltodl(n,nd_psh[i]->dl),new,n);

}

// compute HP(I:new)

if ( current->w )

list1 = dp_monomial_hilbert_poincare_weight(b,current->x,current->w);

else

list1 = dp_monomial_hilbert_poincare(b,current->x);

data1 = BDY((LIST)list1);

// HP(I+<new>) = H(I)-t^d*H(I:new), d=tdeg(new)

makevar("t",&tv); UTOZ(new->td,dz);

pwrp(CO,tv,dz,&td);

mulp(CO,(P)ARG0(data1),td,&s);

subp(CO,current->hn,s,&hn);

current->hn = hn;

}

ND_pairs nd_remove_same_sugar( ND_pairs d, int sugar)

{

struct oND_pairs root;

ND_pairs prev,cur;

int i;

root.next = d;

prev = &root; cur = d;

i = 0;

while ( cur ) {

if ( SG(cur) == sugar ) {

prev->next = cur->next;

i++;

} else

prev = cur;

cur = cur->next;

}

if ( DP_Print && i ) fprintf(asir_out,"[%d]",i);

return root.next;

}

/* return value = 0 => input is not a GB */

NODE nd_gb(int m,int ishomo,int checkonly,int gensyz,int **indp)

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

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

int Nnfnz = 0,Nnfz = 0;

P cont;

LIST list;

struct oHPDATA current_hpdata,final_hpdata;

int final_hpvalue;

struct oEGT eg1,eg2,eg_update;

init_eg(&eg_update);

Line 2493 init_eg(&eg_update);

Line 2636 init_eg(&eg_update);

g = update_base(g,i);

}

sugar = 0;

if ( nd_hpdata ) {

if ( DP_Print ) fprintf(asir_out,"Hilbert driven algorithm.\n");

setup_hpdata(&final_hpdata,&current_hpdata);

}

while ( d ) {

again:

l = nd_minp(d,&d);

Line 2566 get_eg(&eg1);

Line 2713 get_eg(&eg1);

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

g = update_base(g,nh);

FREENDP(l);

if ( nd_hpdata ) {

int dg,sugar0;

update_hpdata(&current_hpdata,nh);

dg = comp_hn(final_hpdata.hn,current_hpdata.hn);

if ( dg < 0 ) {

int d_len;

for ( d_len = 0; d; d = d->next, d_len++);

fprintf(asir_out,"[%d] We found a gb\n",d_len);

}

sugar0 = sugar;

while ( d && dg > sugar0 ) {

d = nd_remove_same_sugar(d,sugar0);

sugar0++;

}

} else {

Nnfz++;

if ( nd_gentrace && gensyz ) {

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

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

MKNODE(t,list,nd_alltracelist);

nd_alltracelist = t; nd_tracelist = 0;

}

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

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

FREENDP(l);

}

conv_ilist(nd_demand,0,g,indp);

if ( !checkonly && DP_Print ) {

printf("\nnd_gb done. Nnd_add=%d,Npairs=%d, Nnfnz=%d,Nnfz=%d,",Nnd_add,Npairs,Nnfnz,Nnfz);

fprintf(asir_out,"\nnd_gb done. Nbase=%d,Nnd_add=%d,Npairs=%d, Nnfnz=%d,Nnfz=%d,",nd_psn,Nnd_add,Npairs,Nnfnz,Nnfz);

printf("Nremoved=%d\n",NcriB+NcriMF+Ncri2);

fprintf(asir_out,"Nremoved=%d\n",NcriB+NcriMF+Ncri2);

fflush(asir_out);

}

if ( DP_Print ) {

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

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

}

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

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

ND_pairs nd_newpairs_s(int t ,NODE *syz);

ND_pairs *nd_newpairs_array_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 2600 int nd_nf_s(int mod,ND d,ND g,NDV *ps,int full,ND *nf)

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

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

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

extern int (*cmpdl)(int n,DL d1,DL d2);

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

int primitive_irred(ND p,SIG sig)

{

static int wpd=0,dlen=0;

static DL dquo,squo;

static UINT *quo;

int i;

if ( dlen < nd_nvar ) {

NEWDL(dquo,nd_nvar);

NEWDL(squo,nd_nvar);

dlen = nd_nvar;

}

if ( wpd != nd_wpd ) {

wpd = nd_wpd;

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

}

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

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

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

if ( ndl_reducible(HDL(p),DL(nd_psh[i])) ) {

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

ndl_sub(HDL(p),DL(nd_psh[i]),quo);

_ndltodl(quo,dquo);

if ( _eqdl(nd_nvar,squo,dquo) )

return 0;

}

return 1;

}

NODE insert_sig(NODE l,SIG s)

{

int pos;

Line 2653 ND_pairs remove_spair_s(ND_pairs d,SIG sig)

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

Line 2703 ND_pairs find_smallest_lcm(ND_pairs l)

Line 2897 ND_pairs find_smallest_lcm(ND_pairs l)

NODE t;

ND_pairs r;

struct oSIG sig1;

static DL mul,quo,minlm;

static DL mul,quo,quo2,minlm;

static int nvar = 0;

if ( nvar < nd_nvar ) {

nvar = nd_nvar;

NEWDL(quo,nvar); NEWDL(mul,nvar);

NEWDL(quo,nvar); NEWDL(quo2,nvar); NEWDL(mul,nvar);

NEWDL(minlm,nvar);

}

sig = l->sig;

Line 2721 ND_pairs find_smallest_lcm(ND_pairs l)

Line 2915 ND_pairs find_smallest_lcm(ND_pairs l)

_addtodl(nd_nvar,quo,mul);

if ( (*cmpdl)(nd_nvar,minlm,mul) > 0 ) {

minindex = i;

break;

_copydl(nd_nvar,mul,minlm);

}

// l->lcm is minimal; return l itself

if ( minindex < 0 ) return l;

else return 0;

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

if ( i == minindex ) continue;

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

Line 2734 ND_pairs find_smallest_lcm(ND_pairs l)

Line 2930 ND_pairs find_smallest_lcm(ND_pairs l)

_addtodl(nd_nvar,nd_ps[i]->sig->dl,quo);

sig1.pos = nd_ps[i]->sig->pos;

sig1.dl = quo;

sig1.dl2 = quo2;

_adddl(nd_nvar,sig1.dl,nd_sba_hm[sig1.pos],sig1.dl2);

if ( comp_sig(sig,&sig1) > 0 ) {

// printf("X");

NEWND_pairs(r);

Line 2792 SIG trivial_sig(int i,int j)

Line 2990 SIG trivial_sig(int i,int j)

if ( nvar != nd_nvar ) {

nvar = nd_nvar; NEWDL(lcm,nvar); NEWDL(sigi.dl,nvar); NEWDL(sigj.dl,nvar);

NEWDL(sigi.dl2,nvar); NEWDL(sigj.dl2,nvar);

}

if ( nd_sba_inputisgb != 0 ) {

lcm_of_DL(nd_nvar,nd_sba_hm[i],nd_sba_hm[j],lcm);

sigi.pos = i; _subdl(nd_nvar,lcm,nd_sba_hm[i],sigi.dl);

_copydl(nd_nvar,lcm,sigi.dl2);

sigj.pos = j; _subdl(nd_nvar,lcm,nd_sba_hm[j],sigj.dl);

_copydl(nd_nvar,lcm,sigj.dl2);

if ( comp_sig(&sigi,&sigj) > 0 ) sig = dup_sig(&sigi);

else sig = dup_sig(&sigj);

} else {

sigi.pos = i; _copydl(nd_nvar,nd_sba_hm[j],sigi.dl);

_adddl(nd_nvar,sigi.dl,nd_sba_hm[i],sigi.dl2);

sigj.pos = j; _copydl(nd_nvar,nd_sba_hm[i],sigj.dl);

_adddl(nd_nvar,sigj.dl,nd_sba_hm[j],sigj.dl2);

if ( comp_sig(&sigi,&sigj) > 0 ) sig = dup_sig(&sigi);

else sig = dup_sig(&sigj);

}

return sig;

}

int nd_minsig(ND_pairs *d)

{

int min,i,ret;

min = -1;

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

if ( d[i] != 0 ) {

if ( min < 0 ) min = i;

else {

ret = comp_sig(d[i]->sig,d[min]->sig);

if ( ret < 0 ) min = i;

}

return min;

}

int dlength(ND_pairs d)

{

int i;

for ( i = 0; d; d = d->next, i++ );

return i;

}

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

{

int i,j,nh,sugar,stat,pos;

NODE r,t,g;

ND_pairs d;

ND_pairs *d;

ND_pairs l,l1;

ND h,nf,s,head,nf1;

NDV nfv;

Line 2822 NODE nd_sba_buch(int m,int ishomo,int **indp,NODE *syz

Line 3049 NODE nd_sba_buch(int m,int ishomo,int **indp,NODE *syz

LIST list;

SIG sig;

NODE *syzlist;

int ngen;

int ngen,ind;

int Nnominimal,Nredundant;

DL lcm,quo,mul;

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

struct oHPDATA final_hpdata,current_hpdata;

int Nnfs=0,Nnfz=0,Nnfnz=0;

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

struct oEGT eg_minsig,eg_smallest,eg_removecont,eg_hpdata,eg_updatepairs,eg_sbabuch,eg_sp;

int Nnfs=0,Nnfz=0,Nnfnz=0,dlen,nsyz;

init_eg(&eg_remove);

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

d = (ND_pairs *)MALLOC(nd_psn*sizeof(ND_pairs));

nd_nbase = nd_psn;

Nsyz = 0;

Nnd_add = 0;

Nnominimal = 0;

Nredundant = 0;

d = 0;

ngen = nd_psn;

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

if ( !do_weyl || nd_sba_inputisgb ) {

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

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

sig = trivial_sig(i,j);

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

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

sig = trivial_sig(i,j);

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

}

dlen = 0;

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

d = update_pairs_s(d,i,syzlist);

dlen += update_pairs_array_s(d,i,syzlist);

}

sugar = 0;

pos = 0;

if ( nd_hpdata ) {

setup_hpdata(&final_hpdata,&current_hpdata);

}

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

init_eg(&eg_sp);

init_eg(&eg_create);

init_eg(&eg_merge);

init_eg(&eg_minsig);

init_eg(&eg_smallest);

init_eg(&eg_large);

init_eg(&eg_nf);

init_eg(&eg_nfzero);

while ( d ) {

init_eg(&eg_removecont);

again:

init_eg(&eg_updatepairs);

if ( DP_Print ) {

init_eg(&eg_hpdata);

int len;

init_eg(&eg_sbabuch);

ND_pairs td;

get_eg(&eg3);

for ( td = d, len=0; td; td = td->next, len++)

while ( 1 ) {

;

if ( DP_Print && !nd_hpdata && dlen%1000 == 0 ) fprintf(asir_out,"(%d)",dlen);

if ( !(len%100) ) fprintf(asir_out,"(%d)",len);

again :

}

get_eg(&eg1);

l = d; d = d->next;

ind = nd_minsig(d);

#if 0

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

if ( small_lcm(l) ) {

if ( ind < 0 ) break;

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

l = d[ind];

Nnominimal++;

// printf("(%d,%d)",l->i1,l->i2); print_sig(l->sig); printf("\n");

continue;

get_eg(&eg1);

}

if ( SG(l) != sugar ) {

sugar = SG(l);

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

}

sig = l->sig;

if ( DP_Print && nd_sba_pot ) {

if ( sig->pos != pos ) {

fprintf(asir_out,"[%d]",sig->pos);

pos = sig->pos;

}

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

#else

// if ( l->sig->dl->td == 0 )

// if ( DP_Print ) print_sig(l->sig);

l1 = find_smallest_lcm(l);

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

if ( l1 == 0 ) {

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

d[ind] = d[ind]->next; dlen--;

// if ( DP_Print && !nd_hpdata ) fprintf(asir_out,"M");

Nnominimal++;

continue;

}

Line 2900 again:

Line 3125 again:

pos = sig->pos;

}

get_eg(&eg1);

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

#endif

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

if ( !stat ) {

NEXT(l) = d; d = l;

nd_reconstruct_s(0,d);

d = nd_reconstruct(0,d);

goto again;

}

get_eg(&eg1);

#if USE_GEOBUCKET

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

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

#else

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

#endif

get_eg(&eg2);

if ( !stat ) {

NEXT(l) = d; d = l;

nd_reconstruct_s(0,d);

d = nd_reconstruct(0,d);

goto again;

} else if ( stat == -1 ) {

d[ind] = d[ind]->next; dlen--;

Nnfs++;

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

FREENDP(l);

} else if ( nf ) {

d[ind] = d[ind]->next; dlen--;

Nnfnz++;

if ( DP_Print ) {

if ( nd_sba_redundant_check ) {

Line 2937 get_eg(&eg2);

Line 3162 get_eg(&eg2);

}

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

hc = HCU(nf);

nd_removecont(m,nf);

get_eg(&eg1);

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

nd_removecont(m,nf);

nh = ndv_newps(m,nfv,0);

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

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

nh = ndv_newps(m,nfv,0);

get_eg(&eg1);

dlen += update_pairs_array_s(d,nh,syzlist);

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

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

if ( nd_hpdata ) {

int dg,sugar0;

d = update_pairs_s(d,nh,syzlist);

get_eg(&eg1);

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

update_hpdata(&current_hpdata,nh);

FREENDP(l);

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

dg = comp_hn(final_hpdata.hn,current_hpdata.hn);

// if ( !compp(CO,final_hpdata.hn,current_hpdata.hn) )

if ( dg < 0 ) {

if ( DP_Print ) { printf("\nWe found a gb.\n"); }

break;

} else if ( nd_sba_heu == 1 ) {

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

sugar0 = sugar;

while ( d[i] && dg > sugar0 ) {

d[i] = nd_remove_same_sugar(d[i],sugar0);

sugar0++;

}

} else {

d[ind] = d[ind]->next; dlen--;

Nnfz++;

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

// syzygy

get_eg(&eg1);

d = remove_spair_s(d,sig);

nsyz = Nsyz;

d[sig->pos] = remove_spair_s(d[sig->pos],sig);

dlen -= Nsyz-nsyz;

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

}

get_eg(&eg4); add_eg(&eg_sbabuch,&eg3,&eg4);

g = conv_ilist_s(nd_demand,0,indp);

if ( DP_Print ) {

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

printf("\ndlen=%d,nd_sba done. nd_add=%d,Nsyz=%d,Nsamesig=%d,Nnominimal=%d\n",dlen,Nnd_add,Nsyz,Nsamesig,Nnominimal);

printf("Nnfnz=%d,Nnfz=%d,Nnfsingular=%d\n",Nnfnz,Nnfz,Nnfs);

printf("Nbase=%d,Nnfnz=%d,Nnfz=%d,Nnfsingular=%d\n",nd_psn,Nnfnz,Nnfz,Nnfs);

fflush(stdout);

if ( nd_sba_redundant_check )

printf("Nredundant=%d\n",Nredundant);

fflush(stdout);

print_eg("sp",&eg_sp);

print_eg("create",&eg_create);

print_eg("merge",&eg_merge);

print_eg("minsig",&eg_minsig);

print_eg("smallest",&eg_smallest);

print_eg("remove",&eg_remove);

printf("\n");

print_eg("nf",&eg_nf);

print_eg("nfzero",&eg_nfzero);

print_eg("removecont",&eg_removecont);

print_eg("updatepairs",&eg_updatepairs);

print_eg("hpdata",&eg_hpdata);

print_eg("total",&eg_sbabuch);

printf("\n");

}

if ( nd_sba_syz ) {

print_eg("remove",&eg_remove);

print_eg("nf",&eg_nf);

print_eg("nfzero",&eg_nfzero);

printf("\n");

}

if ( nd_sba_syz ) {

NODE hsyz,tsyz,prev;

hsyz = 0;

Line 3080 int do_diagonalize_trace(int sugar,int m)

Line 3346 int do_diagonalize_trace(int sugar,int m)

Z iq;

P cont,cont1;

if ( diag_period == 0 ) return 1;

for ( i = nd_psn-1; i >= 0 && SG(nd_psh[i]) == sugar; i-- ) {

if ( nd_gentrace ) {

/* Trace = [1,index,1,1] */

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

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

int diag_count = 0;

P cont;

LIST list;

struct oHPDATA current_hpdata,final_hpdata;

int final_hpvalue;

init_eg(&eg_monic);

init_eg(&eg_invdalg);

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

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

g = update_base(g,i);

}

sugar = 0;

if ( nd_hpdata ) {

if ( DP_Print ) fprintf(asir_out,"Hilbert driven algorithm.\n");

setup_hpdata(&final_hpdata,&current_hpdata);

}

while ( d ) {

again:

l = nd_minp(d,&d);

Line 3255 again:

Line 3529 again:

}

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

g = update_base(g,nh);

if ( nd_hpdata ) {

int dg,sugar0;

update_hpdata(&current_hpdata,nh);

dg = comp_hn(final_hpdata.hn,current_hpdata.hn);

if ( dg < 0 ) {

int d_len;

for ( d_len = 0; d; d = d->next, d_len++);

fprintf(asir_out,"[%d] We found a gb\n",d_len);

}

sugar0 = sugar;

while ( d && dg > sugar0 ) {

d = nd_remove_same_sugar(d,sugar0);

sugar0++;

}

} else {

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

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

}

} else {

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

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

}

FREENDP(l);

}

Line 3271 again:

Line 3561 again:

}

conv_ilist(nd_demand,1,g,indp);

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

if ( DP_Print ) { fprintf(asir_out,"\nnd_gb_trace done. Nbase=%d\n",nd_psn); fflush(asir_out); }

return g;

}

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

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

return d;

}

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

{

ND_pairs *d1;

struct oEGT eg1,eg2,eg3;

int i;

if ( !t ) return 0;

get_eg(&eg1);

Nnewpair = 0;

d1 = nd_newpairs_array_s(t,syz);

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

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

d[i] = merge_pairs_s(d[i],d1[i]);

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

return Nnewpair;

}

ND_pairs nd_newpairs( NODE g, int t )

{

NODE h;

Line 3640 int comp_sig_monomial(int n,DL d1,DL d2)

Line 3947 int comp_sig_monomial(int n,DL d1,DL d2)

}

if ( !nd_sba_modord )

return (*cmpdl)(n,d1,d2);

else {

else if ( !nd_sba_modord->weight && !nd_sba_modord->oldv ) {

return (*nd_sba_modord->cmpdl)(n,d1,d2);

} else {

weight = nd_sba_modord->weight;

oldv = nd_sba_modord->oldv;

if ( oldv ) {

Line 3666 int comp_sig(SIG s1,SIG s2)

Line 3975 int comp_sig(SIG s1,SIG s2)

if ( nd_sba_pot ) {

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

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

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

else return comp_sig_monomial(nd_nvar,DL(s1),DL(s2));

} else {

static DL m1,m2;

static int nvar = 0;

Line 3675 int comp_sig(SIG s1,SIG s2)

Line 3984 int comp_sig(SIG s1,SIG s2)

if ( nvar != nd_nvar ) {

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

}

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

if ( !nd_sba_modord )

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

ret = (*cmpdl)(nd_nvar,DL2(s1),DL2(s2));

ret = comp_sig_monomial(nd_nvar,m1,m2);

else

ret = comp_sig_monomial(nd_nvar,DL2(s1),DL2(s2));

if ( ret != 0 ) return ret;

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

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

Line 3697 int _create_spair_s(int i1,int i2,ND_pairs sp,SIG sig1

Line 4007 int _create_spair_s(int i1,int i2,ND_pairs sp,SIG sig1

p1 = nd_psh[i1];

p2 = nd_psh[i2];

ndl_lcm(DL(p1),DL(p2),sp->lcm);

#if 0

s1 = SG(p1)-TD(DL(p1));

s2 = SG(p2)-TD(DL(p2));

SG(sp) = MAX(s1,s2) + TD(sp->lcm);

#endif

if ( wpd != nd_wpd ) {

wpd = nd_wpd;

Line 3712 int _create_spair_s(int i1,int i2,ND_pairs sp,SIG sig1

Line 4024 int _create_spair_s(int i1,int i2,ND_pairs sp,SIG sig1

_ndltodl(lcm,DL(sig1));

_addtodl(nd_nvar,DL(p1->sig),DL(sig1));

sig1->pos = p1->sig->pos;

_adddl(nd_nvar,DL(sig1),nd_sba_hm[sig1->pos],DL2(sig1));

// DL(sig2) <- sp->lcm

// DL(sig2) -= DL(p2)

Line 3720 int _create_spair_s(int i1,int i2,ND_pairs sp,SIG sig1

Line 4033 int _create_spair_s(int i1,int i2,ND_pairs sp,SIG sig1

_ndltodl(lcm,DL(sig2));

_addtodl(nd_nvar,DL(p2->sig),DL(sig2));

sig2->pos = p2->sig->pos;

_adddl(nd_nvar,DL(sig2),nd_sba_hm[sig2->pos],DL2(sig2));

ret = comp_sig(sig1,sig2);

if ( ret == 0 ) return 0;

else if ( ret > 0 ) sp->sig = sig1;

else sp->sig = sig2;

s1 = DL(sig1)->td+nd_sba_hm[p1->sig->pos]->td;

s2 = DL(sig2)->td+nd_sba_hm[p2->sig->pos]->td;

SG(sp) = MAX(s1,s2);

return 1;

}

Line 3736 SIG dup_sig(SIG sig)

Line 4055 SIG dup_sig(SIG sig)

else {

NEWSIG(r);

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

_copydl(nd_nvar,DL2(sig),DL2(r));

r->pos = sig->pos;

return r;

}

Line 3765 ND_pairs merge_pairs_s(ND_pairs p1,ND_pairs p2)

Line 4085 ND_pairs merge_pairs_s(ND_pairs p1,ND_pairs p2)

} else if ( ret > 0 ) {

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

} else {

Nnewpair--;

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

Nsamesig++;

if ( ret < 0 ) {

Line 3787 ND_pairs merge_pairs_s(ND_pairs p1,ND_pairs p2)

Line 4108 ND_pairs merge_pairs_s(ND_pairs p1,ND_pairs p2)

ND_pairs insert_pair_s(ND_pairs l,ND_pairs s)

{

ND_pairs p,prev;

int ret;

int ret=1;

for ( p = l, prev = 0; p != 0; prev = p, p = p->next ) {

if ( (ret = comp_sig(s->sig,p->sig)) <= 0 )

Line 3808 ND_pairs insert_pair_s(ND_pairs l,ND_pairs s)

Line 4129 ND_pairs insert_pair_s(ND_pairs l,ND_pairs s)

return l;

} else {

// insert s between prev and p

Nnewpair++;

s->next = p;

if ( prev == 0 ) {

return s;

Line 3869 ND_pairs nd_newpairs_s(int t, NODE *syz)

Line 4191 ND_pairs nd_newpairs_s(int t, NODE *syz)

return r0;

}

ND_pairs *nd_newpairs_array_s(int t, NODE *syz)

{

NODE h,s;

UINT *dl;

int ts,ret,i;

ND_pairs r,r0,_sp,sp;

ND_pairs *d;

SIG spsig,tsig;

static int nvar = 0;

static SIG _sig1,_sig2;

struct oEGT eg1,eg2,eg3,eg4;

NEWND_pairs(_sp);

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

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

}

d = (ND_pairs *)MALLOC(nd_nbase*sizeof(ND_pairs));

Nnewpair = 0;

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

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

if ( ret ) {

spsig = _sp->sig;

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

tsig = (SIG)s->body;

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

break;

}

if ( s == 0 ) {

NEWND_pairs(sp);

dup_ND_pairs(sp,_sp);

d[spsig->pos] = insert_pair_s(d[spsig->pos],sp);

} else

Nsyz++;

}

return d;

}

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

ND_pairs nd_ipairtospair(NODE ipair)

{

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

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

ndv_lm_modord(nd_ps[i],nd_sba_hm[i]);

else

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

_adddl(nd_nvar,DL(sig),nd_sba_hm[i],DL2(sig));

}

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

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

Line 4744 NODE nd_sba_f4(int m,int **indp);

Line 5105 NODE nd_sba_f4(int m,int **indp);

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

{

VL tv,fv,vv,vc,av;

NODE fd,fd0,r,r0,t,x,s,xx,nd,syz;

NODE fd,fd0,r,r0,t,x,s,xx,nd,nd1,syz;

int e,max,nvar,i;

NDV b;

int ishomo,nalg,wmax,len;

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

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

struct oEGT eg0,eg1,egconv,egintred;

LIST l1,redind;

Z z;

nd_module = 0;

nd_demand = 0;

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

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

}

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

if ( nd_gentrace ) {

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

}

x = f4 ? nd_sba_f4(m,&perm) : nd_sba_buch(m,ishomo || homo,&perm,&syz);

if ( !x ) {

*rp = 0; return;

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

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

nd_setup_parameters(nvar,0);

}

nd_demand = 0;

get_eg(&eg0);

x = ndv_reducebase(x,perm);

for ( nd = 0, i = length(x)-1; i >= 0; i-- ) {

STOZ(perm[i],z); MKNODE(nd1,z,nd); nd = nd1;

}

MKLIST(redind,nd);

x = ndv_reduceall(m,x);

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

nd_setup_parameters(nd_nvar,0);

get_eg(&eg0);

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

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

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

if ( r0 ) NEXT(r) = 0;

if ( nd_sba_syz ) {

LIST gb,hsyz;

NODE nd;

MKLIST(gb,r0);

MKLIST(hsyz,syz);

nd = mknode(2,gb,hsyz);

MKLIST(*rp,nd);

} else if ( nd_gentrace ) {

LIST gb,trace;

MKLIST(trace,nd_alltracelist);

MKLIST(gb,r0);

nd = mknode(3,gb,redind,trace);

MKLIST(*rp,nd);

} else

MKLIST(*rp,r0);

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

print_eg("intred",&egintred); fprintf(asir_out,"\n");

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

}

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

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

Obj obj;

NumberField nf;

struct order_spec *ord1;

struct oEGT eg_check,eg0,eg1;

struct oEGT eg_check,eg_gb,eg_intred,eg0,eg1;

NODE tr,tl1,tl2,tl3,tl4;

LIST l1,l2,l3,l4,l5;

int *perm;

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

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

get_eg(&eg0);

tl1 = tl2 = tl3 = tl4 = 0;

if ( Demand )

nd_demand = 1;

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

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

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

nd_init_ord(ord);

nd_setup_parameters(nvar,0);

}

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

nd_demand = 0;

cand = ndv_reducebase(cand,perm);

if ( nd_gentrace ) { tl1 = nd_alltracelist; nd_alltracelist = 0; }

get_eg(&eg0);

cand = ndv_reduceall(0,cand);

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

cbpe = nd_bpe;

if ( nd_gentrace ) { tl2 = nd_alltracelist; nd_alltracelist = 0; }

get_eg(&eg0);

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

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

tl3 = nd_alltracelist; nd_alltracelist = 0;

} else tl3 = 0;

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

if ( nd_vc || nd_gentrace || nd_gensyz )

if ( nd_vc || nd_gentrace || nd_gensyz || do_weyl )

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

else

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

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

Line 5707 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=%.3fsec\n",eg_check.exectime);

fprintf(asir_out,"gb=%.3fsec,check=%.3fsec,intred=%.3fsec\n",

eg_gb.exectime,eg_check.exectime,eg_intred.exectime);

/* dp->p */

nd_bpe = cbpe;

nd_setup_parameters(nd_nvar,0);

Line 6172 void nd_reconstruct_s(int trace,ND_pairs *d)

Line 6556 void nd_reconstruct_s(int trace,ND_pairs *d)

SG(s) = SG(t);

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

}

if ( s0 ) NEXT(s) = 0;

d[i] = s0;

}

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

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

else if ( NUM(p) ) {

NEWNM(m);

ndl_zero(DL(m));

if ( !INT((Q)p) )

if ( RATN(p) && !INT((Q)p) )

error("ptond : input must be integer-coefficient");

CZ(m) = (Z)p;

NEXT(m) = 0;

Line 10305 void parse_nd_option(VL vl,NODE opt)

Line 10690 void parse_nd_option(VL vl,NODE opt)

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

nd_sba_dontsort = 0; nd_top = 0; nd_sba_redundant_check = 0;

nd_sba_syz = 0; nd_sba_modord = 0; nd_sba_inputisgb = 0;

nd_hpdata = 0; nd_sba_heu = 0;

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

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

Line 10352 void parse_nd_option(VL vl,NODE opt)

Line 10738 void parse_nd_option(VL vl,NODE opt)

nd_splist = value?1:0;

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

nd_check_splist = BDY((LIST)value);

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

if ( value )

nd_hpdata = BDY((LIST)value);

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

u = BDY((LIST)value);

n = length(u);

Line 10370 void parse_nd_option(VL vl,NODE opt)

Line 10759 void parse_nd_option(VL vl,NODE opt)

nd_sba_dontsort = value?1:0;

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

nd_sba_syz = value?1:0;

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

nd_sba_heu = value?1:0;

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

// value=[vlist,ordspec,weight]

u = BDY((LIST)value);

Line 11575 INLINE int ndl_find_reducer_minsig(UINT *dg)

Line 11966 INLINE int ndl_find_reducer_minsig(UINT *dg)

_ndltodl(tmp,DL(quo));

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

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

_adddl(nd_nvar,DL(quo),nd_sba_hm[quo->pos],DL2(quo));

if ( imin < 0 || comp_sig(quomin,quo) > 0 ) {

t = quo; quo = quomin; quomin = t;

imin = i;

Line 11625 int nd_symbolic_preproc_s(PGeoBucket bucket,int trace,

Line 12017 int nd_symbolic_preproc_s(PGeoBucket bucket,int trace,

_ndltodl(DL(mul),DL(sig));

_addtodl(nd_nvar,DL(nd_psh[index]->sig),DL(sig));

sig->pos = nd_psh[index]->sig->pos;

_adddl(nd_nvar,DL(sig),nd_sba_hm[sig->pos],DL2(sig));

MKNM_ind_pair(pair,mul,index,sugar,sig);

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

add_pbucket_symbolic(bucket,nd_remove_head(red));

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