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.51 and 1.66

version 1.51, 2021/03/09 07:07:02

version 1.66, 2022/04/03 06:45:47

Line 1

/* $OpenXM: OpenXM_contrib2/asir2018/engine/nd.c,v 1.50 2021/03/09 05:20:35 noro Exp $ */

/* $OpenXM: OpenXM_contrib2/asir2018/engine/nd.c,v 1.65 2022/04/03 00:39:12 noro Exp $ */

#include "nd.h"

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 178 void _NM_alloc()

matrix alloc_matrix(int row,int col)

{

unsigned long **a;

int i,len,blen;

matrix mat;

mat = (matrix)MALLOC(sizeof(struct matrix));

Line 383 void ndl_dehomogenize(UINT *d)

Line 382 void ndl_dehomogenize(UINT *d)

void ndl_lcm(UINT *d1,unsigned *d2,UINT *d)

{

UINT t1,t2,u,u1,u2;

int i,j,l;

int i,j;

if ( nd_module && (MPOS(d1) != MPOS(d2)) )

error("ndl_lcm : inconsistent monomials");

Line 481 void ndl_lcm(UINT *d1,unsigned *d2,UINT *d)

Line 480 void ndl_lcm(UINT *d1,unsigned *d2,UINT *d)

void ndl_max(UINT *d1,unsigned *d2,UINT *d)

{

UINT t1,t2,u,u1,u2;

int i,j,l;

int i,j;

for ( i = nd_exporigin; i < nd_wpd; i++ ) {

u1 = d1[i]; u2 = d2[i];

Line 521 int ndl_weight(UINT *d)

Line 520 int ndl_weight(UINT *d)

int ndl_weight2(UINT *d)

{

int t,u;

int i,j;

int i;

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

u = GET_EXP(d,i);

Line 579 int ndl_lex_compare(UINT *d1,UINT *d2)

Line 578 int ndl_lex_compare(UINT *d1,UINT *d2)

int ndl_block_compare(UINT *d1,UINT *d2)

{

int i,l,j,ord_o,ord_l;

int i,l,j,ord_o;

struct order_pair *op;

UINT t1,t2,m;

UINT *mask;

Line 748 int ndl_module_glex_compare(UINT *d1,UINT *d2)

Line 747 int ndl_module_glex_compare(UINT *d1,UINT *d2)

break;

case 1:

if ( nd_pot_nelim && MPOS(d1)>=nd_pot_nelim+1 && MPOS(d2) >= nd_pot_nelim+1 ) {

if ( nd_pot_nelim && MPOS(d1)>=(UINT)(nd_pot_nelim+1) && MPOS(d2) >= (UINT)(nd_pot_nelim+1) ) {

if ( TD(d1) > TD(d2) ) return 1;

else if ( TD(d1) < TD(d2) ) return -1;

if ( (c = ndl_lex_compare(d1,d2)) != 0 ) return c;

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

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

if ( pos1 == pos2 ) return (*dl_base_compare_function)(nd_nvar,d1,d2);

}

// comparison by the bottom order

LAST:

switch ( nd_base_ordtype ) {

case 0:

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

Line 995 INLINE void ndl_sub(UINT *d1,UINT *d2,UINT *d)

Line 993 INLINE void ndl_sub(UINT *d1,UINT *d2,UINT *d)

int ndl_disjoint(UINT *d1,UINT *d2)

{

UINT t1,t2,u,u1,u2;

UINT t1,t2,u1,u2;

int i,j;

if ( nd_module && (MPOS(d1) == MPOS(d2)) ) return 0;

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

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

ND nd_merge(ND p1,ND p2)

{

int n,c;

int c;

int t,can,td1,td2;

int can;

ND r;

NM m1,m2,mr0,mr,s;

if ( !p1 ) return p2;

else if ( !p2 ) return p1;

else {

can = 0;

for ( n = NV(p1), m1 = BDY(p1), m2 = BDY(p2), mr0 = 0; m1 && m2; ) {

for ( m1 = BDY(p1), m2 = BDY(p2), mr0 = 0; m1 && m2; ) {

c = DL_COMPARE(DL(m1),DL(m2));

switch ( c ) {

case 0:

Line 1356 ND nd_merge(ND p1,ND p2)

Line 1355 ND nd_merge(ND p1,ND p2)

ND nd_add(int mod,ND p1,ND p2)

{

int n,c;

int c;

int t,can,td1,td2;

int t,can;

ND r;

NM m1,m2,mr0,mr,s;

Nnd_add++;

Line 1369 ND nd_add(int mod,ND p1,ND p2)

Line 1367 ND nd_add(int mod,ND p1,ND p2)

else if ( !mod ) return nd_add_q(p1,p2);

else {

can = 0;

for ( n = NV(p1), m1 = BDY(p1), m2 = BDY(p2), mr0 = 0; m1 && m2; ) {

for ( m1 = BDY(p1), m2 = BDY(p2), mr0 = 0; m1 && m2; ) {

c = DL_COMPARE(DL(m1),DL(m2));

switch ( c ) {

case 0:

Line 1430 int nm_destructive_add_q(NM *m1,NM *m2,NM *mr0,NM *mr)

Line 1428 int nm_destructive_add_q(NM *m1,NM *m2,NM *mr0,NM *mr)

ND nd_add_q(ND p1,ND p2)

{

int n,c,can;

int c,can;

ND r;

NM m1,m2,mr0,mr,s;

P t;

Line 1439 ND nd_add_q(ND p1,ND p2)

Line 1436 ND nd_add_q(ND p1,ND p2)

else if ( !p2 ) return p1;

else {

can = 0;

for ( n = NV(p1), m1 = BDY(p1), m2 = BDY(p2), mr0 = 0; m1 && m2; ) {

for ( m1 = BDY(p1), m2 = BDY(p2), mr0 = 0; m1 && m2; ) {

c = DL_COMPARE(DL(m1),DL(m2));

switch ( c ) {

case 0:

Line 1481 ND nd_add_q(ND p1,ND p2)

Line 1478 ND nd_add_q(ND p1,ND p2)

ND nd_add_sf(ND p1,ND p2)

{

int n,c,can;

int c,can;

ND r;

NM m1,m2,mr0,mr,s;

int t;

Line 1490 ND nd_add_sf(ND p1,ND p2)

Line 1486 ND nd_add_sf(ND p1,ND p2)

else if ( !p2 ) return p1;

else {

can = 0;

for ( n = NV(p1), m1 = BDY(p1), m2 = BDY(p2), mr0 = 0; m1 && m2; ) {

for ( m1 = BDY(p1), m2 = BDY(p2), mr0 = 0; m1 && m2; ) {

c = DL_COMPARE(DL(m1),DL(m2));

switch ( c ) {

case 0:

Line 1572 ND nd_reduce2(int mod,ND d,ND g,NDV p,NM mul,NDC dn,Ob

Line 1568 ND nd_reduce2(int mod,ND d,ND g,NDV p,NM mul,NDC dn,Ob

/* ret=1 : success, ret=0 : overflow */

int nd_nf(int mod,ND d,ND g,NDV *ps,int full,ND *rp)

{

NM m,mrd,tail;

NM m,tail;

NM mul;

int n,sugar,psugar,sugar0,stat,index;

int n,sugar,index;

int c,c1,c2,dummy;

RHist h;

NDV p,red;

NDV p;

Q cg,cred,gcd,tq,qq;

Z iq;

DP dmul;

NODE node;

LIST hist;

double hmag;

P tp,tp1;

Obj div;

Obj tr,tr1,div;

union oNDC hg;

P cont;

Line 1595 int nd_nf(int mod,ND d,ND g,NDV *ps,int full,ND *rp)

Line 1588 int nd_nf(int mod,ND d,ND g,NDV *ps,int full,ND *rp)

}

if ( !mod ) hmag = ((double)p_mag(HCP(g)))*nd_scale;

sugar0 = sugar = SG(g);

sugar = SG(g);

n = NV(g);

mul = (NM)MALLOC(sizeof(struct oNM)+(nd_wpd-1)*sizeof(UINT));

if ( d )

Line 1618 int nd_nf(int mod,ND d,ND g,NDV *ps,int full,ND *rp)

Line 1611 int nd_nf(int mod,ND d,ND g,NDV *ps,int full,ND *rp)

nmtodp(mod,mul,&dmul);

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

}

sugar = MAX(sugar,SG(p)+TD(DL(mul)));

sugar = MAX(sugar,(int)(SG(p)+TD(DL(mul))));

if ( !mod && g && !nd_vc && ((double)(p_mag(HCP(g))) > hmag) ) {

hg = HCU(g);

nd_removecont2(d,g);

Line 1660 int nd_nf(int mod,ND d,ND g,NDV *ps,int full,ND *rp)

Line 1653 int nd_nf(int mod,ND d,ND g,NDV *ps,int full,ND *rp)

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

{

NM m,mrd,tail;

NM m,tail;

NM mul;

int n,sugar,psugar,sugar0,stat,index;

int n,sugar,index;

int c,c1,c2,dummy;

RHist h;

NDV p,red;

NDV p;

Q cg,cred,gcd,tq,qq;

Z iq;

DP dmul;

NODE node;

LIST hist;

double hmag;

P tp,tp1;

Obj div;

Obj tr,tr1,div;

// union oNDC hg;

union oNDC hg;

P cont;

SIG sig;

if ( !g ) {

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

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

}

if ( !mod ) hmag = ((double)p_mag(HCP(g)))*nd_scale;

sugar0 = sugar = SG(g);

sugar = SG(g);

n = NV(g);

mul = (NM)MALLOC(sizeof(struct oNM)+(nd_wpd-1)*sizeof(UINT));

if ( d )

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

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

p = ps[index];

/* d+g -> div*(d+g)+mul*p */

g = nd_reduce2(mod,d,g,p,mul,0,&div);

sugar = MAX(sugar,SG(p)+TD(DL(mul)));

sugar = MAX(sugar,(int)(SG(p)+TD(DL(mul))));

if ( !mod && g && ((double)(p_mag(HCP(g))) > hmag) ) {

hg = HCU(g);

// hg = HCU(g);

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 1742 int nd_nf_pbucket(int mod,ND g,NDV *ps,int full,ND *rp

Line 1739 int nd_nf_pbucket(int mod,ND g,NDV *ps,int full,ND *rp

{

int hindex,index;

NDV p;

ND u,d,red;

ND d,red;

NODE l;

NM mul,m,tail;

NM mul,m,mrd,tail;

int sugar,psugar,n;

int sugar,psugar,n,h_reducible;

PGeoBucket bucket;

int c,c1,c2;

Z cg,cred,gcd,zzz;

Z cg,cred,gcd;

RHist h;

double hmag,gmag;

int count = 0;

Line 1854 int nd_nf_pbucket_s(int mod,ND g,NDV *ps,int full,ND *

Line 1850 int nd_nf_pbucket_s(int mod,ND g,NDV *ps,int full,ND *

{

int hindex,index;

NDV p;

ND u,d,red;

ND d,red;

NODE l;

NM mul,m,tail;

NM mul,m,mrd,tail;

int sugar,psugar,n;

int sugar,psugar,n,h_reducible;

PGeoBucket bucket;

int c,c1,c2;

Z cg,cred,gcd,zzz;

Z cg,cred,gcd;

RHist h;

double hmag,gmag;

int count = 0;

Line 1980 int nd_nf_pbucket_s(int mod,ND g,NDV *ps,int full,ND *

Line 1975 int nd_nf_pbucket_s(int mod,ND g,NDV *ps,int full,ND *

int ndv_check_membership(int m,NODE input,int obpe,int oadv,EPOS oepos,NODE cand)

{

int n,i,stat;

int i,stat;

ND nf,d;

NDV r;

NODE t,s;

union oNDC dn;

Z q;

LIST list;

ndv_setup(m,0,cand,nd_gentrace?1:0,1,0);

n = length(cand);

// n = length(cand);

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

/* membercheck : list is a subset of Id(cand) ? */

Line 2096 void add_pbucket_symbolic(PGeoBucket g,ND d)

Line 2090 void add_pbucket_symbolic(PGeoBucket g,ND d)

#else

void add_pbucket_symbolic(PGeoBucket g,ND d)

{

int l,i,k,m,m0;

int l,k,m,m0;

if ( !d )

return;

Line 2139 void add_pbucket(int mod,PGeoBucket g,ND d)

Line 2133 void add_pbucket(int mod,PGeoBucket g,ND d)

#else

void add_pbucket(int mod,PGeoBucket g,ND d)

{

int l,i,k,m,m0;

int l,k,m,m0;

m0 = g->m;

while ( d != 0 ) {

Line 2201 NM remove_head_pbucket_symbolic(PGeoBucket g)

Line 2195 NM remove_head_pbucket_symbolic(PGeoBucket g)

int head_pbucket(int mod,PGeoBucket g)

{

int j,i,c,k,nv,sum;

int j,i,c,k,sum;

UINT *di,*dj;

UINT *dj;

ND gi,gj;

k = g->m;

Line 2247 int head_pbucket(int mod,PGeoBucket g)

Line 2241 int head_pbucket(int mod,PGeoBucket g)

int head_pbucket_q(PGeoBucket g)

{

int j,i,c,k,nv;

int j,i,c,k;

Z sum,t;

ND gi,gj;

Line 2261 int head_pbucket_q(PGeoBucket g)

Line 2255 int head_pbucket_q(PGeoBucket g)

gj = g->body[j];

sum = HCZ(gj);

} else {

nv = NV(gi);

// nv = NV(gi);

c = DL_COMPARE(HDL(gi),HDL(gj));

if ( c > 0 ) {

if ( sum ) HCZ(gj) = sum;

Line 2287 int head_pbucket_q(PGeoBucket g)

Line 2281 int head_pbucket_q(PGeoBucket g)

int head_pbucket_lf(PGeoBucket g)

{

int j,i,c,k,nv;

int j,i,c,k;

Z sum,t;

ND gi,gj;

Line 2301 int head_pbucket_lf(PGeoBucket g)

Line 2295 int head_pbucket_lf(PGeoBucket g)

gj = g->body[j];

sum = HCZ(gj);

} else {

nv = NV(gi);

// nv = NV(gi);

c = DL_COMPARE(HDL(gi),HDL(gj));

if ( c > 0 ) {

if ( sum ) HCZ(gj) = sum;

Line 2328 int head_pbucket_lf(PGeoBucket g)

Line 2322 int head_pbucket_lf(PGeoBucket g)

ND normalize_pbucket(int mod,PGeoBucket g)

{

int i;

ND r,t;

ND r;

r = 0;

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

Line 2369 void register_hcf(NDV p)

Line 2363 void register_hcf(NDV p)

#else

void register_hcf(NDV p)

{

DCP dc,t;

P hc,h,q;

Q dmy;

int c;

Line 2403 void register_hcf(NDV p)

Line 2396 void register_hcf(NDV p)

int do_diagonalize(int sugar,int m)

{

int i,nh,stat;

int i,stat;

NODE r,g,t;

ND nf,s,head;

ND h,nf,s,head;

NDV nfv;

Q q;

P cont;

P nm,nmp,dn,mnp,dnp,cont,cont1;

union oNDC hc;

NODE node;

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 2470 LIST compute_splist()

Line 2462 LIST compute_splist()

}

typedef struct oHPDATA {

P hn; // HP(t)=hn(t)/(1-t)^n

int n;

int len;

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

P *head; // hp(i)=head[i] (i=0,...,len-1)

P hp; // dim Hm(i)=hp(i) (i >= len)

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

P *plist; // plist[i]=(1-t)^i

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

void mhp_to_hf(VL vl,P hp,int n,P *plist,VECT *head,P *hf);

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

LIST dp_monomial_hilbert_poincare(VECT b,VECT x,P *plist);

LIST dp_monomial_hilbert_poincare(VECT b,VECT x);

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

int hpvalue(HPDATA data,int d)

{

P *head;

int len;

P hp,val;

Z dz;

head = data->head;

len = data->len;

hp = data->hp;

if ( d < len )

return ZTOS((Z)head[d]);

else {

STOZ(d,dz);

substp(CO,hp,hp->v,(P)dz,&val);

return ZTOS((Z)val);

}

void setup_hpdata(HPDATA final,HPDATA current)

{

int n,i;

P *r;

DL *p;

P tv;

VECT b,x;

VECT b,x,head;

DL dl;

LIST ret;

int *w;

n = nd_nvar;

final->n = n = nd_nvar;

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

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

head = (VECT)ARG2(nd_hpdata);

#if 0

final->len = head->len;

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

final->head = (P *)BDY(head);

wlen = length(BDY(weight));

final->hp = (P)ARG3(nd_hpdata);

if ( n != wlen )

final->plist = (P *)BDY((VECT)ARG4(nd_hpdata));

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;

r = (P *)CALLOC(n+1,sizeof(P));

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

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

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

}

make_reduced(b,n);

if ( w ) {

makevar("t",&tv);

ret = dp_monomial_hilbert_poincare_weight(b,x,w);

mhp_rec(b,x,tv,r);

} else

current->hn = mhp_ctop(r,final->plist,n);

ret = dp_monomial_hilbert_poincare(b,x);

mhp_to_hf(CO,current->hn,n,final->plist,&head,&current->hp);

current->n = n;

current->head = (P *)BDY(head);

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

current->len = head->len;

current->x = x;

current->plist = final->plist;

current->w = w;

}

void update_hpdata(HPDATA current,int nh,int do_hf)

int comp_hn(P a, P b)

{

NODE data1,nd,t;

P s;

DL new,dl;

DCP dc;

int len,i,n;

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;

DL new;

int i,n;

Z dz;

DL *p;

VECT b,head;

VECT b;

P tv,td,s,hn,hpoly;

P tv,td,s,hn;

LIST list1;

n = nd_nvar;

Line 2560 void update_hpdata(HPDATA current,int nh,int do_hf)

Line 2552 void update_hpdata(HPDATA current,int nh,int do_hf)

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

}

// compute HP(I:new)

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

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

Line 2568 void update_hpdata(HPDATA current,int nh,int do_hf)

Line 2563 void update_hpdata(HPDATA current,int nh,int do_hf)

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

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

current->hn = hn;

if ( do_hf ) {

mhp_to_hf(CO,hn,n,current->plist,&head,&hpoly);

current->head = (P *)BDY(head);

current->len = head->len;

current->hp = hpoly;

}

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 )

if ( SG(cur) == sugar ) {

prev->next = cur->next;

else

i++;

} else

prev = cur;

cur = cur->next;

}

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

return root.next;

}

Line 2598 ND_pairs nd_remove_same_sugar( ND_pairs d, int sugar)

Line 2591 ND_pairs nd_remove_same_sugar( ND_pairs d, int sugar)

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

{

int i,nh,sugar,stat;

NODE r,g,t;

NODE g,t;

ND_pairs d;

ND_pairs l;

ND h,nf,s,head,nf1;

ND h,nf;

NDV nfv;

Z q;

union oNDC dn,hc;

union oNDC hc;

int diag_count = 0;

int Nnfnz = 0,Nnfz = 0;

P cont;

LIST list;

struct oHPDATA current_hpdata,final_hpdata;

int final_hpvalue;

struct oEGT eg1,eg2,eg_update;

Line 2623 init_eg(&eg_update);

Line 2615 init_eg(&eg_update);

}

sugar = 0;

if ( nd_hpdata ) {

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

setup_hpdata(&final_hpdata,&current_hpdata);

}

while ( d ) {

Line 2641 again:

Line 2634 again:

}

sugar = SG(l);

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

if ( nd_hpdata ) {

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

break;

else {

final_hpvalue = hpvalue(&final_hpdata,sugar);

if ( final_hpvalue == hpvalue(&current_hpdata,sugar) ) {

if ( DP_Print ) fprintf(asir_out,"sugar=%d done.\n",sugar);

d = nd_remove_same_sugar(d,sugar);

continue;

}

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

if ( !stat ) {

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

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

g = update_base(g,nh);

FREENDP(l);

if ( nd_hpdata ) {

update_hpdata(&current_hpdata,nh,1);

int dg,sugar0;

if ( final_hpvalue == hpvalue(&current_hpdata,sugar) ) {

if ( DP_Print ) fprintf(asir_out,"sugar=%d done.\n",sugar);

update_hpdata(&current_hpdata,nh);

d = nd_remove_same_sugar(d,sugar);

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

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

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

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

Line 2827 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 2856 ND_pairs find_smallest_lcm(ND_pairs l)

Line 2875 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 2889 ND_pairs find_smallest_lcm(ND_pairs l)

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

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

}

Line 2990 int dlength(ND_pairs d)

Line 3016 int dlength(ND_pairs d)

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

{

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

NODE r,t,g;

NODE g;

ND_pairs *d;

ND_pairs l,l1;

ND h,nf,s,head,nf1;

ND h,nf;

NDV nfv;

Z q;

// union oNDC hc;

union oNDC dn,hc;

P cont;

LIST list;

SIG sig;

NODE *syzlist;

int ngen,ind;

int Nnominimal,Nredundant;

DL lcm,quo,mul;

struct oHPDATA final_hpdata,current_hpdata;

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

struct oEGT eg1,eg2,eg3,eg4,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;

Line 3018 init_eg(&eg_remove);

Line 3041 init_eg(&eg_remove);

Nnominimal = 0;

Nredundant = 0;

ngen = nd_psn;

if ( !do_weyl ) {

if ( !do_weyl || nd_sba_inputisgb ) {

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

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

sig = trivial_sig(i,j);

Line 3049 init_eg(&eg_hpdata);

Line 3072 init_eg(&eg_hpdata);

init_eg(&eg_sbabuch);

get_eg(&eg3);

while ( 1 ) {

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

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

again :

get_eg(&eg1);

ind = nd_minsig(d);

Line 3062 get_eg(&eg1);

Line 3085 get_eg(&eg1);

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

if ( l1 == 0 ) {

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

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

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

Nnominimal++;

continue;

}

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

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

}

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

Line 3113 get_eg(&eg2);

Line 3136 get_eg(&eg2);

fflush(stdout);

}

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

hc = HCU(nf);

// hc = HCU(nf);

get_eg(&eg1);

nd_removecont(m,nf);

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;

get_eg(&eg1);

update_hpdata(&current_hpdata,nh,0);

update_hpdata(&current_hpdata,nh);

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

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

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

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

}

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

g = conv_ilist_s(nd_demand,0,indp);

if ( DP_Print ) {

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;

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;

}

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

Line 3206 int check_splist(int m,NODE splist)

Line 3241 int check_splist(int m,NODE splist)

for ( d = 0, t = splist; t; t = NEXT(t) ) {

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

NEXTND_pairs(d,r);

r->i1 = ZTOS((Q)ARG0(p)); r->i2 = ZTOS((Q)ARG1(p));

r->i1 = (int)ZTOS((Q)ARG0(p)); r->i2 = (int)ZTOS((Q)ARG1(p));

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

SG(r) = TD(LCM(r)); /* XXX */

}

Line 3244 int check_splist_f4(int m,NODE splist)

Line 3279 int check_splist_f4(int m,NODE splist)

for ( d = 0, t = splist; t; t = NEXT(t) ) {

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

NEXTND_pairs(d,r);

r->i1 = ZTOS((Q)ARG0(p)); r->i2 = ZTOS((Q)ARG1(p));

r->i1 = (int)ZTOS((Q)ARG0(p)); r->i2 = (int)ZTOS((Q)ARG1(p));

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

SG(r) = TD(LCM(r)); /* XXX */

}

Line 3275 int check_splist_f4(int m,NODE splist)

Line 3310 int check_splist_f4(int m,NODE splist)

int do_diagonalize_trace(int sugar,int m)

{

int i,nh,stat;

int i,stat;

NODE r,g,t;

ND nf,s,head;

ND h,nf,nfq,s,head;

NDV nfv;

NDV nfv,nfqv;

Q q,den,num;

union oNDC hc;

NODE node;

LIST l;

Z iq;

P cont,cont1;

P cont;

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 3346 void nd_subst_vector(VL vl,P p,NODE subst,P *r)

Line 3380 void nd_subst_vector(VL vl,P p,NODE subst,P *r)

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

{

int i,nh,sugar,stat;

NODE r,g,t;

NODE g,t;

ND_pairs d;

ND_pairs l;

ND h,nf,nfq,s,head;

ND h,nf,nfq;

NDV nfv,nfqv;

Z q,den,num;

Z q;

P hc;

union oNDC dn,hnfq;

union oNDC hnfq;

struct oEGT eg_monic,egm0,egm1;

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

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

}

sugar = 0;

if ( nd_hpdata ) {

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

setup_hpdata(&final_hpdata,&current_hpdata);

}

Line 3394 again:

Line 3428 again:

#endif

sugar = SG(l);

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

if ( nd_hpdata ) {

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

break;

else {

final_hpvalue = hpvalue(&final_hpdata,sugar);

if ( final_hpvalue == hpvalue(&current_hpdata,sugar) ) {

if ( DP_Print ) fprintf(asir_out,"sugar=%d done.\n",sugar);

d = nd_remove_same_sugar(d,sugar);

continue;

}

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

if ( !stat ) {

Line 3480 again:

Line 3502 again:

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

g = update_base(g,nh);

if ( nd_hpdata ) {

update_hpdata(&current_hpdata,nh,1);

int dg,sugar0;

if ( final_hpvalue == hpvalue(&current_hpdata,sugar) ) {

if ( DP_Print ) fprintf(asir_out,"sugar=%d done.\n",sugar);

update_hpdata(&current_hpdata,nh);

d = nd_remove_same_sugar(d,sugar);

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

Line 3533 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 3531 NODE ndv_reduceall(int m,NODE f)

Line 3562 NODE ndv_reduceall(int m,NODE f)

int i,j,n,stat;

ND nf,g,head;

NODE t,a0,a;

union oNDC dn;

Q q,num,den;

NODE node;

LIST l;

Z iq,jq;

int *perm;

union oNDC hc;

P cont,cont1;

P cont;

if ( nd_nora ) return f;

n = length(f);

Line 3546 NODE ndv_reduceall(int m,NODE f)

Line 3575 NODE ndv_reduceall(int m,NODE f)

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

if ( nd_gentrace ) {

for ( t = nd_tracelist, i = 0; i < n; i++, t = NEXT(t) )

perm[i] = ZTOS((Q)ARG1(BDY((LIST)BDY(t))));

perm[i] = (int)ZTOS((Q)ARG1(BDY((LIST)BDY(t))));

}

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

if ( nd_gentrace ) {

Line 3565 NODE ndv_reduceall(int m,NODE f)

Line 3594 NODE ndv_reduceall(int m,NODE f)

hc = HCU(nf); nd_removecont(m,nf);

if ( nd_gentrace ) {

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

jq = ARG1(BDY((LIST)BDY(t))); j = ZTOS(jq);

jq = ARG1(BDY((LIST)BDY(t))); j = (int)ZTOS(jq);

STOZ(perm[j],jq); ARG1(BDY((LIST)BDY(t))) = jq;

}

/* exact division */

Line 3688 ND_pairs nd_newpairs( NODE g, int t )

Line 3717 ND_pairs nd_newpairs( NODE g, int t )

dl = DL(nd_psh[t]);

ts = SG(nd_psh[t]) - TD(dl);

if ( nd_module && nd_intersect && (MPOS(dl) > nd_intersect) ) return 0;

if ( nd_module && nd_intersect && (MPOS(dl) > (UINT)nd_intersect) ) return 0;

for ( r0 = 0, h = g; h; h = NEXT(h) ) {

if ( nd_module && (MPOS(DL(nd_psh[(long)BDY(h)])) != MPOS(dl)) )

continue;

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

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

{

int e1,e2,i,j,l;

int *t1,*t2;

int len,head;

int len;

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

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

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

default:

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

}

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

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

}

return 0;

}

Line 3842 struct comp_sig_spec *create_comp_sig_spec(VL current_

Line 3870 struct comp_sig_spec *create_comp_sig_spec(VL current_

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 = BDY((LIST)BDY(t)); l[i].order = (int)ZTOS((Q)BDY(tn));

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

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

s += l[i].length;

}

if ( s != nvar )

Line 3858 struct comp_sig_spec *create_comp_sig_spec(VL current_

Line 3886 struct comp_sig_spec *create_comp_sig_spec(VL current_

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

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

spec->row = m->row;

spec->matrix = w;

spec->cmpdl = sig_cmpdl_mat;

Line 3868 struct comp_sig_spec *create_comp_sig_spec(VL current_

Line 3896 struct comp_sig_spec *create_comp_sig_spec(VL current_

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

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

spec->weight = a;

}

return spec;

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

Line 3916 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 3914 int comp_sig(SIG s1,SIG s2)

Line 3944 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 3923 int comp_sig(SIG s1,SIG s2)

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

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

if ( !nd_sba_modord )

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

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

else

ret = comp_sig_monomial(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 3965 int _create_spair_s(int i1,int i2,ND_pairs sp,SIG sig1

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

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

Line 3994 SIG dup_sig(SIG sig)

Line 4024 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 4012 void dup_ND_pairs(ND_pairs to,ND_pairs from)

Line 4043 void dup_ND_pairs(ND_pairs to,ND_pairs from)

ND_pairs merge_pairs_s(ND_pairs p1,ND_pairs p2)

{

struct oND_pairs root;

ND_pairs q1,q2,r0,r;

ND_pairs q1,q2,r;

int ret;

r = &root;

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

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

ND_pairs nd_newpairs_s(int t, NODE *syz)

{

NODE h,s;

NODE s;

UINT *dl;

int ret,i;

int ts,ret,i;

ND_pairs r0,_sp,sp;

ND_pairs r,r0,_sp,sp;

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

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

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

ND_pairs *nd_newpairs_array_s(int t, NODE *syz)

{

NODE h,s;

NODE s;

UINT *dl;

int ret,i;

int ts,ret,i;

ND_pairs _sp,sp;

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

Line 4177 ND_pairs nd_ipairtospair(NODE ipair)

Line 4204 ND_pairs nd_ipairtospair(NODE ipair)

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

NEXTND_pairs(r0,r);

tn = BDY((LIST)BDY(t));

r->i1 = ZTOS((Q)ARG0(tn));

r->i1 = (int)ZTOS((Q)ARG0(tn));

r->i2 = ZTOS((Q)ARG1(tn));

r->i2 = (int)ZTOS((Q)ARG1(tn));

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

s1 = SG(nd_psh[r->i1])-TD(DL(nd_psh[r->i1]));

s2 = SG(nd_psh[r->i2])-TD(DL(nd_psh[r->i2]));

Line 4197 ND_pairs crit_B( ND_pairs d, int s )

Line 4224 ND_pairs crit_B( ND_pairs d, int s )

{

ND_pairs cur,head,prev,remove;

UINT *t,*tl,*lcm;

int td,tdl;

if ( !d ) return 0;

t = DL(nd_psh[s]);

Line 4363 NODE update_base(NODE nd,int ndp)

Line 4389 NODE update_base(NODE nd,int ndp)

ND_pairs nd_minp( ND_pairs d, ND_pairs *prest )

{

ND_pairs m,ml,p,l;

UINT *lcm;

int s;

int s,td,len,tlen,c,c1;

if ( !(p = NEXT(m = d)) ) {

*prest = p;

Line 4464 int nd_tdeg(NDV c)

Line 4489 int nd_tdeg(NDV c)

len = LEN(c);

for ( a = BDY(c), i = 0; i < len; i++, NMV_ADV(a) )

wmax = MAX(TD(DL(a)),wmax);

wmax = MAX((int)TD(DL(a)),wmax);

return wmax;

}

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

{

int len;

RHist r;

NDV b;

NODE tn;

LIST l;

Z iq;

Line 4560 void ndv_lm_modord(NDV p,DL d)

Line 4583 void ndv_lm_modord(NDV p,DL d)

int ndv_setup(int mod,int trace,NODE f,int dont_sort,int dont_removecont,int sba)

{

int i,j,td,len,max;

int i,j;

NODE s,s0,f0,tn;

NODE s,tn;

UINT *d;

RHist r;

NDVI w;

NDV a,am;

union oNDC hc;

NODE node;

P hcp;

Z iq,jq;

LIST l;

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

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

if ( !dont_removecont) ndv_removecont(-2,a);

am = nd_ps[i] = ndv_dup(trace,w[i].p);

ndv_mod(trace,am);

if ( DL_COMPARE(HDL(am),HDL(a)) )

if ( DL_COMPARE(HDL(am),HDL(a)) ) return 0;

return 0;

ndv_removecont(trace,am);

} else {

a = nd_ps_trace[i] = ndv_dup(0,w[i].p);

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

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

register_hcf(a);

am = nd_ps[i] = ndv_dup(mod,a);

ndv_mod(mod,am);

if ( DL_COMPARE(HDL(am),HDL(a)) )

if ( DL_COMPARE(HDL(am),HDL(a)) ) return 0;

return 0;

ndv_removecont(mod,am);

}

} else {

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

Line 4696 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 4697 static VECT prev_weight_vector_obj;

Line 4717 static VECT prev_weight_vector_obj;

void preprocess_algcoef(VL vv,VL av,struct order_spec *ord,LIST f,

struct order_spec **ord1p,LIST *f1p,NODE *alistp)

{

NODE alist,t,s,r0,r,arg;

NODE alist,t,s,arg;

VL tv;

P poly;

DP d;

Line 4706 void preprocess_algcoef(VL vv,VL av,struct order_spec

Line 4726 void preprocess_algcoef(VL vv,VL av,struct order_spec

MP m;

int i,nvar,nalg,n;

NumberField nf;

LIST f1,f2;

LIST f1;

struct order_spec *current_spec;

VECT obj,obj0;

VECT tmp;

Line 4796 NODE postprocess_algcoef(VL av,NODE alist,NODE r)

Line 4815 NODE postprocess_algcoef(VL av,NODE alist,NODE r)

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

{

VL tv,fv,vv,vc,av;

VL tv,fv,vv,av;

NODE fd,fd0,r,r0,t,x,s,xx,alist;

NODE fd,fd0,r0,t,x,s,xx,alist,r;

int e,max,nvar,i;

NDV b;

int ishomo,nalg,mrank,trank,wmax,len;

NMV a;

Alg alpha,dp;

P zp;

P p,zp;

Q dmy;

LIST f1,zpl;

LIST f1,f2,zpl;

struct order_spec *ord1;

Obj obj;

NODE tr,tl1,tl2,tl3,tl4,nzlist;

NumberField nf;

LIST l1,l2,l3,l4,l5;

struct order_spec *ord1;

NODE tr,tl1,tl2,tl3,tl4,nzlist;

LIST l1,l2,l3,l4,l5;

int j;

Z jq,bpe,last_nonzero;

int *perm;

EPOS oepos;

int obpe,oadv,ompos,cbpe;

VECT hvect;

NcriB = NcriMF = Ncri2 = 0;

nd_module = 0;

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

else nd_demand = 0;

if ( DP_Multiple )

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

#if 0

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

switch ( ord->id ) {

case 1:

if ( ord->nv != nvar )

error("nd_{gr,f4} : invalid order specification");

break;

default:

break;

}

nd_nalg = 0;

av = 0;

if ( !m ) {

get_algtree((Obj)f,&av);

for ( nalg = 0, tv = av; tv; tv = NEXT(tv), nalg++ );

nd_ntrans = nvar;

nd_nalg = nalg;

/* #i -> t#i */

if ( nalg ) {

preprocess_algcoef(vv,av,ord,f,&ord1,&f1,&alist);

ord = ord1;

f = f1;

}

nd_nalg = 0;

nvar += nalg;

av = 0;

}

if ( !m ) {

nd_init_ord(ord);

get_algtree((Obj)f,&av);

mrank = 0;

for ( nalg = 0, tv = av; tv; tv = NEXT(tv), nalg++ );

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

nd_ntrans = nvar;

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

nd_nalg = nalg;

/* #i -> t#i */

if ( nalg ) {

preprocess_algcoef(vv,av,ord,f,&ord1,&f1,&alist);

ord = ord1;

f = f1;

}

nvar += nalg;

}

nd_init_ord(ord);

mrank = 0;

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

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

if ( nd_module ) {

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

e = dpm_getdeg((DPM)BDY(t),&trank);

max = MAX(e,max);

mrank = MAX(mrank,trank);

} else {

s = BDY((LIST)BDY(t));

trank = length(s);

mrank = MAX(mrank,trank);

for ( ; s; s = NEXT(s) ) {

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

max = MAX(e,max);

}

} 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,nd_nzlist?0: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 ( nd_module ) {

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

Z cont;

e = dpm_getdeg((DPM)BDY(t),&trank);

DPM zdpm;

max = MAX(e,max);

mrank = MAX(mrank,trank);

if ( !m && !nd_gentrace ) dpm_ptozp((DPM)BDY(t),&cont,&zdpm);

else zdpm = (DPM)BDY(t);

b = (pointer)dpmtondv(m,zdpm);

} else {

if ( !m && !nd_gentrace ) pltozpl((LIST)BDY(t),&dmy,&zpl);

s = BDY((LIST)BDY(t));

else zpl = (LIST)BDY(t);

trank = length(s);

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

mrank = MAX(mrank,trank);

for ( ; s; s = NEXT(s) ) {

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

max = MAX(e,max);

}

} else {

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

DP zdp;

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

max = MAX(e,max);

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

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

else zp = (P)BDY(t);

max = MAX(e,max);

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

}

if ( ishomo )

ishomo = ishomo && ndv_ishomo(b);

if ( m ) ndv_mod(m,b);

if ( b ) { NEXTNODE(fd0,fd); BDY(fd) = (pointer)b; }

}

if ( fd0 ) NEXT(fd) = 0;

nd_setup_parameters(nvar,nd_nzlist?0: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 ( nd_module ) {

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

Z cont;

DPM zdpm;

if ( !m && !nd_gentrace ) dpm_ptozp((DPM)BDY(t),&cont,&zdpm);

else zdpm = (DPM)BDY(t);

b = (pointer)dpmtondv(m,zdpm);

} else {

if ( !m && !nd_gentrace ) pltozpl((LIST)BDY(t),&dmy,&zpl);

else zpl = (LIST)BDY(t);

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

}

} else {

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

DP zdp;

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

if ( m ) ndv_mod(m,b);

if ( b ) { NEXTNODE(fd0,fd); BDY(fd) = (pointer)b; }

}

if ( fd0 ) NEXT(fd) = 0;

if ( !ishomo && homo ) {

for ( t = fd0, wmax = max; t; t = NEXT(t) ) {

b = (NDV)BDY(t); len = LEN(b);

for ( a = BDY(b), i = 0; i < len; i++, NMV_ADV(a) )

wmax = MAX(TD(DL(a)),wmax);

wmax = MAX((int)TD(DL(a)),wmax);

}

homogenize_order(ord,nvar,&ord1);

nd_init_ord(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_gbblock||nd_splist||nd_check_splist)?1:0,0,0);

if ( nd_gentrace ) {

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

}

if ( nd_splist ) {

*rp = compute_splist();

return;

}

if ( nd_check_splist ) {

if ( f4 ) {

if ( check_splist_f4(m,nd_check_splist) ) *rp = (LIST)ONE;

else *rp = 0;

} else {

if ( check_splist(m,nd_check_splist) ) *rp = (LIST)ONE;

else *rp = 0;

}

return;

}

x = f4?nd_f4(m,0,&perm):nd_gb(m,ishomo || homo,0,0,&perm);

if ( !x ) {

*rp = 0; return;

}

if ( nd_gentrace ) {

MKVECT(hvect,nd_psn);

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

ndltodp(nd_psh[i]->dl,(DP *)&BDY(hvect)[i]);

}

if ( !ishomo && homo ) {

/* dehomogenization */

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

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

nd_init_ord(ord);

nd_setup_parameters(nvar,0);

}

nd_demand = 0;

if ( nd_module && nd_intersect ) {

for ( j = nd_psn-1, x = 0; j >= 0; j-- )

if ( MPOS(DL(nd_psh[j])) > nd_intersect ) {

if ( MPOS(DL(nd_psh[j])) > (UINT)nd_intersect ) {

MKNODE(xx,(pointer)((unsigned long)j),x); x = xx;

}

conv_ilist(nd_demand,0,x,0);

goto FINAL;

}

if ( nd_gentrace && f4 ) { nzlist = nd_alltracelist; }

x = ndv_reducebase(x,perm);

if ( nd_gentrace && !f4 ) { tl1 = nd_alltracelist; nd_alltracelist = 0; }

x = ndv_reduceall(m,x);

cbpe = nd_bpe;

if ( nd_gentrace && !f4 ) {

tl2 = nd_alltracelist; nd_alltracelist = 0;

ndv_check_membership(m,fd0,obpe,oadv,oepos,x);

tl3 = nd_alltracelist; nd_alltracelist = 0;

if ( nd_gensyz ) {

nd_gb(m,0,1,1,0);

tl4 = nd_alltracelist; nd_alltracelist = 0;

} else tl4 = 0;

}

nd_bpe = cbpe;

nd_setup_parameters(nd_nvar,0);

FINAL:

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

NEXTNODE(r0,r);

if ( nd_module ) {

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

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

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

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

}

if ( r0 ) NEXT(r) = 0;

if ( !m && nd_nalg )

r0 = postprocess_algcoef(av,alist,r0);

MKLIST(*rp,r0);

if ( nd_gentrace ) {

if ( f4 ) {

STOZ(16,bpe);

STOZ(nd_last_nonzero,last_nonzero);

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

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

VL tv,fv,vv;

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

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

int e,max,nvar,i;

NDV b;

int ishomo,nalg,wmax,len;

int ishomo,wmax,len;

NMV a;

P p,zp;

P zp;

Q dmy;

struct order_spec *ord1;

int j;

int *perm;

EPOS oepos;

int obpe,oadv,ompos,cbpe;

int obpe,oadv,ompos;

struct oEGT eg0,eg1,egconv,egintred;

LIST l1,redind;

Z z;

nd_module = 0;

nd_demand = 0;

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

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

case 1:

if ( ord->nv != nvar )

error("nd_sba : invalid order specification");

break;

default:

break;

}

nd_nalg = 0;

nd_init_ord(ord);

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

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

for ( t = fd0, wmax = max; t; t = NEXT(t) ) {

b = (NDV)BDY(t); len = LEN(b);

for ( a = BDY(b), i = 0; i < len; i++, NMV_ADV(a) )

wmax = MAX(TD(DL(a)),wmax);

wmax = MAX((int)TD(DL(a)),wmax);

}

homogenize_order(ord,nvar,&ord1);

nd_init_ord(ord1);

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

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

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

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

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

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

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

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

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

{

VL tv,fv,vv,vc,av;

VL tv,fv,vv,av;

NODE fd,fd0,r,r0,t,x,s,xx,alist;

NODE fd,fd0,r,r0,t,x,alist;

int e,max,nvar,i;

int e,max,nvar,i,nalg;

NDV b;

int ishomo,nalg;

int ishomo;

Alg alpha,dp;

P zp;

P p,zp;

Q dmy;

LIST f1,f2;

LIST f1;

Obj obj;

NumberField nf;

struct order_spec *ord1;

int *perm;

Line 5315 NDV recompute_trace(NODE ti,NDV *p,int mod)

Line 5342 NDV recompute_trace(NODE ti,NDV *p,int mod)

void nd_gr_recompute_trace(LIST f,LIST v,int m,struct order_spec *ord,LIST tlist,LIST *rp)

{

VL tv,fv,vv,vc,av;

VL tv,fv,vv;

NODE fd,fd0,r,r0,t,x,s,xx,alist;

NODE r,r0,t;

int e,max,nvar,i;

int nvar,i;

NDV b;

int ishomo,nalg;

P zp;

Alg alpha,dp;

Q dmy;

P p,zp;

Q dmy;

LIST f1,f2;

Obj obj;

NumberField nf;

struct order_spec *ord1;

NODE permtrace,intred,ind,perm,trace,ti;

int len,n,j;

NDV *db,*pb;

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:

if ( ord->nv != nvar )

error("nd_check : invalid order specification");

break;

default:

break;

}

nd_init_ord(ord);

nd_bpe = ZTOS((Q)ARG7(BDY(tlist)));

nd_bpe = (int)ZTOS((Q)ARG7(BDY(tlist)));

nd_setup_parameters(nvar,0);

len = length(BDY(f));

db = (NDV *)MALLOC(len*sizeof(NDV *));

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

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

b = ptondv(CO,vv,zp);

ndv_mod(m,b);

ndv_mul_c(m,b,invm(HCM(b),m));

db[i] = b;

}

permtrace = BDY((LIST)ARG2(BDY(tlist)));

intred = BDY((LIST)ARG3(BDY(tlist)));

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

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

trace = NEXT(permtrace);

for ( i = length(perm)-1, t = trace; t; t = NEXT(t) ) {

j = ZTOS((Q)ARG0(BDY((LIST)BDY(t))));

j = (int)ZTOS((Q)ARG0(BDY((LIST)BDY(t))));

if ( j > i ) i = j;

}

n = i+1;

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

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

pb[ZTOS((Q)ARG0(ti))] = recompute_trace(BDY((LIST)ARG1(ti)),pb,m);

if ( !pb[ZTOS((Q)ARG0(ti))] ) { *rp = 0; return; }

if ( DP_Print ) {

fprintf(asir_out,"*"); fflush(asir_out);

}

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

NEXTNODE(r0,r);

b = pb[ZTOS((Q)BDY(t))];

ndv_mul_c(m,b,invm(HCM(b),m));

#if 0

BDY(r) = ndvtop(m,CO,vv,pb[ZTOS((Q)BDY(t))]);

#else

BDY(r) = ndvtodp(m,pb[ZTOS((Q)BDY(t))]);

#endif

}

if ( r0 ) NEXT(r) = 0;

MKLIST(*rp,r0);

if ( DP_Print ) fprintf(asir_out,"\n");

}

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

{

VL tv,fv,vv,vc,av;

VL tv,fv,vv,av;

NODE fd,fd0,in0,in,r,r0,t,s,cand,alist;

NODE fd,fd0,in0,in,r,t,s,cand,alist;

int m,nocheck,nvar,mindex,e,max;

NDV c;

NMV a;

P p,zp;

P zp;

Q dmy;

EPOS oepos;

int obpe,oadv,wmax,i,len,cbpe,ishomo,nalg,mrank,trank,ompos;

Alg alpha,dp;

LIST f1,zpl;

P poly;

LIST f1,f2,zpl;

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

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

for ( t = in0, wmax = max; t; t = NEXT(t) ) {

c = (NDV)BDY(t); len = LEN(c);

for ( a = BDY(c), i = 0; i < len; i++, NMV_ADV(a) )

wmax = MAX(TD(DL(a)),wmax);

wmax = MAX((int)TD(DL(a)),wmax);

}

homogenize_order(ord,nvar,&ord1);

nd_init_ord(ord1);

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

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

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

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

Line 5646 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 5875 void ndv_removecont(int mod,NDV p)

Line 5897 void ndv_removecont(int mod,NDV p)

int i,len,all_p;

Z *c;

P *w;

Z dvr,t;

Z dvr;

P g,cont,tp;

NMV m;

Line 5920 void ndv_homogenize(NDV p,int obpe,int oadv,EPOS oepos

Line 5942 void ndv_homogenize(NDV p,int obpe,int oadv,EPOS oepos

len = p->len;

for ( m = BDY(p), i = 0, max = 0; i < len; NMV_OADV(m), i++ )

max = MAX(max,TD(DL(m)));

max = MAX(max,(int)TD(DL(m)));

mr0 = nmv_adv>oadv?(NMV)REALLOC(BDY(p),len*nmv_adv):BDY(p);

m = (NMV)((char *)mr0+(len-1)*oadv);

mr = (NMV)((char *)mr0+(len-1)*nmv_adv);

Line 5938 void ndv_dehomogenize(NDV p,struct order_spec *ord)

Line 5960 void ndv_dehomogenize(NDV p,struct order_spec *ord)

{

int i,j,adj,len,newnvar,newwpd,newadv,newexporigin,newmpos;

int pos;

Q *w;

Q dvr,t;

NMV m,r;

len = p->len;

Line 5999 void nd_heu_nezgcdnpz(VL vl,P *pl,int m,int full,P *pr

Line 6019 void nd_heu_nezgcdnpz(VL vl,P *pl,int m,int full,P *pr

void removecont_array(P *p,int n,int full)

{

int all_p,all_q,i;

int all_q,i;

Z *c;

P *w;

P t,s;

Line 6028 void removecont_array_q(Z *c,int n)

Line 6048 void removecont_array_q(Z *c,int n)

{

struct oVECT v;

Z d0,d1,a,u,u1,gcd;

int i,j;

int i;

Z *q,*r;

q = (Z *)MALLOC(n*sizeof(Z));

Line 6172 void ndv_free(NDV p)

Line 6192 void ndv_free(NDV p)

void nd_append_red(UINT *d,int i)

{

RHist m,m0;

RHist m;

int h;

NEWRHist(m);

Line 6216 UINT *nd_compute_bound(ND p)

Line 6236 UINT *nd_compute_bound(ND p)

{

UINT *d1,*d2,*t;

UINT u;

int i,j,k,l,len,ind;

int i,j,k,l,ind;

NM m;

if ( !p )

return 0;

d1 = (UINT *)MALLOC(nd_wpd*sizeof(UINT));

d2 = (UINT *)MALLOC(nd_wpd*sizeof(UINT));

len = LEN(p);

m = BDY(p); ndl_copy(DL(m),d1); m = NEXT(m);

for ( m = NEXT(m); m; m = NEXT(m) ) {

ndl_lcm(DL(m),d1,d2);

Line 6267 int nd_get_exporigin(struct order_spec *ord)

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

int i,j,elen,wpd;

struct order_pair *op;

extern int CNVars;

nd_nvar = nvar;

Line 6289 void nd_setup_parameters(int nvar,int max) {

Line 6307 void nd_setup_parameters(int nvar,int max) {

}

if ( !do_weyl && weight_check && (current_dl_weight_vector || nd_matrix) ) {

UINT t;

int st;

int *v;

/* t = max(weights) */

t = 0;

if ( current_dl_weight_vector )

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

if ( (st=current_dl_weight_vector[i]) < 0 ) st = -st;

if ( t < st ) t = st;

if ( t < (UINT)st ) t = st;

}

if ( nd_matrix )

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

for ( j = 0, v = nd_matrix[i]; j < nd_nvar; j++ ) {

if ( (st=v[j]) < 0 ) st = -st;

if ( t < st ) t = st;

if ( t < (UINT)st ) t = st;

}

/* i = bitsize of t */

for ( i = 0; t; t >>=1, i++ );

Line 6346 ND_pairs nd_reconstruct(int trace,ND_pairs d)

Line 6364 ND_pairs nd_reconstruct(int trace,ND_pairs d)

int i,obpe,oadv,h;

static NM prev_nm_free_list;

static ND_pairs prev_ndp_free_list;

RHist mr0,mr;

RHist mr;

RHist r;

RHist *old_red;

ND_pairs s0,s,t;

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

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

int i,obpe,oadv,h;

static NM prev_nm_free_list;

static ND_pairs prev_ndp_free_list;

RHist mr0,mr;

RHist mr;

RHist r;

RHist *old_red;

ND_pairs s0,s,t;

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

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

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

{

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

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

struct order_pair *op;

n = nd_nvar;

oepw = (sizeof(UINT)*8)/obpe;

// oepw = (sizeof(UINT)*8)/obpe;

omask0 = (1<<obpe)-1;

TD(r) = TD(d);

for ( i = nd_exporigin; i < nd_wpd; i++ ) r[i] = 0;

Line 6543 void ndl_reconstruct(UINT *d,UINT *r,int obpe,EPOS oep

Line 6561 void ndl_reconstruct(UINT *d,UINT *r,int obpe,EPOS oep

ND nd_copy(ND p)

{

NM m,mr,mr0;

int c,n;

ND r;

if ( !p )

Line 6570 int nd_sp(int mod,int trace,ND_pairs p,ND *rp)

Line 6587 int nd_sp(int mod,int trace,ND_pairs p,ND *rp)

P gp,tp;

Z g,t;

Z iq;

int td;

LIST hist;

NODE node;

DP d;

Line 6823 ND ndv_mul_nm_symbolic(NM m0,NDV p)

Line 6839 ND ndv_mul_nm_symbolic(NM m0,NDV p)

{

NM mr,mr0;

NMV m;

UINT *d,*dt,*dm;

UINT *d;

int c,n,td,i,c1,c2,len;

int i,len;

Q q;

ND r;

if ( !p ) return 0;

else {

n = NV(p); m = BDY(p);

m = BDY(p);

d = DL(m0);

len = LEN(p);

mr0 = 0;

td = TD(d);

c = CM(m0);

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

NEXTNM(mr0,mr);

CM(mr) = 1;

Line 6852 ND ndv_mul_nm(int mod,NM m0,NDV p)

Line 6865 ND ndv_mul_nm(int mod,NM m0,NDV p)

{

NM mr,mr0;

NMV m;

UINT *d,*dt,*dm;

UINT *d;

int c,n,td,i,c1,c2,len;

int c,i,c1,c2,len;

P q;

ND r;

Line 6865 ND ndv_mul_nm(int mod,NM m0,NDV p)

Line 6878 ND ndv_mul_nm(int mod,NM m0,NDV p)

} else

return weyl_ndv_mul_nm(mod,m0,p);

} else {

n = NV(p); m = BDY(p);

m = BDY(p);

d = DL(m0);

len = LEN(p);

mr0 = 0;

td = TD(d);

if ( mod == -1 ) {

c = CM(m0);

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

Line 6913 ND nd_quo(int mod,PGeoBucket bucket,NDV d)

Line 6925 ND nd_quo(int mod,PGeoBucket bucket,NDV d)

{

NM mq0,mq;

NMV tm;

Q q;

int i,nv,c,c1,c2,hindex;

int i,nv,sg,c,c1,c2,hindex;

ND p,t,r;

if ( bucket->m < 0 ) return 0;

Line 7061 ND nd_dup(ND p)

Line 7072 ND nd_dup(ND p)

void ndv_mod(int mod,NDV p)

{

NMV t,d;

int r,s,u;

int r;

int i,len,dlen;

P cp;

Z c;

Line 7173 NDV pltondv(VL vl,VL dvl,LIST p)

Line 7184 NDV pltondv(VL vl,VL dvl,LIST p)

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

{

int n,i,j,k,e;

int j,k,e,i;

VL tvl;

V v;

DCP dc;

DCP *w;

ND r,s,t,u;

ND r,t,s;

P x;

int c;

UINT *d;

NM m,m0;

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

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

} else {

NEWNM(m0); d = DL(m0);

for ( j = k-1, s = 0; j >= 0; j-- ) {

ndl_zero(d); e = ZTOS(DEG(w[j])); PUT_EXP(d,i,e);

ndl_zero(d); e = (int)ZTOS(DEG(w[j])); PUT_EXP(d,i,e);

TD(d) = MUL_WEIGHT(e,i);

if ( nd_blockmask) ndl_weight_mask(d);

if ( nd_module ) MPOS(d) = 0;

Line 7272 LIST ndvtopl(int mod,VL vl,VL dvl,NDV p,int rank)

Line 7282 LIST ndvtopl(int mod,VL vl,VL dvl,NDV p,int rank)

Z q;

P c;

UINT *d;

P s,r,u,t,w;

P r,u,t,w;

GFS gfs;

P *a;

LIST l;

Line 7408 NDV dptondv(int mod,DP p)

Line 7418 NDV dptondv(int mod,DP p)

NDV d;

NMV m,m0;

MP t;

MP *a;

int i,len,n;

if ( !p ) return 0;

Line 7545 DPM ndvtodpm(int mod,NDV p)

Line 7554 DPM ndvtodpm(int mod,NDV p)

DP ndtodp(int mod,ND p)

{

MP m,m0;

DP d;

NM t;

int i,len;

if ( !p ) return 0;

m0 = 0;

len = p->len;

for ( t = BDY(p); t; t = NEXT(t) ) {

NEXTMP(m0,m);

m->dl = ndltodl(nd_nvar,DL(t));

m->c = (Obj)ndctop(mod,t->c);

}

NEXT(m) = 0;

MKDP(nd_nvar,m0,d);

SG(d) = SG(p);

return d;

}

void ndv_print(NDV p)

Line 7861 void nd_nf_p(Obj f,LIST g,LIST v,int m,struct order_sp

Line 7868 void nd_nf_p(Obj f,LIST g,LIST v,int m,struct order_sp

NDV ndvf;

VL vv,tv;

int stat,nvar,max,mrank;

union oNDC dn;

Q cont;

P pp;

LIST ppl;

Line 8030 IndArray nm_ind_pair_to_vect_compress(int trace,UINT *

Line 8036 IndArray nm_ind_pair_to_vect_compress(int trace,UINT *

{

NM m;

NMV mr;

UINT *d,*t,*s,*u;

UINT *d,*t,*u;

NDV p;

unsigned char *ivc;

unsigned short *ivs;

UINT *v,*ivi,*s0v;

UINT *v,*ivi;

int i,j,len,prev,diff,cdiff,h,st,ed,md,c;

int i,j,len,prev,diff,cdiff,st,ed,md,c;

IndArray r;

m = pair->mul;

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

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

unsigned int *ivi;

NDV redv;

NMV mr;

NODE rp;

int maxrs;

double hmag;

int l;

static mpz_t *svect;

static int svect_len=0;

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

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

unsigned int *ivi;

NDV redv;

NMV mr;

NODE rp;

int maxrs;

maxrs = 0;

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

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

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

{

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

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

UINT c;

IndArray ivect;

unsigned char *ivc;

unsigned short *ivs;

unsigned int *ivi;

NDV redv;

NMV mr;

NODE rp;

int maxrs;

maxrs = 0;

Line 8402 int ndv_reduce_vect_sf(int m,UINT *svect,int col,IndAr

Line 8404 int ndv_reduce_vect_sf(int m,UINT *svect,int col,IndAr

ND nd_add_lf(ND p1,ND p2)

{

int n,c,can;

int c,can;

ND r;

NM m1,m2,mr0,mr,s;

Z t;

Line 8411 ND nd_add_lf(ND p1,ND p2)

Line 8412 ND nd_add_lf(ND p1,ND p2)

else if ( !p2 ) return p1;

else {

can = 0;

for ( n = NV(p1), m1 = BDY(p1), m2 = BDY(p2), mr0 = 0; m1 && m2; ) {

for ( m1 = BDY(p1), m2 = BDY(p2), mr0 = 0; m1 && m2; ) {

c = DL_COMPARE(DL(m1),DL(m2));

switch ( c ) {

case 0:

Line 8450 ND nd_add_lf(ND p1,ND p2)

Line 8451 ND nd_add_lf(ND p1,ND p2)

int ndv_reduce_vect_lf(mpz_t *svect,int trace,int col,IndArray *imat,NM_ind_pair *rp0,int nred)

{

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

mpz_t c,mc,c1;

IndArray ivect;

unsigned char *ivc;

unsigned short *ivs;

unsigned int *ivi;

NDV redv;

NMV mr;

NODE rp;

int maxrs;

maxrs = 0;

Line 8508 int ndv_reduce_vect_lf(mpz_t *svect,int trace,int col,

Line 8507 int ndv_reduce_vect_lf(mpz_t *svect,int trace,int col,

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

{

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

mpz_t a,a1,inv;

mpz_t a,inv;

mpz_t *t,*pivot,*pk;

mpz_t **mat;

struct oEGT eg0,eg1,eg_forward,eg_mod,eg_back;

int size,size1;

mpz_init(inv);

mpz_init(a);

mat = (mpz_t **)mat0;

size = 0;

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

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

mpz_mod(mat[i][j],mat[i][j],BDY(current_mod_lf));

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

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

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

{

int j,k,len;

int j,len;

UINT *p;

NDV r;

NMV mr0,mr;

Line 8676 NDV vect_to_ndv_q(Z *vect,int spcol,int col,int *rhead

Line 8672 NDV vect_to_ndv_q(Z *vect,int spcol,int col,int *rhead

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

if ( !INT(c) )

error("vect_to_ndv_q : components must be integers");

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

}

Line 8747 NDV plain_vect_to_ndv_q(Z *vect,int col,UINT *s0vect)

Line 8743 NDV plain_vect_to_ndv_q(Z *vect,int col,UINT *s0vect)

int nd_sp_f4(int m,int trace,ND_pairs l,PGeoBucket bucket)

{

ND_pairs t;

NODE sp0,sp;

int stat;

ND spol;

Line 8819 void print_ndp(ND_pairs l)

Line 8814 void print_ndp(ND_pairs l)

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

{

int i,nh,stat,index,f4red;

int i,nh,stat,f4red;

NODE r,g,tn0,tn,node;

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

ND_pairs d,l,t,ll,lh;

LIST l0,l1;

ND spol,red;

NDV nf;

NDV nf,redv;

NODE rp0,nflist,nzlist,nzlist_t;

NM s0,s;

int col;

NODE rp0,srp0,nflist,nzlist,nzlist_t;

UINT *s0vect;

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

int sugar;

UINT c;

PGeoBucket bucket;

UINT **spmat;

struct oEGT eg0,eg1,eg_f4;

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

Z i1,i2,sugarq;

int *colstat;

IndArray *imat;

int *rhead;

int spcol,sprow;

int sugar,sugarh;

PGeoBucket bucket;

struct oEGT eg0,eg1,eg_f4;

Z i1,i2,sugarq;

init_eg(&f4_symb); init_eg(&f4_conv); init_eg(&f4_conv); init_eg(&f4_elim1); init_eg(&f4_elim2);

#if 0

ndv_alloc = 0;

#endif

Nf4_red=0;

g = 0; d = 0;

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

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

g = update_base(g,i);

}

nzlist = 0;

nzlist_t = nd_nzlist;

f4red = 1;

nd_last_nonzero = 0;

while ( d ) {

get_eg(&eg0);

l = nd_minsugarp(d,&d);

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

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

if ( nzlist_t ) {

node = BDY((LIST)BDY(nzlist_t));

sugarh = ZTOS((Q)ARG0(node));

// sugarh = (int)ZTOS((Q)ARG0(node));

tn = BDY((LIST)ARG1(node));

if ( !tn ) {

nzlist_t = NEXT(nzlist_t);

continue;

}

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

lh = nd_ipairtospair(tn);

}

bucket = create_pbucket();

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

if ( !stat ) {

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

NEXT(t) = d; d = l;

d = nd_reconstruct(0,d);

continue;

}

if ( bucket->m < 0 ) continue;

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

if ( !col ) {

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

NEXT(t) = d; d = l;

d = nd_reconstruct(0,d);

continue;

}

get_eg(&eg1); init_eg(&eg_f4); add_eg(&eg_f4,&eg0,&eg1); add_eg(&f4_symb,&eg0,&eg1);

if ( DP_Print )

fprintf(asir_out,"sugar=%d,symb=%.3fsec,",

fprintf(asir_out,"sugar=%d,symb=%.3fsec,",sugar,eg_f4.exectime);

sugar,eg_f4.exectime);

nflist = nd_f4_red(m,nd_nzlist?lh:l,0,s0vect,col,rp0,nd_gentrace?&ll:0);

if ( checkonly && nflist ) return 0;

/* adding new bases */

if ( nflist ) nd_last_nonzero = f4red;

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

nf = (NDV)BDY(r);

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

ndv_removecont(m,nf);

if ( !m && nd_nalg ) {

ND nf1;

nf1 = ndvtond(m,nf);

nd_monic(0,&nf1);

nd_removecont(m,nf1);

nf = ndtondv(m,nf1);

}

nh = ndv_newps(m,nf,0);

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

g = update_base(g,nh);

}

if ( DP_Print ) {

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

}

if ( nd_gentrace ) {

for ( t = ll, tn0 = 0; t; t = NEXT(t) ) {

NEXTNODE(tn0,tn);

STOZ(t->i1,i1); STOZ(t->i2,i2);

node = mknode(2,i1,i2); MKLIST(l0,node);

BDY(tn) = l0;

}

if ( tn0 ) NEXT(tn) = 0; MKLIST(l0,tn0);

STOZ(sugar,sugarq); node = mknode(2,sugarq,l0); MKLIST(l1,node);

MKNODE(node,l1,nzlist); nzlist = node;

}

if ( nd_nzlist ) nzlist_t = NEXT(nzlist_t);

f4red++;

if ( nd_f4red && f4red > nd_f4red ) break;

if ( nd_rank0 && !nflist ) break;

}

if ( nd_gentrace ) {

if ( nd_nzlist ) nzlist_t = NEXT(nzlist_t);

MKLIST(l0,reverse_node(nzlist));

f4red++;

MKNODE(nd_alltracelist,l0,0);

if ( nd_f4red && f4red > nd_f4red ) break;

}

if ( nd_rank0 && !nflist ) break;

}

if ( nd_gentrace ) {

MKLIST(l0,reverse_node(nzlist));

MKNODE(nd_alltracelist,l0,0);

}

#if 0

fprintf(asir_out,"ndv_alloc=%d\n",ndv_alloc);

#endif

if ( DP_Print ) {

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;

}

NODE nd_f4_trace(int m,int **indp)

{

int i,nh,stat,index;

int i,nh,stat;

NODE r,g;

ND_pairs d,l,l0,t;

ND spol,red;

NDV nfqv,nfv;

NDV nf,redv,nfqv,nfv;

NODE rp0,nflist;

NM s0,s;

int col;

NODE rp0,srp0,nflist;

UINT *s0vect;

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

UINT c;

UINT **spmat;

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

int *colstat;

IndArray *imat;

int *rhead;

int spcol,sprow;

int sugar;

PGeoBucket bucket;

struct oEGT eg0,eg1,eg_f4;

Line 9149 void red_by_vect_2(matrix mat,int *sugar,unsigned long

Line 9127 void red_by_vect_2(matrix mat,int *sugar,unsigned long

NODE nd_f4_red_2(ND_pairs sp0,UINT *s0vect,int col,NODE rp0,ND_pairs *nz)

{

int nsp,nred,i,i0,k,rank,row;

int nsp,i,rank;

NODE r0,rp;

ND_pairs sp;

ND spol;

NM_ind_pair rt;

int *s0hash;

UINT *s;

int *pivot,*sugar,*head;

int *sugar;

matrix mat;

NM m;

NODE r;

struct oEGT eg0,eg1,eg2,eg_elim1,eg_elim2;

int rhead,rsugar,size;

unsigned long *v;

get_eg(&eg0);

for ( sp = sp0, nsp = 0; sp; sp = NEXT(sp), nsp++ );

nred = length(rp0);

// nred = length(rp0);

mat = alloc_matrix(nsp,col);

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

for ( i = 0, s = s0vect; i < col; i++, s += nd_wpd )

s0hash[i] = ndl_hash_value(s);

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

for ( i = 0, sp = sp0; sp; sp = NEXT(sp) ) {

Line 9224 NODE nd_f4_red(int m,ND_pairs sp0,int trace,UINT *s0ve

Line 9201 NODE nd_f4_red(int m,ND_pairs sp0,int trace,UINT *s0ve

NODE r0,rp;

ND_pairs sp;

NM_ind_pair *rvect;

UINT *s;

int *s0hash;

struct oEGT eg0,eg1,eg_conv;

if ( m == 2 && nd_rref2 )

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

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

NM_ind_pair *rvect,int *rhead,IndArray *imat,int nred,ND_pairs *nz)

{

int spcol,sprow,a;

int i,j,k,l,rank;

int i,j,k,rank;

NODE r0,r;

ND_pairs sp;

ND spol;

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

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

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 sprow,a;

int i,j,k,l,rank;

int i,rank;

NODE r0,r;

ND_pairs sp;

ND spol;

UINT **spmat;

UINT *svect,*cvect;

UINT *svect;

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

Line 9442 NODE nd_f4_red_sf_main(int m,ND_pairs sp0,int nsp,UINT

Line 9415 NODE nd_f4_red_sf_main(int m,ND_pairs sp0,int nsp,UINT

NM_ind_pair *rvect,int *rhead,IndArray *imat,int nred,ND_pairs *nz)

{

int spcol,sprow,a;

int i,j,k,l,rank;

int i,j,k,rank;

NODE r0,r;

ND_pairs sp;

ND spol;

Line 9522 NODE nd_f4_red_lf_main(int m,ND_pairs sp0,int nsp,int

Line 9495 NODE nd_f4_red_lf_main(int m,ND_pairs sp0,int nsp,int

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

{

int spcol,sprow,a;

int i,j,k,l,rank;

int i,j,k,rank;

NODE r0,r;

ND_pairs sp;

ND spol;

Line 9604 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U

Line 9577 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U

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

{

int spcol,sprow,a;

int i,j,k,l,rank;

int i,j,k,rank;

NODE r0,r;

ND_pairs sp;

ND spol;

Line 9758 NDV nd_recv_ndv()

Line 9731 NDV nd_recv_ndv()

int nd_gauss_elim_q(Z **mat0,int *sugar,int row,int col,int *colstat)

{

int i,j,t,c,rank,inv;

int i,j,c,rank;

int *ci,*ri;

Z dn;

MAT m,nm;

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

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

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;

int i,j,k,rank,s;

UINT inv;

UINT a;

UINT *t,*pivot,*pk;

UINT *pk;

UINT *ck;

UINT *ct;

ND_pairs pair;

SIG sg;

int *used;

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

Line 9876 int nd_gauss_elim_mod_s(UINT **mat,int *sugar,ND_pairs

Line 9845 int nd_gauss_elim_mod_s(UINT **mat,int *sugar,ND_pairs

s = sugar[i];

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

/* normalize pivot row */

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

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

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

}

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

Line 9971 void ndv_save(NDV p,int index)

Line 9940 void ndv_save(NDV p,int index)

FILE *s;

char name[BUFSIZ];

short id;

int nv,sugar,len,n,i,td,e,j;

int nv,sugar,len,i,td,e,j;

NMV m;

unsigned int *dl;

int mpos;

Line 10037 NDV ndv_load(int index)

Line 10006 NDV ndv_load(int index)

FILE *s;

char name[BUFSIZ];

short id;

int nv,sugar,len,n,i,td,e,j;

int nv,sugar,len,i,td,e,j;

NDV d;

NMV m0,m;

unsigned int *dl;

Line 10270 ND ndv_mul_nmv_trunc(int mod,NMV m0,NDV p,UINT *d)

Line 10239 ND ndv_mul_nmv_trunc(int mod,NMV m0,NDV p,UINT *d)

NM mr,mr0;

NM tnm;

NMV m;

UINT *d0,*dt,*dm;

UINT *d0;

int c,n,td,i,c1,c2,len;

int c,i,c1,c2,len;

Z q;

ND r;

if ( !p ) return 0;

else {

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

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

d0 = DL(m0);

td = TD(d);

mr0 = 0;

NEWNM(tnm);

if ( mod ) {

Line 10317 ND ndv_mul_nmv_trunc(int mod,NMV m0,NDV p,UINT *d)

Line 10285 ND ndv_mul_nmv_trunc(int mod,NMV m0,NDV p,UINT *d)

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

{

int i,obpe,oadv,h,k,l;

int obpe,oadv,k,l;

static NM prev_nm_free_list;

EPOS oepos;

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

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

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

{

UINT *d0,*d1,*d,*t,*r;

UINT *d0,*d;

int k,l,i;

d0 = (UINT *)MALLOC(nd_nvar*sizeof(UINT));

Line 10369 UINT *nd_det_compute_bound(NDV **dm,int n,int j)

Line 10337 UINT *nd_det_compute_bound(NDV **dm,int n,int j)

DL nd_separate_d(UINT *d,UINT *trans)

{

int n,td,i,e,j;

int td,i,e,j;

DL a;

ndl_zero(trans);

Line 10402 DL nd_separate_d(UINT *d,UINT *trans)

Line 10370 DL nd_separate_d(UINT *d,UINT *trans)

int nd_monic(int mod,ND *p)

{

UINT *trans,*t;

DL alg;

MP mp0,mp;

NM m,m0,m1,ma0,ma,mb,mr0,mr;

NM m,ma0,ma,mb,mr0,mr;

ND r;

DL dl;

DP nm;

NDV ndv;

DAlg inv,cd;

ND s,c;

Z l,mul;

Z ln;

int n,ntrans,i,e,td,is_lc,len;

int i,e,td,is_lc,len;

NumberField nf;

struct oEGT eg0,eg1;

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

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

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

{

int n,i,j;

int n,i;

int *ind;

NODE g0,g;

Line 10607 void parse_nd_option(VL vl,NODE opt)

Line 10572 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_hpdata = 0; nd_sba_heu = 0;

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

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

Line 10627 void parse_nd_option(VL vl,NODE opt)

Line 10592 void parse_nd_option(VL vl,NODE opt)

nd_gbblock = MALLOC((2*length(u)+1)*sizeof(int));

for ( i = 0; u; u = NEXT(u) ) {

p = BDY((LIST)BDY(u));

s = nd_gbblock[i++] = ZTOS((Q)BDY(p));

s = nd_gbblock[i++] = (int)ZTOS((Q)BDY(p));

nd_gbblock[i++] = s+ZTOS((Q)BDY(NEXT(p)))-1;

nd_gbblock[i++] = (int)(s+ZTOS((Q)BDY(NEXT(p)))-1);

}

nd_gbblock[i] = -1;

} else

Line 10638 void parse_nd_option(VL vl,NODE opt)

Line 10603 void parse_nd_option(VL vl,NODE opt)

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

nd_intersect = value?1:0;

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

nd_intersect = ZTOS((Q)value);

nd_intersect = (int)ZTOS((Q)value);

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

nd_lf = value?1:0;

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

if ( value ) {

u = BDY((LIST)value);

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

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

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

}

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

nd_f4red = ZTOS((Q)value);

nd_f4red = (int)ZTOS((Q)value);

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

nd_rank0 = value?1:0;

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

Line 10663 void parse_nd_option(VL vl,NODE opt)

Line 10628 void parse_nd_option(VL vl,NODE opt)

n = length(u);

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

for ( i = 0; i < n; i++, u = NEXT(u) )

nd_sugarweight[i] = ZTOS((Q)BDY(u));

nd_sugarweight[i] = (int)ZTOS((Q)BDY(u));

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

nd_f4_td = value?1:0;

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

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

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

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

nd_sba_pot = ZTOS((Q)value);

nd_sba_pot = (int)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_heu") ) {

nd_sba_heu = value?1:0;

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

// value=[vlist,ordspec,weight]

u = BDY((LIST)value);

Line 10748 ND nd_mul_nm(int mod,NM m0,ND p)

Line 10715 ND nd_mul_nm(int mod,NM m0,ND p)

ND nd_mul_nm_lf(NM m0,ND p)

{

UINT *d0;

Z c0,c1,c;

Z c0,c1;

NM tm,mr,mr0;

ND r;

Line 10758 ND nd_mul_nm_lf(NM m0,ND p)

Line 10725 ND nd_mul_nm_lf(NM m0,ND p)

mr0 = 0;

for ( tm = BDY(p); tm; tm = NEXT(tm) ) {

NEXTNM(mr0,mr);

c = CZ(tm); mullf(c0,CZ(tm),&c1); CZ(mr) = c1;

mullf(c0,CZ(tm),&c1); CZ(mr) = c1;

ndl_add(d0,DL(tm),DL(mr));

}

NEXT(mr) = 0;

Line 10847 ND *btog_lf(NODE ti,ND **p,int nb)

Line 10814 ND *btog_lf(NODE ti,ND **p,int nb)

ND btog_one(NODE ti,ND *p,int nb,int mod)

{

PGeoBucket r;

int i,ci,j;

int ci,j;

NODE t,s;

ND m,tp;

ND pi,rd;

Line 10861 ND btog_one(NODE ti,ND *p,int nb,int mod)

Line 10828 ND btog_one(NODE ti,ND *p,int nb,int mod)

ptomp(mod,(P)HCZ(m),&c);

if ( (ci = ((MQ)c)->cont) != 0 ) {

HCM(m) = ci;

pi = p[j=ZTOS((Q)ARG1(s))];

pi = p[j=(int)ZTOS((Q)ARG1(s))];

if ( !pi ) {

pi = nd_load_mod(j);

tp = nd_mul_nm(mod,BDY(m),pi);

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

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

ind = BDY((LIST)ARG4(BDY(tlist)));

perm = BDY((LIST)BDY(permtrace)); trace =NEXT(permtrace);

for ( i = length(perm)-1, t = trace; t; t = NEXT(t) ) {

j = ZTOS((Q)BDY(BDY((LIST)BDY(t))));

j = (int)ZTOS((Q)BDY(BDY((LIST)BDY(t))));

if ( j > i ) i = j;

}

n = i+1;

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

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

p = (ND **)MALLOC(n*sizeof(ND *));

for ( t = perm, i = 0; t; t = NEXT(t), i++ ) {

pi = BDY((LIST)BDY(t));

pi0 = ZTOS((Q)ARG0(pi)); pi1 = ZTOS((Q)ARG1(pi));

pi0 = (int)ZTOS((Q)ARG0(pi)); pi1 = (int)ZTOS((Q)ARG1(pi));

p[pi0] = c = (ND *)MALLOC(nb*sizeof(ND));

ptomp(mod,(P)ARG2(pi),&inv);

((MQ)inv)->cont = invm(((MQ)inv)->cont,mod);

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

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

for ( t = trace,i=0; t; t = NEXT(t), i++ ) {

printf("%d ",i); fflush(stdout);

ti = BDY((LIST)BDY(t));

p[j=ZTOS((Q)ARG0(ti))] = btog(BDY((LIST)ARG1(ti)),p,nb,mod);

p[j=(int)ZTOS((Q)ARG0(ti))] = btog(BDY((LIST)ARG1(ti)),p,nb,mod);

}

for ( t = intred, i=0; t; t = NEXT(t), i++ ) {

printf("%d ",i); fflush(stdout);

ti = BDY((LIST)BDY(t));

p[j=ZTOS((Q)ARG0(ti))] = btog(BDY((LIST)ARG1(ti)),p,nb,mod);

p[j=(int)ZTOS((Q)ARG0(ti))] = btog(BDY((LIST)ARG1(ti)),p,nb,mod);

}

m = length(ind);

MKMAT(mat,nb,m);

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

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

ind = BDY((LIST)ARG4(BDY(tlist)));

perm = BDY((LIST)BDY(permtrace)); trace =NEXT(permtrace);

for ( i = length(perm)-1, t = trace; t; t = NEXT(t) ) {

j = ZTOS((Q)BDY(BDY((LIST)BDY(t))));

j = (int)ZTOS((Q)BDY(BDY((LIST)BDY(t))));

if ( j > i ) i = j;

}

n = i+1;

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

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

p = (ND **)MALLOC(n*sizeof(ND *));

for ( t = perm, i = 0; t; t = NEXT(t), i++ ) {

pi = BDY((LIST)BDY(t));

pi0 = ZTOS((Q)ARG0(pi)); pi1 = ZTOS((Q)ARG1(pi));

pi0 = (int)ZTOS((Q)ARG0(pi)); pi1 = (int)ZTOS((Q)ARG1(pi));

p[pi0] = c = (ND *)MALLOC(nb*sizeof(ND));

simp_ff((Obj)ARG2(pi),(Obj *)&lm); lmtolf(lm,&lf); invz(lf,current_mod_lf,&inv);

u = ptond(CO,vv,(P)ONE);

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

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

for ( t = trace,i=0; t; t = NEXT(t), i++ ) {

printf("%d ",i); fflush(stdout);

ti = BDY((LIST)BDY(t));

p[j=ZTOS((Q)ARG0(ti))] = btog_lf(BDY((LIST)ARG1(ti)),p,nb);

p[j=(int)ZTOS((Q)ARG0(ti))] = btog_lf(BDY((LIST)ARG1(ti)),p,nb);

}

for ( t = intred, i=0; t; t = NEXT(t), i++ ) {

printf("%d ",i); fflush(stdout);

ti = BDY((LIST)BDY(t));

p[j=ZTOS((Q)ARG0(ti))] = btog_lf(BDY((LIST)ARG1(ti)),p,nb);

p[j=(int)ZTOS((Q)ARG0(ti))] = btog_lf(BDY((LIST)ARG1(ti)),p,nb);

}

m = length(ind);

MKMAT(mat,nb,m);

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

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

VL fv,tv,vv;

NODE permtrace,perm,trace,intred,ind,t,pi,ti;

ND *p;

ND *c;

ND u;

P inv;

VECT vect;

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

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

ind = BDY((LIST)ARG4(BDY(tlist)));

perm = BDY((LIST)BDY(permtrace)); trace =NEXT(permtrace);

for ( i = length(perm)-1, t = trace; t; t = NEXT(t) ) {

j = ZTOS((Q)BDY(BDY((LIST)BDY(t))));

j = (int)ZTOS((Q)BDY(BDY((LIST)BDY(t))));

if ( j > i ) i = j;

}

n = i+1;

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

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

p = (ND *)MALLOC(n*sizeof(ND *));

for ( t = perm, i = 0; t; t = NEXT(t), i++ ) {

pi = BDY((LIST)BDY(t));

pi0 = ZTOS((Q)ARG0(pi)); pi1 = ZTOS((Q)ARG1(pi));

pi0 = (int)ZTOS((Q)ARG0(pi)); pi1 = (int)ZTOS((Q)ARG1(pi));

if ( pi1 == pos ) {

ptomp(mod,(P)ARG2(pi),&inv);

((MQ)inv)->cont = invm(((MQ)inv)->cont,mod);

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

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

for ( t = trace,i=0; t; t = NEXT(t), i++ ) {

printf("%d ",i); fflush(stdout);

ti = BDY((LIST)BDY(t));

p[j=ZTOS((Q)ARG0(ti))] = btog_one(BDY((LIST)ARG1(ti)),p,nb,mod);

p[j=(int)ZTOS((Q)ARG0(ti))] = btog_one(BDY((LIST)ARG1(ti)),p,nb,mod);

if ( Demand ) {

nd_save_mod(p[j],j); nd_free(p[j]); p[j] = 0;

}

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

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

for ( t = intred, i=0; t; t = NEXT(t), i++ ) {

printf("%d ",i); fflush(stdout);

ti = BDY((LIST)BDY(t));

p[j=ZTOS((Q)ARG0(ti))] = btog_one(BDY((LIST)ARG1(ti)),p,nb,mod);

p[j=(int)ZTOS((Q)ARG0(ti))] = btog_one(BDY((LIST)ARG1(ti)),p,nb,mod);

if ( Demand ) {

nd_save_mod(p[j],j); nd_free(p[j]); p[j] = 0;

}

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

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

for ( j = 0, t = ind; j < m; j++, t = NEXT(t) ) {

u = p[ZTOS((Q)BDY(t))];

if ( !u ) {

u = nd_load_mod(ZTOS((Q)BDY(t)));

u = nd_load_mod((int)ZTOS((Q)BDY(t)));

BDY(vect)[j] = ndtodp(mod,u);

nd_free(u);

} else

Line 11130 void ndv_print_lf(NDV p)

Line 11096 void ndv_print_lf(NDV p)

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

{

VL tv,fv,vv,vc,av;

VL tv,fv,vv;

NODE fd,fd0,in0,in,r,r0,t,s,cand,alist;

NODE fd,fd0,in0,in,r,t,s,cand;

int m,nocheck,nvar,mindex,e,max;

int m,nvar,mindex,e,max;

NDV c;

NMV a;

P p,zp;

Q dmy;

EPOS oepos;

int obpe,oadv,wmax,i,len,cbpe,ishomo,nalg,mrank,trank,ompos;

int obpe,oadv,wmax,i,len,cbpe,ishomo,mrank,trank,ompos;

Alg alpha,dp;

P poly;

LIST f1,f2,zpl;

Obj obj;

NumberField nf;

struct order_spec *ord1;

struct oEGT eg_check,eg0,eg1;

NODE tr,tl1,tl2,tl3,tl4;

LIST l1,l2,l3,l4,l5;

int *perm;

int j,ret;

int ret;

NODE retn;

Q jq,bpe;

nd_module = 0;

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

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

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

nd_ntrans = nvar;

nd_nalg = 0;

nocheck = 0;

// nocheck = 0;

mindex = 0;

/* do not use on-demand load/save */

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

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

for ( t = in0, wmax = max; t; t = NEXT(t) ) {

c = (NDV)BDY(t); len = LEN(c);

for ( a = BDY(c), i = 0; i < len; i++, NMV_ADV(a) )

wmax = MAX(TD(DL(a)),wmax);

wmax = MAX((int)TD(DL(a)),wmax);

}

homogenize_order(ord,nvar,&ord1);

nd_init_ord(ord1);

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

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

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

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

}

if ( MaxDeg > 0 ) nocheck = 1;

// if ( MaxDeg > 0 ) nocheck = 1;

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

if ( ret )

cand = nd_f4_lf_trace_main(m,&perm);

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

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

if ( (ret = ndv_check_membership(-2,in0,obpe,oadv,oepos,cand)) != 0 ) {

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

retn = nd_f4(-2,0,0);

if ( !retn ) {

/* failure */

*rp = 0; return;

}

if ( !retn ) {

/* failure */

*rp = 0; return;

}

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

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

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

NODE nd_f4_lf_trace_main(int m,int **indp)

{

int i,nh,stat,index;

int i,nh,stat;

NODE r,rm,g;

ND_pairs d,l,l0,t;

ND spol,red;

NDV nfqv,nfv;

NDV nf,redv,nfqv,nfv;

NODE rp0,nflist,nflist_lf;

NM s0,s;

UINT *s0vect;

NODE rp0,srp0,nflist,nflist_lf;

int col;

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

UINT c;

UINT **spmat;

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

int *colstat;

IndArray *imat;

int *rhead;

int spcol,sprow;

int sugar;

PGeoBucket bucket;

struct oEGT eg0,eg1,eg_f4;

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

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

NODE r0,rp;

ND_pairs sp;

NM_ind_pair *rvect;

UINT *s;

int *s0hash;

struct oEGT eg0,eg1,eg_conv;

for ( sp = sp0, nsp = 0; sp; sp = NEXT(sp), nsp++ );

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

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

#else

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

#endif

else

else {

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

r0 = 0;

error("nd_f4_red_q_main_s : not implemented yet");

}

return r0;

}

INLINE int ndl_find_reducer_minsig(UINT *dg)

{

RHist r;

int i,singular,ret,d,k,imin;

int i,imin;

SIG t;

static int wpd,nvar;

static SIG quo,quomin;

Line 11881 INLINE int ndl_find_reducer_minsig(UINT *dg)

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

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

Line 11951 int nd_symbolic_preproc_s(PGeoBucket bucket,int trace,

Line 11901 int nd_symbolic_preproc_s(PGeoBucket bucket,int trace,

NODE nd_sba_f4(int m,int **indp)

{

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

int i,nh,stat,f4red,f4step;

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

int col,psugar,ms;

NODE r,g,rp0,nflist;

ND_pairs d,l,t,l1;

ND h,nf;

NDV nfv;

union oNDC hc;

// union oNDC hc;

UINT *s0vect;

UINT c;

PGeoBucket bucket;

NODE *syzlist;

SIG sig;

struct oEGT eg0,eg1,eg_f4;

struct oEGT eg1;

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

struct oEGT eg2,eg_remove,eg_nf,eg_nfzero;

Nf4_red=0;

d = 0;

Line 12020 again:

Line 11969 again:

} else if ( nf ) {

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

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

hc = HCU(nf);

// hc = HCU(nf);

nd_removecont(m,nf);

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

nh = ndv_newps(m,nfv,0);

Line 12044 again:

Line 11993 again:

again2:

psugar = ms;

l = nd_minsugarp_s(d,&d);

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

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

bucket = create_pbucket();

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

if ( !stat ) {

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