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.39 and 1.48

version 1.39, 2020/10/29 01:50:35

version 1.48, 2021/02/18 05:35:01

Line 1

/* $OpenXM: OpenXM_contrib2/asir2018/engine/nd.c,v 1.38 2020/10/26 02:41:05 noro Exp $ */

/* $OpenXM: OpenXM_contrib2/asir2018/engine/nd.c,v 1.47 2021/02/01 08:06:33 noro Exp $ */

#include "nd.h"

int Nnd_add,Nf4_red;

void print_siglist(NODE l);

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 65 static int nd_module_rank,nd_poly_weight_len;

Line 67 static int nd_module_rank,nd_poly_weight_len;

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

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;

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 76 static int nd_f4red,nd_rank0,nd_last_nonzero;

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

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

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

DPM ndvtodpm(int mod,NDV p);

NDV dptondv(int mod,DP p);

NDV dpmtondv(int mod,DPM p);

int dp_getdeg(DP p);

int dpm_getdeg(DPM p,int *rank);

void dpm_ptozp(DPM p,Z *cont,DPM *r);

int compdmm(int nv,DMM a,DMM b);

DPM sigtodpm(SIG s);

SIG dup_sig(SIG sig);

void Pdp_set_weight(NODE,VECT *);

void Pox_cmo_rpc(NODE,Obj *);

Line 116 NODE nd_f4_red_mod64_main(int m,ND_pairs sp0,int nsp,U

Line 136 NODE nd_f4_red_mod64_main(int m,ND_pairs sp0,int nsp,U

NODE nd_f4_red_lf_main(int m,ND_pairs sp0,int nsp,int trace,UINT *s0vect,int col,

NM_ind_pair *rvect,int *rhead,IndArray *imat,int nred);

int nd_gauss_elim_lf(mpz_t **mat0,int *sugar,int row,int col,int *colstat);

int nd_gauss_elim_mod_s(UINT **mat,int *sugar,ND_pairs *spactive,int row,int col,int md,int *colstat,SIG *sig);

NODE nd_f4_lf_trace_main(int m,int **indp);

void nd_f4_lf_trace(LIST f,LIST v,int trace,int homo,struct order_spec *ord,LIST *rp);

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

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

int ndl_module_schreyer_compare(UINT *m1,UINT *m2)

{

int pos1,pos2,t,j;

int pos1,pos2,t,j,retpot;

DMM *in;

DMMstack s;

static DL d1=0;

static DL d2=0;

static int dlen=0;

extern int ReversePOT;

if ( ReversePOT ) retpot = -1;

else retpot = 1;

pos1 = MPOS(m1); pos2 = MPOS(m2);

if ( pos1 == pos2 ) return (*ndl_base_compare_function)(m1,m2);

if ( nd_nvar > dlen ) {

Line 816 int ndl_module_schreyer_compare(UINT *m1,UINT *m2)

Line 840 int ndl_module_schreyer_compare(UINT *m1,UINT *m2)

_addtodl(nd_nvar,in[pos1]->dl,d1);

_addtodl(nd_nvar,in[pos2]->dl,d2);

if ( in[pos1]->pos == in[pos2]->pos && _eqdl(nd_nvar,d1,d2)) {

if ( pos1 < pos2 ) return 1;

if ( pos1 < pos2 ) return retpot;

else if ( pos1 > pos2 ) return -1;

else if ( pos1 > pos2 ) return -retpot;

else return 0;

}

pos1 = in[pos1]->pos;

Line 830 LAST:

Line 854 LAST:

case 0:

t = (*dl_base_compare_function)(nd_nvar,d1,d2);

if ( t ) return t;

else if ( pos1 < pos2 ) return 1;

else if ( pos1 < pos2 ) return retpot;

else if ( pos1 > pos2 ) return -1;

else if ( pos1 > pos2 ) return -retpot;

else return 0;

break;

case 1:

if ( pos1 < pos2 ) return 1;

if ( pos1 < pos2 ) return retpot;

else if ( pos1 > pos2 ) return -1;

else if ( pos1 > pos2 ) return -retpot;

else return (*dl_base_compare_function)(nd_nvar,d1,d2);

break;

case 2:

if ( d1->td > d2->td ) return 1;

else if ( d1->td < d2->td ) return -1;

else if ( pos1 < pos2 ) return 1;

else if ( pos1 < pos2 ) return retpot;

else if ( pos1 > pos2 ) return -1;

else if ( pos1 > pos2 ) return -retpot;

else return (*dl_base_compare_function)(nd_nvar,d1,d2);

break;

default:

Line 1206 INLINE int ndl_find_reducer(UINT *dg)

Line 1230 INLINE int ndl_find_reducer(UINT *dg)

return -1;

}

INLINE int ndl_find_reducer_nonsig(UINT *dg)

{

RHist r;

int i;

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

r = nd_psh[i];

if ( ndl_reducible(dg,DL(r)) ) return i;

}

return -1;

}

// ret=0,...,nd_psn-1 => reducer found

// ret=nd_psn => reducer not found

// ret=-1 => singular top reducible

Line 1225 void print_sig(SIG s)

Line 1261 void print_sig(SIG s)

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

}

void print_siglist(NODE l)

{

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

print_sig((SIG)l->body);

}

// assuming increasing order wrt signature

INLINE int ndl_find_reducer_s(UINT *dg,SIG sig)

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

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

Z q;

union oNDC dn,hc;

int diag_count = 0;

int Nnfnz = 0,Nnfz = 0;

P cont;

LIST list;

struct oEGT eg1,eg2,eg_update;

Line 2483 again:

Line 2527 again:

d = nd_reconstruct(0,d);

goto again;

} else if ( nf ) {

Nnfnz++;

if ( checkonly || gensyz ) return 0;

if ( nd_newelim ) {

if ( nd_module ) {

Line 2521 get_eg(&eg1);

Line 2566 get_eg(&eg1);

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

g = update_base(g,nh);

FREENDP(l);

} else {

if ( nd_gentrace && gensyz ) {

Nnfz++;

nd_tracelist = reverse_node(nd_tracelist);

if ( nd_gentrace && gensyz ) {

MKLIST(list,nd_tracelist);

nd_tracelist = reverse_node(nd_tracelist);

STOZ(-1,q); t = mknode(2,q,list); MKLIST(list,t);

MKLIST(list,nd_tracelist);

MKNODE(t,list,nd_alltracelist);

STOZ(-1,q); t = mknode(2,q,list); MKLIST(list,t);

nd_alltracelist = t; nd_tracelist = 0;

MKNODE(t,list,nd_alltracelist);

}

nd_alltracelist = t; nd_tracelist = 0;

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

}

FREENDP(l);

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

if ( !checkonly && DP_Print ) {

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

if ( DP_Print )

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

print_eg("update",&eg_update);

fflush(asir_out);

}

if ( DP_Print ) {

print_eg("update",&eg_update); fprintf(asir_out,"\n");

}

return g;

}

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 2569 NODE insert_sig(NODE l,SIG s)

Line 2621 NODE insert_sig(NODE l,SIG s)

else if ( _dl_redble(sig,DL(t),nd_nvar) )

// remove p

prev->next = p->next;

else

prev = p;

} else

prev = p;

}

Line 2609 int small_lcm(ND_pairs l)

Line 2663 int small_lcm(ND_pairs l)

int i;

NODE t;

static DL lcm,mul,quo;

static int nvar;

static int nvar = 0;

if ( nd_sba_largelcm ) return 0;

if ( nvar < nd_nvar ) {

Line 2644 int small_lcm(ND_pairs l)

Line 2698 int small_lcm(ND_pairs l)

#endif

}

ND_pairs find_smallest_lcm(ND_pairs l)

{

SIG sig;

int i,minindex;

NODE t;

ND_pairs r;

struct oSIG sig1;

static DL mul,quo,minlm;

static int nvar = 0;

if ( nvar < nd_nvar ) {

nvar = nd_nvar;

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

NEWDL(minlm,nvar);

}

sig = l->sig;

// find mg s.t. m*s(g)=sig and m*lm(g) is minimal

_ndltodl(l->lcm,minlm); minindex = -1;

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

if ( _dl_redble_ext(mul,minlm,quo,nd_nvar) ) {

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

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

sig1.dl = quo;

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

// printf("X");

NEWND_pairs(r);

r->sig = sig;

r->i1 = minindex;

r->i2 = i;

dltondl(nd_nvar,minlm,r->lcm);

r->next = 0;

return r;

}

// there is no suitable spair

return 0;

}

ND_pairs remove_large_lcm(ND_pairs d)

{

struct oND_pairs root;

Line 2652 ND_pairs remove_large_lcm(ND_pairs d)

Line 2762 ND_pairs remove_large_lcm(ND_pairs d)

root.next = d;

prev = &root; p = d;

while ( p ) {

#if 0

if ( small_lcm(p) ) {

// remove p

prev->next = p->next;

} else

#else

if ( find_smallest_lcm(p) == 0 ) {

// remove p

prev->next = p->next;

} else

#endif

prev = p;

p = p->next;

}

Line 2666 struct oEGT eg_create,eg_newpairs,eg_merge;

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

// S(fj*ei-fi*ej)

void _subdl(int,DL,DL,DL);

SIG trivial_sig(int i,int j)

{

static DL lcm;

static struct oSIG sigi,sigj;

static int nvar = 0;

SIG sig;

if ( nvar != nd_nvar ) {

nvar = nd_nvar; NEWDL(lcm,nvar); NEWDL(sigi.dl,nvar); NEWDL(sigj.dl,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);

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

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

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

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;

ND_pairs l,l1;

ND h,nf,s,head,nf1;

NDV nfv;

Z q;

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

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

LIST list;

SIG sig;

NODE *syzlist;

int Nredundant;

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 oEGT eg1,eg2,eg_update,eg_remove,eg_large,eg_nf,eg_nfzero,eg_minsig,eg_smallest;

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;

if ( !do_weyl ) {

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

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

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

}

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;

pos = 0;

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

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

while ( 1 ) {

again:

if ( DP_Print && dlen%100 == 0 ) fprintf(asir_out,"(%d)",dlen);

if ( DP_Print ) {

again :

int len;

get_eg(&eg1);

ND_pairs td;

ind = nd_minsig(d);

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

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

;

if ( ind < 0 ) break;

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

l = d[ind];

}

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

l = d; d = d->next;

get_eg(&eg1);

if ( small_lcm(l) ) {

l1 = find_smallest_lcm(l);

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

if ( l1 == 0 ) {

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

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

Nredundant++;

Nnominimal++;

continue;

}

if ( SG(l) != sugar ) {

if ( SG(l1) != sugar ) {

sugar = SG(l);

sugar = SG(l1);

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

}

sig = l->sig;

sig = l1->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);

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

if ( !stat ) {

NEXT(l) = d; d = l;

nd_reconstruct_s(0,d);

d = nd_reconstruct(0,d);

goto again;

}

get_eg(&eg1);

Line 2747 get_eg(&eg1);

Line 2928 get_eg(&eg1);

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

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

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

Nnfnz++;

if ( DP_Print ) {

if ( nd_sba_redundant_check ) {

if ( ndl_find_reducer_nonsig(HDL(nf)) >= 0 ) {

Nredundant++;

printf("R");

} else

printf("+");

} else

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,nh,syzlist);

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

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

FREENDP(l);

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

}

g = conv_ilist_s(nd_demand,0,indp);

if ( DP_Print ) {

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

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

fflush(stdout);

if ( nd_sba_redundant_check )

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

fflush(stdout);

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

print_eg("nf",&eg_nf);

print_eg("nfzero",&eg_nfzero);

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;

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

tsyz = syzlist[i];

for ( prev = 0; tsyz != 0; prev = tsyz, tsyz = NEXT(tsyz))

BDY(tsyz) = (pointer)sigtodpm((SIG)BDY(tsyz));

if ( prev != 0 ) {

prev->next = hsyz; hsyz = syzlist[i];

}

*syzp = hsyz;

} else *syzp = 0;

return g;

}

Line 3072 again:

Line 3293 again:

}

conv_ilist(nd_demand,1,g,indp);

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

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

return g;

}

Line 3160 NODE ndv_reduceall(int m,NODE f)

Line 3381 NODE ndv_reduceall(int m,NODE f)

return a0;

}

int ndplength(ND_pairs d)

{

int i;

for ( i = 0; d; i++ ) d = NEXT(d);

return i;

}

ND_pairs update_pairs( ND_pairs d, NODE /* of index */ g, int t, int gensyz)

{

ND_pairs d1,nd,cur,head,prev,remove;

int len0;

if ( !g ) return d;

/* for testing */

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

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

}

d = crit_B(d,t);

d1 = nd_newpairs(g,t);

len0 = ndplength(d1);

d1 = crit_M(d1);

d1 = crit_F(d1);

NcriMF += len0-ndplength(d1);

if ( gensyz || do_weyl )

head = d1;

else {

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

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

remove = cur;

if ( !prev ) head = cur = NEXT(cur);

else cur = NEXT(prev) = NEXT(cur);

FREENDP(remove);

FREENDP(remove); Ncri2++;

} else {

prev = cur; cur = NEXT(cur);

}

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

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

Line 3493 ND_pairs nd_newpairs( NODE g, int t )

if ( nd_gbblock[i] >= 0 )

continue;

}

NEXTND_pairs(r0,r);

NEXTND_pairs(r0,r); Npairs++;

r->i1 = (long)BDY(h);

r->i2 = t;

ndl_lcm(DL(nd_psh[r->i1]),dl,r->lcm);

Line 3259 ND_pairs nd_newpairs( NODE g, int t )

Line 3507 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 {

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,s1->dl,s2->dl);

} else {

static DL m1,m2;

static int nvar;

static int nvar = 0;

int ret;

if ( nvar != nd_nvar ) {

Line 3275 int comp_sig(SIG s1,SIG s2)

Line 3716 int comp_sig(SIG s1,SIG s2)

}

_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 ( !nd_sba_modord )

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

else

ret = comp_sig_monomial(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;

Line 3363 ND_pairs merge_pairs_s(ND_pairs p1,ND_pairs p2)

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

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

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

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

int ts,ret,i;

ND_pairs r,r0,_sp,sp;

SIG spsig,tsig;

static int nvar;

static int nvar = 0;

static SIG _sig1,_sig2;

struct oEGT eg1,eg2,eg3,eg4;

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

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

Line 4001 ND_pairs crit_B( ND_pairs d, int s )

} else {

cur = NEXT(prev) = NEXT(cur);

}

FREENDP(remove);

FREENDP(remove); NcriB++;

} else {

prev = cur; cur = NEXT(cur);

}

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

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

return nd_psn++;

}

// find LM wrt the specified modord

void ndv_lm_modord(NDV p,DL d)

{

NMV m;

DL tmp;

int len,i,ret;

NEWDL(tmp,nd_nvar);

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

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

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

_ndltodl(DL(m),tmp);

ret = comp_sig_monomial(nd_nvar,tmp,d);

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

}

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

}

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

/* return 1 if success, 0 if failure (HC(a mod p)) */

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

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

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

if ( nd_sba_modord )

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

else

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

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

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

int obpe,oadv,ompos,cbpe;

VECT hvect;

NcriB = NcriMF = Ncri2 = 0;

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

Line 4613 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 4153 void nd_gr(LIST f,LIST v,int m,int homo,int retdp,int

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

}

} else {

e = getdeg(tv->v,(P)BDY(t));

if ( OID(BDY(t)) == O_DP ) {

max = MAX(e,max);

e = dp_getdeg((DP)BDY(t));

max = MAX(e,max);

} else {

e = getdeg(tv->v,(P)BDY(t));

max = MAX(e,max);

}

nd_setup_parameters(nvar,nd_nzlist?0:max);

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

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

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

}

} else {

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

if ( OID(BDY(t)) == O_DP ) {

else zp = (P)BDY(t);

DP zdp;

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

if ( !m && !nd_gentrace ) dp_ptozp((DP)BDY(t),&zdp);

else zdp = (DP)BDY(t);

b = (pointer)dptondv(m,zdp);

} else {

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

else zp = (P)BDY(t);

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

}

if ( ishomo )

ishomo = ishomo && ndv_ishomo(b);

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

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

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

int e,max,nvar,i;

NDV b;

int ishomo,nalg,wmax,len;

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

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

nd_module = 0;

nd_demand = 0;

parse_nd_option(current_option);

Nsamesig = 0;

if ( DP_Multiple )

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

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

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

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

initd(ord);

for ( t = BDY(f), max = 1; t; t = NEXT(t) ) {

for ( tv = vv; tv; tv = NEXT(tv) ) {

e = getdeg(tv->v,(P)BDY(t));

if ( OID(BDY(t)) == O_DP ) {

max = MAX(e,max);

e = dp_getdeg((DP)BDY(t));

max = MAX(e,max);

} else {

e = getdeg(tv->v,(P)BDY(t));

max = MAX(e,max);

}

nd_setup_parameters(nvar,max);

obpe = nd_bpe; oadv = nmv_adv; oepos = nd_epos; ompos = nd_mpos;

ishomo = 1;

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

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

if ( OID(BDY(t)) == O_DP ) {

else zp = (P)BDY(t);

DP zdp;

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

if ( !m ) dp_ptozp((DP)BDY(t),&zdp);

else zdp = (DP)BDY(t);

b = (pointer)dptondv(m,zdp);

} else {

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

else zp = (P)BDY(t);

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

}

if ( ishomo )

ishomo = ishomo && ndv_ishomo(b);

if ( m ) ndv_mod(m,b);

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

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

}

homogenize_order(ord,nvar,&ord1);

nd_init_ord(ord1);

// for SIG comparison

initd(ord1);

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

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

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

}

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

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

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

if ( !x ) {

*rp = 0; return;

}

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

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

/* dehomogenization */

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

nd_init_ord(ord);

// for SIG comparison

initd(ord);

nd_setup_parameters(nvar,0);

}

nd_demand = 0;

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

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

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

}

if ( r0 ) NEXT(r) = 0;

MKLIST(*rp,r0);

if ( nd_sba_syz ) {

LIST gb,hsyz;

NODE nd;

MKLIST(gb,r0);

MKLIST(hsyz,syz);

nd = mknode(2,gb,hsyz);

MKLIST(*rp,nd);

} else

MKLIST(*rp,r0);

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

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

}

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

Line 4964 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 4567 void nd_gr_recompute_trace(LIST f,LIST v,int m,struct

Line 5112 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 4664 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int

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

Z jq,bpe;

VECT hvect;

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 4677 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int

Line 5224 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 4731 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int

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

}

} else {

if ( OID(BDY(t)) == O_DP ) {

e = dp_getdeg((DP)BDY(t));

max = MAX(e,max);

} else {

e = getdeg(tv->v,(P)BDY(t));

max = MAX(e,max);

}

nd_setup_parameters(nvar,max);

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

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

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

}

} else {

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

if ( OID(BDY(t)) == O_DP ) {

else zp = (P)BDY(t);

DP zdp;

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

if ( !nd_gentrace ) dp_ptozp((DP)BDY(t),&zdp);

else zdp = (DP)BDY(t);

c = (pointer)dptondv(m,zdp);

} else {

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

else zp = (P)BDY(t);

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

}

if ( ishomo )

ishomo = ishomo && ndv_ishomo(c);

Line 5491 int nd_get_exporigin(struct order_spec *ord)

Line 6050 int nd_get_exporigin(struct order_spec *ord)

void nd_setup_parameters(int nvar,int max) {

int i,j,n,elen,ord_o,ord_l,l,s,wpd;

struct order_pair *op;

extern int CNVars;

nd_nvar = nvar;

CNVars = nvar;

if ( max ) {

/* XXX */

if ( do_weyl ) nd_bpe = 32;

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

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

Line 6970 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 6622 int nmv_comp(NMV a,NMV b)

Line 7184 int nmv_comp(NMV a,NMV b)

return -t;

}

NDV dptondv(int mod,DP p)

{

NDV d;

NMV m,m0;

MP t;

MP *a;

int i,len,n;

if ( !p ) return 0;

for ( t = BDY(p), len = 0; t; t = NEXT(t), len++ );

n = p->nv;

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

m0 = m = (NMV)MALLOC_ATOMIC_IGNORE_OFF_PAGE(len*nmv_adv);

else

m0 = m = MALLOC(len*nmv_adv);

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

dltondl(n,t->dl,DL(m));

TD(DL(m)) = ndl_weight(DL(m));

CZ(m) = (Z)t->c;

}

qsort(m0,len,nmv_adv,(int (*)(const void *,const void *))nmv_comp);

MKNDV(NV(p),m0,len,d);

SG(d) = SG(p);

return d;

}

NDV dpmtondv(int mod,DPM p)

{

NDV d;

Line 6698 DP ndvtodp(int mod,NDV p)

Line 7286 DP ndvtodp(int mod,NDV p)

return d;

}

DPM sigtodpm(SIG s)

{

DMM m;

DPM d;

NEWDMM(m);

m->c = (Obj)ONE;

m->dl = s->dl;

m->pos = s->pos+1;

m->next = 0;

MKDPM(nd_nvar,m,d);

SG(d) = s->dl->td;

return d;

}

DPM ndvtodpm(int mod,NDV p)

{

DMM m,m0;

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

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

NDVI w;

NODE t,t0;

if ( nd_norb ) return x;

len = length(x);

w = (NDVI)MALLOC(len*sizeof(struct oNDVI));

for ( i = 0, t = x; i < len; i++, t = NEXT(t) ) {

Line 7458 int ndv_reduce_vect_q(Z *svect0,int trace,int col,IndA

Line 8062 int ndv_reduce_vect_q(Z *svect0,int trace,int col,IndA

}

#endif

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

int ndv_reduce_vect(int m,UINT *svect,int col,IndArray *imat,NM_ind_pair *rp0,int nred,SIG sig)

{

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

UINT c,c1,c2,c3,up,lo,dmy;

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

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

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

ivect = imat[i];

k = ivect->head; svect[k] %= m;

if ( (c = svect[k]) != 0 ) {

if ( (c = svect[k]) != 0 && (sig == 0 || comp_sig(sig,rp0[i]->sig) > 0 ) ) {

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

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

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

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

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

ivc = ivect->index.c;

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

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

if ( c1 ) {

c2 = svect[pos];

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

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

} else svect[pos] = lo;

}

break;

case 2:

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

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

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

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

prev = pos;

if ( c1 ) {

c2 = svect[pos];

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

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

} else svect[pos] = lo;

}

break;

case 4:

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

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

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

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

prev = pos;

if ( c1 ) {

c2 = svect[pos];

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

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

} else svect[pos] = lo;

}

break;

}

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

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

}

NDV vect_to_ndv_s(UINT *vect,int col,UINT *s0vect)

{

int j,k,len;

UINT *p;

UINT c;

NDV r;

NMV mr0,mr;

for ( j = 0, len = 0; j < col; j++ ) if ( vect[j] ) len++;

if ( !len ) return 0;

else {

mr0 = (NMV)MALLOC_ATOMIC_IGNORE_OFF_PAGE(nmv_adv*len);

mr = mr0;

p = s0vect;

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

if ( (c = vect[k++]) != 0 ) {

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

}

MKNDV(nd_nvar,mr0,len,r);

return r;

}

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

{

int j,k,len;

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

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

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

fprintf(asir_out,"symb=%.3fsec,conv=%.3fsec,elim1=%.3fsec,elim2=%.3fsec\n",

f4_symb.exectime,f4_conv.exectime,f4_elim1.exectime,f4_elim2.exectime);

fprintf(asir_out,"number of removed pairs=%d\n,",NcriB+NcriMF+Ncri2);

}

conv_ilist(nd_demand,0,g,indp);

return g;

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

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

if ( m == -1 )

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

else

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

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

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

if ( i < col ) {

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

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

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

return r0;

}

NODE nd_f4_red_main_s(int m,ND_pairs sp0,int nsp,UINT *s0vect,int col,

NM_ind_pair *rvect,int *rhead,IndArray *imat,int nred,NODE *syzlistp)

{

int spcol,sprow,a;

int i,j,k,l,rank;

NODE r0,r;

ND_pairs sp;

ND spol;

UINT **spmat;

UINT *svect,*cvect;

UINT *v;

int *colstat;

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

int maxrs;

int *spsugar;

ND_pairs *spactive;

SIG *spsig;

get_eg(&eg0);

/* elimination (1st step) */

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

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

spsig = (SIG *)MALLOC(nsp*sizeof(SIG));

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

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

if ( !spol ) {

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

continue;

}

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

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

maxrs = ndv_reduce_vect(m,svect,col,imat,rvect,nred,spol->sig);

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

if ( i < col ) {

spmat[sprow] = svect;

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

spsig[sprow] = sp->sig;

sprow++;

} else {

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

}

nd_free(spol);

}

get_eg(&eg1); init_eg(&eg_f4_1); add_eg(&eg_f4_1,&eg0,&eg1); add_eg(&f4_elim1,&eg0,&eg1);

if ( DP_Print ) {

fprintf(asir_out,"elim1=%.3fsec,",eg_f4_1.exectime);

fflush(asir_out);

}

/* free index arrays */

for ( i = 0; i < nred; i++ ) GCFREE(imat[i]->index.c);

/* elimination (2nd step) */

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

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

r0 = 0;

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

if ( spsugar[i] >= 0 ) {

NEXTNODE(r0,r);

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

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;

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

fprintf(asir_out,"elim2=%.3fsec,",eg_f4_2.exectime);

fprintf(asir_out,"nsp=%d,nred=%d,spmat=(%d,%d),rank=%d ",

nsp,nred,sprow,col,rank);

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

}

return r0;

}

/* for small finite fields */

NODE nd_f4_red_sf_main(int m,ND_pairs sp0,int nsp,UINT *s0vect,int col,

Line 8923 int nd_gauss_elim_mod(UINT **mat0,int *sugar,ND_pairs

Line 9628 int nd_gauss_elim_mod(UINT **mat0,int *sugar,ND_pairs

return rank;

}

int nd_gauss_elim_mod_s(UINT **mat,int *sugar,ND_pairs *spactive,int row,int col,int md,int *colstat,SIG *sig)

{

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

UINT inv;

UINT a;

UINT *t,*pivot,*pk;

UINT *ck;

UINT *ct;

ND_pairs pair;

SIG sg;

int *used;

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

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

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

a = mat[i][j] %= md;

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

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

if ( i == row ) {

colstat[j] = 0;

continue;

} else {

colstat[j] = 1;

used[i] = 1;

}

/* column j is normalized */

s = sugar[i];

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

/* normalize pivot row */

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

DMAR(*pk,inv,0,md,*pk);

}

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

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

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

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

Nf4_red++;

}

rank = 0;

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

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

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

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

else rank++;

}

return rank;

}

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

{

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

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

Line 10373 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_gbblock = 0;

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

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

nd_splist = 0; nd_check_splist = 0;

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

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_dontsort = 0; nd_top = 0; nd_sba_redundant_check = 0;

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

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

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

Line 9642 void parse_nd_option(NODE opt)

Line 10399 void parse_nd_option(NODE opt)

nd_gensyz = value?1:0;

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

nd_nora = value?1:0;

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

nd_norb = value?1:0;

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

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

u = BDY((LIST)value);

Line 9687 void parse_nd_option(NODE opt)

Line 10446 void parse_nd_option(NODE opt)

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

nd_sba_pot = ZTOS((Q)value);

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

nd_sba_largelcm = value?1:0;

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

nd_sba_dontsort = value?1:0;

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

nd_sba_syz = value?1:0;

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

// 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_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") ) {

nd_top = value?1:0;

}

if ( nd_sba_syz ) nd_sba_dontsort = 1;

}

ND mdptond(DP d);

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

Line 10677 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 9969 MAT nd_btog_lf(LIST f,LIST v,struct order_spec *ord,LI

Line 10746 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 10040 VECT nd_btog_one(LIST f,LIST v,int mod,struct order_sp

Line 10817 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 10154 void nd_f4_lf_trace(LIST f,LIST v,int trace,int homo,s

Line 10931 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 10660 int nd_gauss_elim_mod64(mp_limb_t **mat,int *sugar,ND_

Line 11437 int nd_gauss_elim_mod64(mp_limb_t **mat,int *sugar,ND_

GCFREE(cmat);

return rank;

}

#endif

int nd_gauss_elim_mod64_s(mp_limb_t **mat,int *sugar,ND_pairs *spactive,int row,int col,int md,int *colstat,SIG *sig)

{

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

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

}

return r0;

}

#endif

NODE nd_f4_red_s(int m,ND_pairs sp0,int trace,UINT *s0vect,int col,NODE rp0,NODE *syzlistp)

{

Line 10840 NODE nd_f4_red_s(int m,ND_pairs sp0,int trace,UINT *s0

Line 11617 NODE nd_f4_red_s(int m,ND_pairs sp0,int trace,UINT *s0

fflush(asir_out);

}

if ( m > 0 )

#if SIZEOF_LONG==8

r0 = nd_f4_red_mod64_main_s(m,sp0,nsp,s0vect,col,rvect,rhead,imat,nred,syzlistp);

#else

r0 = nd_f4_red_main_s(m,sp0,nsp,s0vect,col,rvect,rhead,imat,nred,syzlistp);

#endif

else

// r0 = nd_f4_red_q_main_s(sp0,nsp,trace,s0vect,col,rvect,rhead,imat,nred);

error("nd_f4_red_q_main_s : not implemented yet");

Line 10950 NODE nd_sba_f4(int m,int **indp)

Line 11731 NODE nd_sba_f4(int m,int **indp)

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

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

NODE r,g,rp0,nflist;

ND_pairs d,l,t;

ND_pairs d,l,t,l1;

ND h,nf;

NDV nfv;

union oNDC hc;

Line 10978 NODE nd_sba_f4(int m,int **indp)

Line 11759 NODE nd_sba_f4(int m,int **indp)

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

again:

l = d; d = d->next;

#if 0

if ( small_lcm(l) ) {

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

continue;

}

sig = l->sig;

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

#else

l1 = find_smallest_lcm(l);

if ( l1 == 0 ) {

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

continue;

}

sig = l1->sig;

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

#endif

if ( !stat ) {

NEXT(l) = d; d = l;

d = nd_reconstruct(0,d);

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