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.45 and 1.60

version 1.45, 2021/01/11 08:37:44

version 1.60, 2021/12/17 23:53:13

Line 1

/* $OpenXM: OpenXM_contrib2/asir2018/engine/nd.c,v 1.44 2020/12/15 07:40:09 noro Exp $ */

/* $OpenXM: OpenXM_contrib2/asir2018/engine/nd.c,v 1.59 2021/12/14 01:02:40 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_fixord,nd_sba_grevlexgb;

static int nd_top,nd_sba_syz,nd_sba_inputisgb;

static int *nd_gbblock;

static NODE nd_nzlist,nd_check_splist;

static int nd_splist;

Line 78 static int nd_f4red,nd_rank0,nd_last_nonzero;

Line 79 static int nd_f4red,nd_rank0,nd_last_nonzero;

static DL *nd_sba_hm;

static NODE *nd_sba_pos;

struct comp_sig_spec {

int n;

// current_i <-> oldv[i]

int *oldv;

int *weight;

struct order_pair *order_pair;

int block_length;

int **matrix;

int row;

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

};

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 95 P ndc_div(int mod,union oNDC a,union oNDC b);

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

P ndctop(int mod,union oNDC c);

void finalize_tracelist(int i,P cont);

void conv_ilist(int demand,int trace,NODE g,int **indp);

void parse_nd_option(NODE opt);

void parse_nd_option(VL vl,NODE opt);

void dltondl(int n,DL dl,UINT *r);

DP ndvtodp(int mod,NDV p);

DP ndtodp(int mod,ND p);

Line 1285 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 ) { /* fprintf(asir_out,"s"); fflush(asir_out); */ singular = 1; }

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

Line 1710 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 2453 LIST compute_splist()

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

root.next = d;

prev = &root; cur = d;

while ( cur ) {

if ( SG(cur) == sugar )

prev->next = cur->next;

else

prev = cur;

cur = cur->next;

}

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 2469 NODE nd_gb(int m,int ishomo,int checkonly,int gensyz,i

Line 2617 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 2479 init_eg(&eg_update);

Line 2630 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 2552 get_eg(&eg1);

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

fprintf(asir_out,"We found a gb\n");

d = 0;

}

sugar0 = sugar;

while ( d && dg > sugar0 ) {

if ( DP_Print ) { fprintf(asir_out,"[%d]",sugar0); fflush(asir_out); }

d = nd_remove_same_sugar(d,sugar0);

sugar0++;

}

} else {

Nnfz++;

if ( nd_gentrace && gensyz ) {

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

Line 2732 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 2578 get_eg(&eg2); add_eg(&eg_update,&eg1,&eg2);

Line 2749 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 2586 int nd_nf_s(int mod,ND d,ND g,NDV *ps,int full,ND *nf)

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

Line 2843 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 2689 ND_pairs find_smallest_lcm(ND_pairs l)

Line 2891 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 2707 ND_pairs find_smallest_lcm(ND_pairs l)

Line 2909 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 2720 ND_pairs find_smallest_lcm(ND_pairs l)

Line 2924 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 2778 SIG trivial_sig(int i,int j)

Line 2984 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_grevlexgb != 0 ) {

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

Line 3043 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

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

Line 3119 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 2921 get_eg(&eg2);

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

d = update_pairs_s(d,nh,syzlist);

nh = ndv_newps(m,nfv,0);

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

FREENDP(l);

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

get_eg(&eg1);

update_hpdata(&current_hpdata,nh);

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

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

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

break;

}

} 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",Nnfnz,Nnfz,Nnfs,nd_psn);

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

Line 3400 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 3146 NODE nd_gb_trace(int m,int ishomo,int **indp)

Line 3412 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 3239 again:

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

fprintf(asir_out,"We found a gb\n");

d = 0;

}

sugar0 = sugar;

while ( d && dg > sugar0 ) {

if ( DP_Print ) { fprintf(asir_out,"[%d]",sugar0); fflush(asir_out); }

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

Line 3542 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 3415 get_eg(&eg3); add_eg(&eg_merge,&eg2,&eg3);

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

Line 3756 ND_pairs nd_newpairs( NODE g, int t )

return r0;

}

int sig_cmpdl_op(int n,DL d1,DL d2)

{

int e1,e2,i,j,l;

int *t1,*t2;

int len,head;

struct order_pair *pair;

len = nd_sba_modord->block_length;

pair = nd_sba_modord->order_pair;

head = 0;

for ( i = 0, t1 = d1->d, t2 = d2->d; i < len; i++ ) {

l = pair[i].length;

switch ( pair[i].order ) {

case 0:

for ( j = 0, e1 = e2 = 0; j < l; j++ ) {

e1 += t1[j];

e2 += t2[j];

}

if ( e1 > e2 )

return 1;

else if ( e1 < e2 )

return -1;

else {

for ( j = l - 1; j >= 0 && t1[j] == t2[j]; j-- );

if ( j >= 0 )

return t1[j] < t2[j] ? 1 : -1;

}

break;

case 1:

for ( j = 0, e1 = e2 = 0; j < l; j++ ) {

e1 += t1[j];

e2 += t2[j];

}

if ( e1 > e2 )

return 1;

else if ( e1 < e2 )

return -1;

else {

for ( j = 0; j < l && t1[j] == t2[j]; j++ );

if ( j < l )

return t1[j] > t2[j] ? 1 : -1;

}

break;

case 2:

for ( j = 0; j < l && t1[j] == t2[j]; j++ );

if ( j < l )

return t1[j] > t2[j] ? 1 : -1;

break;

default:

error("sig_cmpdl_op : invalid order"); break;

}

t1 += l; t2 += l; head += l;

}

return 0;

}

int sig_cmpdl_mat(int n,DL d1,DL d2)

{

int *v,*t1,*t2;

int s,i,j,len;

int **matrix;

static int *w;

static int nvar = 0;

if ( nvar != n ) {

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

}

for ( i = 0, t1 = d1->d, t2 = d2->d; i < n; i++ )

w[i] = t1[i]-t2[i];

len = nd_sba_modord->row;

matrix = nd_sba_modord->matrix;

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

v = matrix[j];

for ( i = 0, s = 0; i < n; i++ )

s += v[i]*w[i];

if ( s > 0 )

return 1;

else if ( s < 0 )

return -1;

}

return 0;

}

struct comp_sig_spec *create_comp_sig_spec(VL current_vl,VL old_vl,Obj ord,Obj weight)

{

struct comp_sig_spec *spec;

VL ovl,vl;

V ov;

int i,j,n,nvar,s;

NODE node,t,tn;

struct order_pair *l;

MAT m;

Obj **b;

int **w;

int *a;

spec = (struct comp_sig_spec *)MALLOC(sizeof(struct comp_sig_spec));

for ( i = 0, vl = current_vl; vl; vl = NEXT(vl), i++ );

spec->n = nvar = i;

if ( old_vl != 0 ) {

spec->oldv = (int *)MALLOC(nvar*sizeof(int));

for ( i = 0, ovl = old_vl; i < nvar; ovl = NEXT(ovl), i++ ) {

ov = ovl->v;

for ( j = 0, vl = current_vl; vl; vl = NEXT(vl), j++ )

if ( ov == vl->v ) break;

spec->oldv[i] = j;

}

} else

spec->oldv = 0;

if ( !ord || NUM(ord) ) {

switch ( ZTOS((Z)ord) ) {

case 0:

spec->cmpdl = cmpdl_revgradlex; break;

case 1:

spec->cmpdl = cmpdl_gradlex; break;

case 2:

spec->cmpdl = cmpdl_lex; break;

default:

error("create_comp_sig_spec : invalid spec"); break;

}

} else if ( OID(ord) == O_LIST ) {

node = BDY((LIST)ord);

for ( n = 0, t = node; t; t = NEXT(t), n++ );

l = (struct order_pair *)MALLOC_ATOMIC(n*sizeof(struct order_pair));

for ( i = 0, t = node, s = 0; i < n; t = NEXT(t), i++ ) {

tn = BDY((LIST)BDY(t)); l[i].order = ZTOS((Q)BDY(tn));

tn = NEXT(tn); l[i].length = ZTOS((Q)BDY(tn));

s += l[i].length;

}

if ( s != nvar )

error("create_comp_sig_spec : invalid spec");

spec->order_pair = l;

spec->block_length = n;

spec->cmpdl = sig_cmpdl_op;

} else if ( OID(ord) == O_MAT ) {

m = (MAT)ord; b = (Obj **)BDY(m);

if ( m->col != nvar )

error("create_comp_sig_spec : invalid spec");

w = almat(m->row,m->col);

for ( i = 0; i < m->row; i++ )

for ( j = 0; j < m->col; j++ )

w[i][j] = ZTOS((Q)b[i][j]);

spec->row = m->row;

spec->matrix = w;

spec->cmpdl = sig_cmpdl_mat;

} else

error("create_comp_sig_spec : invalid spec");

if ( weight != 0 ) {

node = BDY((LIST)weight);

a = (int *)MALLOC(nvar*sizeof(int));

for ( i = 0; i < nvar; i++, node = NEXT(node) )

a[i] = ZTOS((Z)BDY(node));

spec->weight = a;

}

return spec;

}

#define SIG_MUL_WEIGHT(a,i) (weight?(a)*weight[i]:(a))

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

{

static DL m1,m2;

static int nvar = 0;

int *oldv,*weight;

int i,w1,w2;

if ( nvar != n ) {

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

}

if ( !nd_sba_modord )

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

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

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

m1->d[i] = d1->d[oldv[i]]; m2->d[i] = d2->d[oldv[i]];

}

} else {

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

m1->d[i] = d1->d[i]; m2->d[i] = d2->d[i];

}

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

w1 += SIG_MUL_WEIGHT(m1->d[i],i);

w2 += SIG_MUL_WEIGHT(m2->d[i],i);

}

m1->td = w1; m2->td = w2;

return (*nd_sba_modord->cmpdl)(n,m1,m2);

}

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 (*cmpdl)(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 3466 int comp_sig(SIG s1,SIG s2)

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

if ( nd_sba_fixord )

ret = cmpdl_revgradlex(nd_nvar,m1,m2);

else

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

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 3491 int _create_spair_s(int i1,int i2,ND_pairs sp,SIG sig1

Line 3988 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 3506 int _create_spair_s(int i1,int i2,ND_pairs sp,SIG sig1

Line 4005 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 3514 int _create_spair_s(int i1,int i2,ND_pairs sp,SIG sig1

Line 4014 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 3530 SIG dup_sig(SIG sig)

Line 4036 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 3559 ND_pairs merge_pairs_s(ND_pairs p1,ND_pairs p2)

Line 4066 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 3581 ND_pairs merge_pairs_s(ND_pairs p1,ND_pairs p2)

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

Line 4110 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 3663 ND_pairs nd_newpairs_s(int t, NODE *syz)

Line 4172 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 4033 int ndv_newps(int m,NDV a,NDV aq)

Line 4580 int ndv_newps(int m,NDV a,NDV aq)

return nd_psn++;

}

// find LM wrt grevlex

// find LM wrt the specified modord

void ndv_lm_fixord(NDV p,DL d)

void ndv_lm_modord(NDV p,DL d)

{

NMV m;

DL tmp;

Line 4042 void ndv_lm_fixord(NDV p,DL d)

Line 4589 void ndv_lm_fixord(NDV p,DL d)

NEWDL(tmp,nd_nvar);

m = BDY(p); len = LEN(p);

_ndltodl(DL(m),d); printdl(d); printf("->");

_ndltodl(DL(m),d); // printdl(d); printf("->");

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

_ndltodl(DL(m),tmp);

ret = cmpdl_revgradlex(nd_nvar,tmp,d);

ret = comp_sig_monomial(nd_nvar,tmp,d);

if ( ret > 0 ) _copydl(nd_nvar,tmp,d);

}

printdl(d); printf("\n");

// printdl(d); printf("\n");

}

/* nd_tracelist = [[0,index,div],...,[nd_psn-1,index,div]] */

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

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

if ( nd_demand ) nd_ps_trace_sym[i]->sig = sig;

}

NEWDL(nd_sba_hm[i],nd_nvar);

if ( nd_sba_fixord )

if ( nd_sba_modord )

ndv_lm_fixord(nd_ps[i],nd_sba_hm[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 4318 void nd_gr(LIST f,LIST v,int m,int homo,int retdp,int

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

nd_module = 0;

if ( !m && Demand ) nd_demand = 1;

else nd_demand = 0;

parse_nd_option(current_option);

if ( DP_Multiple )

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

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

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

ndv_alloc = 0;

#endif

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

parse_nd_option(vv,current_option);

if ( m && nd_vc )

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

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

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

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

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

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

parse_nd_option(vv,current_option);

if ( m && nd_vc )

error("nd_sba : computation over Fp(X) is unsupported. Use dp_gr_mod_main().");

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

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

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

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

Line 5207 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 4676 void nd_gr_postproc(LIST f,LIST v,int m,struct order_s

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

struct order_spec *ord1;

int *perm;

parse_nd_option(current_option);

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

parse_nd_option(vv,current_option);

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

switch ( ord->id ) {

case 1:

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

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

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

parse_nd_option(vv,current_option);

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

switch ( ord->id ) {

case 1:

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

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

NcriB = NcriMF = Ncri2 = 0;

nd_module = 0;

nd_lf = 0;

parse_nd_option(current_option);

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

parse_nd_option(vv,current_option);

if ( nd_lf ) {

if ( f4 )

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

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

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

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

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

switch ( ord->id ) {

case 1:

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

Line 5657 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 5966 void nd_reconstruct_s(int trace,ND_pairs *d)

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

Line 7248 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 10084 NODE conv_ilist_s(int demand,int trace,int **indp)

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

return g0;

}

void parse_nd_option(NODE opt)

void parse_nd_option(VL vl,NODE opt)

{

NODE t,p,u;

int i,s,n;

char *key;

Obj value;

VL oldvl;

nd_gentrace = 0; nd_gensyz = 0; nd_nora = 0; nd_norb = 0; nd_gbblock = 0;

nd_newelim = 0; nd_intersect = 0; nd_nzlist = 0;

Line 10097 void parse_nd_option(NODE opt)

Line 10665 void parse_nd_option(NODE opt)

nd_sugarweight = 0; nd_f4red =0; nd_rank0 = 0;

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_fixord = 0; nd_sba_grevlexgb = 0;

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

nd_hpdata = 0;

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

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

Line 10145 void parse_nd_option(NODE opt)

Line 10714 void parse_nd_option(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 10163 void parse_nd_option(NODE opt)

Line 10735 void parse_nd_option(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_fixord") ) {

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

nd_sba_fixord = value?1:0;

// value=[vlist,ordspec,weight]

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

u = BDY((LIST)value);

nd_sba_grevlexgb = value?1:0;

pltovl((LIST)ARG0(u),&oldvl);

nd_sba_modord = create_comp_sig_spec(vl,oldvl,(Obj)ARG1(u),argc(u)==3?ARG2(u):0);

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

nd_sba_inputisgb = value?1:0;

if ( nd_sba_inputisgb != 0 ) {

// value=[vlist,ordspec,weight]

u = BDY((LIST)value);

pltovl((LIST)ARG0(u),&oldvl);

nd_sba_modord = create_comp_sig_spec(vl,oldvl,(Obj)ARG1(u),argc(u)==3?ARG2(u):0);

}

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

nd_sba_redundant_check = value?1:0;

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

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

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

if ( mod == -2 )

return nd_btog_lf(f,v,ord,tlist,rp);

parse_nd_option(current_option);

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

parse_nd_option(vv,current_option);

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

switch ( ord->id ) {

case 1:

Line 10447 MAT nd_btog_lf(LIST f,LIST v,struct order_spec *ord,LI

Line 11028 MAT nd_btog_lf(LIST f,LIST v,struct order_spec *ord,LI

LM lm;

Z lf,inv;

parse_nd_option(current_option);

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

parse_nd_option(vv,current_option);

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

switch ( ord->id ) {

case 1:

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

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

if ( mod == -2 )

error("nd_btog_one : not implemented yet for a large finite field");

parse_nd_option(current_option);

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

parse_nd_option(vv,current_option);

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

switch ( ord->id ) {

case 1:

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

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

Q jq,bpe;

nd_module = 0;

parse_nd_option(current_option);

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

parse_nd_option(vv,current_option);

if ( nd_vc )

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

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

Line 11359 INLINE int ndl_find_reducer_minsig(UINT *dg)

Line 11940 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 11409 int nd_symbolic_preproc_s(PGeoBucket bucket,int trace,

Line 11991 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>