OpenXM_contrib2/asir2000/engine/nd.c - diff

Return to nd.c CVS log

Up to [local] / OpenXM_contrib2 / asir2000 / engine

Diff for /OpenXM_contrib2/asir2000/engine/nd.c between version 1.112 and 1.134

version 1.112, 2004/10/06 11:58:52

version 1.134, 2006/06/06 07:14:16

Line 1

/* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.111 2004/09/21 07:19:01 noro Exp $ */

/* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.133 2006/06/05 08:11:10 noro Exp $ */

#include "nd.h"

int diag_period = 6;

int (*ndl_compare_function)(UINT *a1,UINT *a2);

int nd_dcomp;

NM _nm_free_list;

ND _nd_free_list;

ND_pairs _ndp_free_list;

static int nd_ntrans;

static int nd_nalg;

#if 0

static int ndv_alloc;

#endif

Line 41 static int nd_found,nd_create,nd_notfirst;

Line 44 static int nd_found,nd_create,nd_notfirst;

static int nmv_adv;

static int nd_demand;

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

int nd_monic(int m,ND *p);

NDV plain_vect_to_ndv_q(Q *mat,int col,UINT *s0vect);

void nd_free_private_storage()

{

_nm_free_list = 0;

Line 724 int ndl_disjoint(UINT *d1,UINT *d2)

Line 733 int ndl_disjoint(UINT *d1,UINT *d2)

#endif

}

int ndl_check_bound2(int index,UINT *d2)

int ndl_check_bound(UINT *d1,UINT *d2)

{

UINT u2;

UINT *d1;

int i,j,ind,k;

d1 = nd_bound[index];

ind = 0;

#if USE_UNROLL

switch ( nd_bpe ) {

Line 819 int ndl_check_bound2(int index,UINT *d2)

Line 826 int ndl_check_bound2(int index,UINT *d2)

#endif

}

int ndl_check_bound2(int index,UINT *d2)

{

return ndl_check_bound(nd_bound[index],d2);

}

INLINE int ndl_hash_value(UINT *d)

{

int i;

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

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

if ( !p1 ) return p2;

else if ( !p2 ) return p1;

else if ( mod == -1 ) return nd_add_sf(p1,p2);

else if ( !mod ) return nd_add_z(p1,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; ) {

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

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

* done in a function.

int nm_destructive_add_z(NM *m1,NM *m2,NM *mr0,NM *mr)

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

{

NM s;

Z t;

Q t;

int can;

t = addz(CZ(*m1),CZ(*m2));

addq(CQ(*m1),CQ(*m2),&t);

s = *m1; *m1 = NEXT(*m1);

if ( t ) {

can = 1; NEXTNM2(*mr0,*mr,s); CZ(*mr) = (t);

can = 1; NEXTNM2(*mr0,*mr,s); CQ(*mr) = (t);

} else {

can = 2; FREENM(s);

}

Line 978 int nm_destructive_add_z(NM *m1,NM *m2,NM *mr0,NM *mr)

Line 990 int nm_destructive_add_z(NM *m1,NM *m2,NM *mr0,NM *mr)

return can;

}

ND nd_add_z(ND p1,ND p2)

ND nd_add_q(ND p1,ND p2)

{

int n,c,can;

ND r;

NM m1,m2,mr0,mr,s;

Z t;

Q t;

if ( !p1 ) return p2;

else if ( !p2 ) return p1;

Line 994 ND nd_add_z(ND p1,ND p2)

Line 1006 ND nd_add_z(ND p1,ND p2)

switch ( c ) {

case 0:

#if defined(__x86_64__)

can += nm_destructive_add_z(&m1,&m2,&mr0,&mr);

can += nm_destructive_add_q(&m1,&m2,&mr0,&mr);

#else

t = addz(CZ(m1),CZ(m2));

addq(CQ(m1),CQ(m2),&t);

s = m1; m1 = NEXT(m1);

if ( t ) {

can++; NEXTNM2(mr0,mr,s); CZ(mr) = (t);

can++; NEXTNM2(mr0,mr,s); CQ(mr) = (t);

} else {

can += 2; FREENM(s);

}

Line 1077 ND nd_add_sf(ND p1,ND p2)

Line 1089 ND nd_add_sf(ND p1,ND p2)

}

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

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

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

{

ND d;

NM m,mrd,tail;

Line 1086 int nd_nf(int mod,ND g,NDV *ps,int full,Q *dn,ND *rp)

Line 1098 int nd_nf(int mod,ND g,NDV *ps,int full,Q *dn,ND *rp)

int c,c1,c2,dummy;

RHist h;

NDV p,red;

Z cg,cred,gcd;

Q cg,cred,gcd,tq,qq;

Q tq,qq;

double hmag;

if ( dn && !mod )

if ( dn ) {

*dn = ONE;

if ( mod )

dn->m = 1;

else

dn->z = ONE;

}

if ( !g ) {

*rp = 0;

return 1;

}

if ( !mod ) hmag = ((double)z_mag(HCZ(g)))*nd_scale;

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

sugar0 = sugar = SG(g);

n = NV(g);

Line 1120 int nd_nf(int mod,ND g,NDV *ps,int full,Q *dn,ND *rp)

Line 1135 int nd_nf(int mod,ND g,NDV *ps,int full,Q *dn,ND *rp)

c1 = invm(HCM(p),mod); c2 = mod-HCM(g);

DMAR(c1,c2,0,mod,c); CM(mul) = c;

} else {

gcd = gcdz_cofactor(HCZ(g),HCZ(p),&cg,&cred);

igcd_cofactor(HCQ(g),HCQ(p),&gcd,&cg,&cred);

CZ(mul) = chsgnz(cg);

chsgnq(cg,&CQ(mul));

nd_mul_c_z(d,cred);

nd_mul_c_q(d,cred); nd_mul_c_q(g,cred);

nd_mul_c_z(g,cred);

if ( dn ) {

mulq(*dn,ztoq(cred),&tq); *dn = tq;

mulq(dn->z,cred,&tq); dn->z = tq;

}

g = nd_add(mod,g,ndv_mul_nm(mod,mul,p));

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

if ( !mod && hmag && g && ((double)(z_mag(HCZ(g))) > hmag) ) {

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

tq = ztoq(HCZ(g));

tq = HCQ(g);

nd_removecont2(d,g);

if ( dn ) {

divq(tq,ztoq(HCZ(g)),&qq); divq(*dn,qq,&tq); *dn = tq;

divq(tq,HCQ(g),&qq); divq(dn->z,qq,&tq); dn->z = tq;

}

hmag = ((double)z_mag((P)HCZ(g)))*nd_scale;

hmag = ((double)p_mag((P)HCQ(g)))*nd_scale;

}

} else if ( !full ) {

*rp = g;

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

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

int sugar,psugar,n,h_reducible;

PGeoBucket bucket;

int c,c1,c2;

Z cg,cred,gcd,zzz;

Q cg,cred,gcd,zzz;

RHist h;

double hmag,gmag;

int count = 0;

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

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

}

sugar = SG(g);

n = NV(g);

if ( !mod ) hmag = ((double)z_mag(HCZ(g)))*nd_scale;

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

bucket = create_pbucket();

add_pbucket(mod,bucket,g);

d = 0;

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

while ( 1 ) {

hindex = mod?head_pbucket(mod,bucket):head_pbucket_z(bucket);

hindex = mod?head_pbucket(mod,bucket):head_pbucket_q(bucket);

if ( hindex < 0 ) {

if ( DP_Print > 3 ) printf("(%d %d)",count,hcount);

if ( d ) SG(d) = sugar;

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

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

c1 = invm(HCM(p),mod); c2 = mod-HCM(g);

DMAR(c1,c2,0,mod,c); CM(mul) = c;

} else {

gcd = gcdz_cofactor(HCZ(g),HCZ(p),&cg,&cred);

igcd_cofactor(HCQ(g),HCQ(p),&gcd,&cg,&cred);

CZ(mul) = chsgnz(cg);

chsgnq(cg,&CQ(mul));

nd_mul_c_z(d,cred);

nd_mul_c_q(d,cred);

mulz_pbucket(bucket,cred);

mulq_pbucket(bucket,cred);

g = bucket->body[hindex];

gmag = (double)z_mag(HCZ(g));

gmag = (double)p_mag((P)HCQ(g));

}

red = ndv_mul_nm(mod,mul,p);

bucket->body[hindex] = nd_remove_head(g);

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

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

return 1;

}

nd_removecont2(d,g);

hmag = ((double)z_mag(HCZ(g)))*nd_scale;

hmag = ((double)p_mag((P)HCQ(g)))*nd_scale;

add_pbucket(mod,bucket,g);

}

} else if ( !full ) {

Line 1271 int ndv_check_candidate(NODE input,int obpe,int oadv,E

Line 1284 int ndv_check_candidate(NODE input,int obpe,int oadv,E

ND nf,d;

NDV r;

NODE t,s;

union oNDC dn;

ndv_setup(0,0,cand);

ndv_setup(0,0,cand,0);

n = length(cand);

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

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

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

g->m = MAX(g->m,k);

}

void mulz_pbucket(PGeoBucket g,Z c)

void mulq_pbucket(PGeoBucket g,Q c)

{

int k;

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

nd_mul_c_z(g->body[k],c);

nd_mul_c_q(g->body[k],c);

}

NM remove_head_pbucket_symbolic(PGeoBucket g)

Line 1471 int head_pbucket(int mod,PGeoBucket g)

Line 1485 int head_pbucket(int mod,PGeoBucket g)

}

int head_pbucket_z(PGeoBucket g)

int head_pbucket_q(PGeoBucket g)

{

int j,i,c,k,nv;

Z sum,t;

Q sum,t;

ND gi,gj;

k = g->m;

Line 1485 int head_pbucket_z(PGeoBucket g)

Line 1499 int head_pbucket_z(PGeoBucket g)

if ( j < 0 ) {

j = i;

gj = g->body[j];

sum = HCZ(gj);

sum = HCQ(gj);

} else {

nv = NV(gi);

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

if ( c > 0 ) {

if ( sum ) HCZ(gj) = sum;

if ( sum ) HCQ(gj) = sum;

else g->body[j] = nd_remove_head(gj);

j = i;

gj = g->body[j];

sum = HCZ(gj);

sum = HCQ(gj);

} else if ( c == 0 ) {

sum = addz(sum,HCZ(gi));

addq(sum,HCQ(gi),&t);

sum = t;

g->body[i] = nd_remove_head(gi);

}

if ( j < 0 ) return -1;

else if ( sum ) {

HCZ(gj) = sum;

HCQ(gj) = sum;

return j;

} else

g->body[j] = nd_remove_head(gj);

Line 1524 ND normalize_pbucket(int mod,PGeoBucket g)

Line 1539 ND normalize_pbucket(int mod,PGeoBucket g)

return r;

}

void do_diagonalize(int sugar,int m)

int do_diagonalize(int sugar,int m)

{

int i,nh,stat;

NODE r,g,t;

ND h,nf,s,head;

NDV nfv;

Z q,num,den;

Q q,num,den;

Q dn;

union oNDC dn;

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

if ( nd_demand )

Line 1540 void do_diagonalize(int sugar,int m)

Line 1555 void do_diagonalize(int sugar,int m)

nfv = nd_ps[i];

s = ndvtond(m,nfv);

s = nd_separate_head(s,&head);

nd_nf(m,s,nd_ps,1,&dn,&nf);

stat = nd_nf(m,s,nd_ps,1,&dn,&nf);

if ( !stat ) return 0;

if ( !m ) {

HCZ(head) = mulz(HCZ(head),simpz((Z)NM(dn)));

NTOQ(NM(dn.z),SGN(dn.z),num);

if ( SGN(dn) < 0 ) HCZ(head) = chsgnz(HCZ(head));

mulq(HCQ(head),num,&q); HCQ(head) = q;

if ( DN(dn) )

if ( DN(dn.z) ) {

nd_mul_c_z(nf,simpz((Z)DN(dn)));

NTOQ(DN(dn.z),1,den);

nd_mul_c_q(nf,den);

}

nf = nd_add(m,head,nf);

ndv_free(nfv);

Line 1559 void do_diagonalize(int sugar,int m)

Line 1577 void do_diagonalize(int sugar,int m)

} else

nd_ps[i] = nfv;

}

return 1;

}

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

Line 1569 NODE nd_gb(int m,int ishomo,int checkonly)

Line 1588 NODE nd_gb(int m,int ishomo,int checkonly)

NODE r,g,t;

ND_pairs d;

ND_pairs l;

ND h,nf,s,head;

ND h,nf,s,head,nf1;

NDV nfv;

Q q,num,den;

union oNDC dn;

g = 0; d = 0;

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

Line 1582 NODE nd_gb(int m,int ishomo,int checkonly)

Line 1603 NODE nd_gb(int m,int ishomo,int checkonly)

again:

l = nd_minp(d,&d);

if ( SG(l) != sugar ) {

if ( ishomo ) do_diagonalize(sugar,m);

if ( ishomo ) {

stat = do_diagonalize(sugar,m);

if ( !stat ) {

NEXT(l) = d; d = l;

d = nd_reconstruct(0,d);

goto again;

}

sugar = SG(l);

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

}

Line 1606 again:

Line 1633 again:

if ( checkonly ) return 0;

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

nd_removecont(m,nf);

if ( !m && nd_nalg ) {

nd_monic(0,&nf);

nd_removecont(m,nf);

}

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

nh = ndv_newps(m,nfv,0);

d = update_pairs(d,g,nh);

Line 1625 again:

Line 1656 again:

return g;

}

void do_diagonalize_trace(int sugar,int m)

int do_diagonalize_trace(int sugar,int m)

{

int i,nh,stat;

NODE r,g,t;

ND h,nf,nfq,s,head;

NDV nfv,nfqv;

Q dn;

Q q,den,num;

union oNDC dn;

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

/* for nd_ps */

s = ndvtond(m,nd_ps[i]);

s = nd_separate_head(s,&head);

nd_nf_pbucket(m,s,nd_ps,1,&nf);

stat = nd_nf_pbucket(m,s,nd_ps,1,&nf);

if ( !stat ) return 0;

nf = nd_add(m,head,nf);

ndv_free(nd_ps[i]);

nd_ps[i] = ndtondv(m,nf);

Line 1650 void do_diagonalize_trace(int sugar,int m)

Line 1683 void do_diagonalize_trace(int sugar,int m)

nfv = nd_ps_trace[i];

s = ndvtond(0,nfv);

s = nd_separate_head(s,&head);

nd_nf(0,s,nd_ps_trace,1,&dn,&nf);

stat = nd_nf(0,s,nd_ps_trace,1,&dn,&nf);

HCZ(head) = mulz(HCZ(head),(Z)NM(dn));

if ( !stat ) return 0;

if ( SGN(dn) < 0 ) HCZ(head) = chsgnz(HCZ(head));

NTOQ(NM(dn.z),SGN(dn.z),num);

if ( DN(dn) )

mulq(HCQ(head),num,&q); HCQ(head) = q;

nd_mul_c_z(nf,(Z)DN(dn));

if ( DN(dn.z) ) {

NTOQ(DN(dn.z),1,den);

nd_mul_c_q(nf,den);

}

nf = nd_add(0,head,nf);

ndv_free(nfv);

nd_removecont(0,nf);

Line 1667 void do_diagonalize_trace(int sugar,int m)

Line 1703 void do_diagonalize_trace(int sugar,int m)

} else

nd_ps_trace[i] = nfv;

}

return 1;

}

static struct oEGT eg_invdalg;

struct oEGT eg_le;

NODE nd_gb_trace(int m,int ishomo)

{

int i,nh,sugar,stat;

Line 1677 NODE nd_gb_trace(int m,int ishomo)

Line 1717 NODE nd_gb_trace(int m,int ishomo)

ND_pairs l;

ND h,nf,nfq,s,head;

NDV nfv,nfqv;

Q q,den,num;

union oNDC dn;

struct oEGT eg_monic,egm0,egm1;

int diag_count = 0;

init_eg(&eg_monic);

init_eg(&eg_invdalg);

init_eg(&eg_le);

g = 0; d = 0;

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

d = update_pairs(d,g,i);

Line 1688 NODE nd_gb_trace(int m,int ishomo)

Line 1735 NODE nd_gb_trace(int m,int ishomo)

again:

l = nd_minp(d,&d);

if ( SG(l) != sugar ) {

if ( ishomo ) do_diagonalize_trace(sugar,m);

#if 1

if ( ishomo ) {

stat = do_diagonalize_trace(sugar,m);

diag_count = 0;

if ( !stat ) {

NEXT(l) = d; d = l;

d = nd_reconstruct(1,d);

goto again;

}

#endif

sugar = SG(l);

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

}

Line 1722 again:

Line 1779 again:

}

if ( nfq ) {

/* m|HC(nfq) => failure */

if ( !remzi(HCZ(nfq),m) ) return 0;

if ( !rem(NM(HCQ(nfq)),m) ) return 0;

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

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

if ( nd_nalg ) {

nd_removecont(0,nfq); nfqv = ndtondv(0,nfq); nd_free(nfq);

/* m|DN(HC(nf)^(-1)) => failure */

get_eg(&egm0);

if ( !nd_monic(m,&nfq) ) return 0;

get_eg(&egm1); add_eg(&eg_monic,&egm0,&egm1);

nd_removecont(0,nfq); nfqv = ndtondv(0,nfq); nd_free(nfq);

nfv = ndv_dup(0,nfqv); ndv_mod(m,nfv); nd_free(nf);

} else {

nd_removecont(0,nfq); nfqv = ndtondv(0,nfq); nd_free(nfq);

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

}

nh = ndv_newps(0,nfv,nfqv);

if ( ishomo && ++diag_count == diag_period ) {

diag_count = 0;

stat = do_diagonalize_trace(sugar,m);

if ( !stat ) {

NEXT(l) = d; d = l;

d = nd_reconstruct(1,d);

goto again;

}

d = update_pairs(d,g,nh);

g = update_base(g,nh);

} else {

Line 1744 again:

Line 1819 again:

else

for ( t = g; t; t = NEXT(t) )

BDY(t) = (pointer)nd_ps_trace[(int)BDY(t)];

if ( nd_nalg ) {

print_eg("monic",&eg_monic);

print_eg("invdalg",&eg_invdalg);

print_eg("le",&eg_le);

}

return g;

}

Line 1762 NODE ndv_reduceall(int m,NODE f)

Line 1842 NODE ndv_reduceall(int m,NODE f)

int i,n,stat;

ND nf,g,head;

NODE t,a0,a;

Q dn;

union oNDC dn;

NDV *w;

Q q,num,den;

n = length(f);

#if 0

Line 1773 NODE ndv_reduceall(int m,NODE f)

Line 1854 NODE ndv_reduceall(int m,NODE f)

(int (*)(const void *,const void *))ndv_compare);

for ( t = f, i = 0; t; i++, t = NEXT(t) ) BDY(t) = (pointer)w[i];

#endif

ndv_setup(m,0,f);

ndv_setup(m,0,f,0);

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

g = ndvtond(m,nd_ps[i]);

g = nd_separate_head(g,&head);

Line 1783 NODE ndv_reduceall(int m,NODE f)

Line 1864 NODE ndv_reduceall(int m,NODE f)

else {

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

if ( !m ) {

HCZ(head) = mulz(HCZ(head),simpz((Z)NM(dn)));

NTOQ(NM(dn.z),SGN(dn.z),num);

if ( SGN(dn) < 0 ) HCZ(head) = chsgnz(HCZ(head));

mulq(HCQ(head),num,&q); HCQ(head) = q;

if ( DN(dn) )

if ( DN(dn.z) ) {

nd_mul_c_z(nf,simpz((Z)DN(dn)));

NTOQ(DN(dn.z),1,den);

nd_mul_c_q(nf,den);

}

nf = nd_add(m,head,nf);

ndv_free(nd_ps[i]);

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

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

return nd_psn++;

}

void ndv_setup(int mod,int trace,NODE f)

void ndv_setup(int mod,int trace,NODE f,int dont_sort)

{

int i,j,td,len,max;

NODE s,s0,f0;

Line 2125 void ndv_setup(int mod,int trace,NODE f)

Line 2208 void ndv_setup(int mod,int trace,NODE f)

for ( nd_psn = 0, s = f; s; s = NEXT(s) ) if ( BDY(s) ) nd_psn++;

w = (NDV *)ALLOCA(nd_psn*sizeof(NDV));

for ( i = 0, s = f; s; s = NEXT(s) ) if ( BDY(s) ) w[i++] = BDY(s);

qsort(w,nd_psn,sizeof(NDV),

if ( !dont_sort )

(int (*)(const void *,const void *))ndv_compare);

qsort(w,nd_psn,sizeof(NDV),

(int (*)(const void *,const void *))ndv_compare);

nd_pslen = 2*nd_psn;

nd_ps = (NDV *)MALLOC(nd_pslen*sizeof(NDV));

nd_ps_trace = (NDV *)MALLOC(nd_pslen*sizeof(NDV));

Line 2162 void ndv_setup(int mod,int trace,NODE f)

Line 2246 void ndv_setup(int mod,int trace,NODE f)

}

struct order_spec *append_block(struct order_spec *spec,

int nv,int nalg,int ord);

extern VECT current_dl_weight_vector_obj;

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;

VL tv;

P poly;

DP d;

Alg alpha,dp;

DAlg inv,da,hc;

MP m;

int i,nvar,nalg,n;

NumberField nf;

LIST f1,f2;

struct order_spec *current_spec;

VECT obj,obj0;

Obj tmp;

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

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

for ( alist = 0, tv = av; tv; tv = NEXT(tv) ) {

NEXTNODE(alist,t); MKV(tv->v,poly);

MKAlg(poly,alpha); BDY(t) = (pointer)alpha;

tv->v = tv->v->priv;

}

NEXT(t) = 0;

/* simplification, makeing polynomials monic */

setfield_dalg(alist);

obj_algtodalg(f,&f1);

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

initd(ord); ptod(vv,vv,(P)BDY(t),&d);

hc = (DAlg)BDY(d)->c;

if ( NID(hc) == N_DA ) {

invdalg(hc,&inv);

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

muldalg(inv,(DAlg)m->c,&da); m->c = (P)da;

}

initd(ord); dtop(vv,vv,d,&poly); BDY(f) = (pointer)poly;

}

obj_dalgtoalg(f1,&f);

/* append alg vars to the var list */

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

NEXT(tv) = av;

/* append a block to ord */

*ord1p = append_block(ord,nvar,nalg,2);

/* create generator list */

nf = get_numberfield();

for ( i = nalg-1, t = BDY(f); i >= 0; i-- ) {

MKAlg(nf->defpoly[i],dp);

MKNODE(s,dp,t); t = s;

}

MKLIST(f1,t);

*alistp = alist;

algobjtorat(f1,f1p);

/* creating a new weight vector */

prev_weight_vector_obj = obj0 = current_dl_weight_vector_obj;

n = nvar+nalg+1;

MKVECT(obj,n);

if ( obj0 && obj0->len == nvar )

for ( i = 0; i < nvar; i++ ) BDY(obj)[i] = BDY(obj0)[i];

else

for ( i = 0; i < nvar; i++ ) BDY(obj)[i] = (pointer)ONE;

for ( i = 0; i < nalg; i++ ) BDY(obj)[i+nvar] = 0;

BDY(obj)[n-1] = (pointer)ONE;

arg = mknode(1,obj);

Pdp_set_weight(arg,&tmp);

}

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

{

NODE s,t,u0,u;

P p;

VL tv;

Obj obj,tmp;

NODE arg;

u0 = 0;

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

p = (P)BDY(t);

for ( tv = av, s = alist; tv; tv = NEXT(tv), s = NEXT(s) ) {

substr(CO,0,(Obj)p,tv->v,(Obj)BDY(s),&obj); p = (P)obj;

}

if ( OID(p) == O_P || (OID(p) == O_N && NID((Num)p) != N_A) ) {

NEXTNODE(u0,u);

BDY(u) = (pointer)p;

}

arg = mknode(1,prev_weight_vector_obj);

Pdp_set_weight(arg,&tmp);

return u0;

}

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

{

VL tv,fv,vv,vc;

VL tv,fv,vv,vc,av;

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

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

int e,max,nvar;

int e,max,nvar,i;

NDV b;

int ishomo;

int ishomo,nalg;

Alg alpha,dp;

P p;

LIST f1,f2;

Obj obj;

NumberField nf;

struct order_spec *ord1;

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

else nd_demand = 0;

Line 2186 void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe

Line 2381 void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe

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;

}

nvar += nalg;

}

nd_init_ord(ord);

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

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

Line 2202 void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe

Line 2412 void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe

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

}

if ( fd0 ) NEXT(fd) = 0;

ndv_setup(m,0,fd0);

ndv_setup(m,0,fd0,0);

x = f4?nd_f4(m):nd_gb(m,ishomo,0);

nd_demand = 0;

x = ndv_reducebase(x);

Line 2212 void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe

Line 2422 void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe

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

}

if ( r0 ) NEXT(r) = 0;

if ( nalg )

r0 = postprocess_algcoef(av,alist,r0);

MKLIST(*rp,r0);

#if 0

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

#endif

}

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

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;

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

int e,max,nvar,i;

NDV b;

int ishomo,nalg;

Alg alpha,dp;

P p;

LIST f1,f2;

Obj obj;

NumberField nf;

struct order_spec *ord1;

VL tv,fv,vv,vc;

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

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

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

}

nvar += nalg;

}

nd_init_ord(ord);

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

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

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

max = MAX(e,max);

}

nd_setup_parameters(nvar,max);

ishomo = 1;

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

b = (pointer)ptondv(CO,vv,(P)BDY(t));

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;

ndv_setup(m,0,fd0,0);

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

x = update_base(x,i);

if ( do_check ) {

x = nd_gb(m,ishomo,1);

if ( !x ) {

*rp = 0;

return;

}

} else {

for ( t = x; t; t = NEXT(t) )

BDY(t) = (pointer)nd_ps[(int)BDY(t)];

}

x = ndv_reducebase(x);

x = ndv_reduceall(m,x);

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

NEXTNODE(r0,r);

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

}

if ( r0 ) NEXT(r) = 0;

if ( nalg )

r0 = postprocess_algcoef(av,alist,r0);

MKLIST(*rp,r0);

}

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

{

VL tv,fv,vv,vc,av;

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

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

NDV c;

NMV a;

P p;

EPOS oepos;

int obpe,oadv,wmax,i,len,cbpe,ishomo;

int obpe,oadv,wmax,i,len,cbpe,ishomo,nalg;

Alg alpha,dp;

P poly;

LIST f1,f2;

Obj obj;

NumberField nf;

struct order_spec *ord1;

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

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

Line 2240 void nd_gr_trace(LIST f,LIST v,int trace,int homo,stru

Line 2537 void nd_gr_trace(LIST f,LIST v,int trace,int homo,stru

default:

break;

}

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;

}

nvar += nalg;

nocheck = 0;

mindex = 0;

Line 2273 void nd_gr_trace(LIST f,LIST v,int trace,int homo,stru

Line 2583 void nd_gr_trace(LIST f,LIST v,int trace,int homo,stru

if ( in0 ) NEXT(in) = 0;

if ( fd0 ) NEXT(fd) = 0;

if ( !ishomo && homo ) {

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

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

Line 2287 void nd_gr_trace(LIST f,LIST v,int trace,int homo,stru

Line 2597 void nd_gr_trace(LIST f,LIST v,int trace,int homo,stru

while ( 1 ) {

if ( Demand )

nd_demand = 1;

ndv_setup(m,1,fd0);

ndv_setup(m,1,fd0,0);

cand = nd_gb_trace(m,ishomo || homo);

cand = f4?nd_f4_trace(m):nd_gb_trace(m,ishomo || homo);

if ( !cand ) {

/* failure */

if ( trace > 1 ) { *rp = 0; return; }

Line 2329 void nd_gr_trace(LIST f,LIST v,int trace,int homo,stru

Line 2639 void nd_gr_trace(LIST f,LIST v,int trace,int homo,stru

/* dp->p */

nd_bpe = cbpe;

nd_setup_parameters(nd_nvar,0);

for ( r = cand; r; r = NEXT(r) ) BDY(r) = (pointer)ndvtop(0,CO,vv,BDY(r));

for ( r = cand; r; r = NEXT(r) )

BDY(r) = (pointer)ndvtop(0,CO,vv,BDY(r));

if ( nalg )

cand = postprocess_algcoef(av,alist,cand);

MKLIST(*rp,cand);

}

Line 2417 void nd_print(ND p)

Line 2730 void nd_print(ND p)

}

void nd_print_z(ND p)

void nd_print_q(ND p)

{

NM m;

Line 2426 void nd_print_z(ND p)

Line 2739 void nd_print_z(ND p)

else {

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

printf("+");

printz(CZ(m));

printexpr(CO,(Obj)CQ(m));

printf("*");

ndl_print(DL(m));

}

Line 2445 void ndp_print(ND_pairs d)

Line 2758 void ndp_print(ND_pairs d)

void nd_removecont(int mod,ND p)

{

int i,n;

Z *w;

Q *w;

Z dvr,t;

Q dvr,t;

NM m;

struct oVECT v;

N q,r;

if ( mod == -1 ) nd_mul_c(mod,p,_invsf(HCM(p)));

else if ( mod ) nd_mul_c(mod,p,invm(HCM(p),mod));

else {

for ( m = BDY(p), n = 0; m; m = NEXT(m), n++ );

w = (Z *)ALLOCA(n*sizeof(Z));

w = (Q *)ALLOCA(n*sizeof(Q));

v.len = n;

v.body = (pointer *)w;

for ( m = BDY(p), i = 0; i < n; m = NEXT(m), i++ ) w[i] = CZ(m);

for ( m = BDY(p), i = 0; i < n; m = NEXT(m), i++ ) w[i] = CQ(m);

removecont_array(w,n);

for ( m = BDY(p), i = 0; i < n; m = NEXT(m), i++ ) CZ(m) = w[i];

for ( m = BDY(p), i = 0; i < n; m = NEXT(m), i++ ) CQ(m) = w[i];

}

void nd_removecont2(ND p1,ND p2)

{

int i,n1,n2,n;

Z *w;

Q *w;

Q dvr,t;

NM m;

struct oVECT v;

N q,r;

if ( !p1 ) {

nd_removecont(0,p2); return;

Line 2478 void nd_removecont2(ND p1,ND p2)

Line 2794 void nd_removecont2(ND p1,ND p2)

n1 = nd_length(p1);

n2 = nd_length(p2);

n = n1+n2;

w = (Z *)ALLOCA(n*sizeof(Z));

w = (Q *)ALLOCA(n*sizeof(Q));

v.len = n;

v.body = (pointer *)w;

for ( m = BDY(p1), i = 0; i < n1; m = NEXT(m), i++ ) w[i] = CZ(m);

for ( m = BDY(p1), i = 0; i < n1; m = NEXT(m), i++ ) w[i] = CQ(m);

for ( m = BDY(p2); i < n; m = NEXT(m), i++ ) w[i] = CZ(m);

for ( m = BDY(p2); i < n; m = NEXT(m), i++ ) w[i] = CQ(m);

removecont_array(w,n);

for ( m = BDY(p1), i = 0; i < n1; m = NEXT(m), i++ ) CZ(m) = w[i];

for ( m = BDY(p1), i = 0; i < n1; m = NEXT(m), i++ ) CQ(m) = w[i];

for ( m = BDY(p2); i < n; m = NEXT(m), i++ ) CZ(m) = w[i];

for ( m = BDY(p2); i < n; m = NEXT(m), i++ ) CQ(m) = w[i];

}

void ndv_removecont(int mod,NDV p)

{

int i,len;

Z *w;

Q *w;

Z dvr,t;

Q dvr,t;

NMV m;

if ( mod == -1 )

Line 2501 void ndv_removecont(int mod,NDV p)

Line 2817 void ndv_removecont(int mod,NDV p)

ndv_mul_c(mod,p,invm(HCM(p),mod));

else {

len = p->len;

w = (Z *)ALLOCA(len*sizeof(Z));

w = (Q *)ALLOCA(len*sizeof(Q));

for ( m = BDY(p), i = 0; i < len; NMV_ADV(m), i++ ) w[i] = CZ(m);

for ( m = BDY(p), i = 0; i < len; NMV_ADV(m), i++ ) w[i] = CQ(m);

removecont_array(w,len);

sortbynm(w,len);

for ( m = BDY(p), i = 0; i < len; NMV_ADV(m), i++ ) CZ(m) = w[i];

qltozl(w,len,&dvr);

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

divq(CQ(m),dvr,&t); CQ(m) = t;

}

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

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

t = (NMV)ALLOCA(nmv_adv);

for ( i = 0; i < len; i++, NMV_OPREV(m), NMV_PREV(mr) ) {

ndl_homogenize(DL(m),DL(t),obpe,oepos,max);

CZ(mr) = CZ(m);

CQ(mr) = CQ(m);

ndl_copy(DL(t),DL(mr));

}

NV(p)++;

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

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

void ndv_dehomogenize(NDV p,struct order_spec *ord)

{

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

Z *w;

Q *w;

Z dvr,t;

Q dvr,t;

NMV m,r;

len = p->len;

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

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

if ( newwpd != nd_wpd ) {

newadv = ROUND_FOR_ALIGN(sizeof(struct oNMV)+(newwpd-1)*sizeof(UINT));

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

CZ(r) = CZ(m);

CQ(r) = CQ(m);

for ( j = 0; j < newexporigin; j++ ) DL(r)[j] = DL(m)[j];

adj = nd_exporigin-newexporigin;

for ( ; j < newwpd; j++ ) DL(r)[j] = DL(m)[j+adj];

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

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

NV(p)--;

}

int comp_z(Z *a,Z *b)

void removecont_array(Q *c,int n)

{

return cmpz(*a,*b);

}

Z zgcdv(VECT a)

{

int i,j,n,nz;

Z g,gt,q,r;

Z *c;

n = a->len;

c = (Z *)ALLOCA(n*sizeof(Z));

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

c[i] = (Z)a->body[i];

qsort(c,n,sizeof(Z),(int (*) (const void *,const void *))comp_z);

for ( ; n && ! *c; n--, c++ );

if ( !n )

return 0;

else if ( n == 1 )

return absz(c[0]);

g = gcdz(c[0],c[1]);

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

q = divz(c[i],g,&r);

gt = gcdz(g,r);

if ( !cmpz(g,gt) ) {

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

q = divz(c[j],g,&r); c[j] = r;

}

} else

g = gt;

}

return absz(g);

}

Z zgcdv_estimate(VECT a)

{

int n,i,m;

Z s,t,u,g;

Z *q;

n = a->len; q = (Z *)a->body;

if ( n == 1 )

return absz(q[0]);

m = n/2;

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

s = sgnz(q[i])>=0 ? addz(s,q[i]) : subz(s,q[i]);

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

t = sgnz(q[i])>=0 ? addz(t,q[i]) : subz(t,q[i]);

g = gcdz(s,t);

return absz(g);

}

void removecont_array(Z *c,int n)

{

struct oVECT v;

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

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

int i,j;

Z q0,q1;

N qn,rn,gn;

Z *q,*r;

Q *q,*r;

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

q = (Q *)ALLOCA(n*sizeof(Q));

r = (Z *)ALLOCA(n*sizeof(Z));

r = (Q *)ALLOCA(n*sizeof(Q));

v.id = O_VECT; v.len = n; v.body = (pointer *)c;

d0 = zgcdv_estimate(&v);

igcdv_estimate(&v,&d0);

/* c[i] = d0*q[i]+r[i] */

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

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

divn(NM(c[i]),NM(d0),&qn,&rn);

q[i] = divz(c[i],d0,&r[i]);

NTOQ(qn,SGN(c[i])*SGN(d0),q[i]);

NTOQ(rn,SGN(c[i]),r[i]);

}

for ( i = 0; i < n; i++ ) if ( r[i] ) break;

if ( i < n ) {

v.id = O_VECT; v.len = n; v.body = (pointer *)r;

/* d1 = GCD(r[0],...,r[n-1]) */

igcdv(&v,&d1);

d1 = zgcdv(&v);

gcdn(NM(d0),NM(d1),&gn); NTOQ(gn,1,gcd);

/* q0 = d0/GCD(d0,d1) */

divsn(NM(d0),gn,&qn); NTOQ(qn,1,a);

gcd = gcdz_cofactor(d0,d1,&q0,&q1);

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

/* q[i] = d0/gcd*q[i]+r[i]/gcd */

mulq(a,q[i],&u);

q[i] = addz(mulz(q0,q[i]),divsz(r[i],gcd));

if ( r[i] ) {

divsn(NM(r[i]),gn,&qn); NTOQ(qn,SGN(r[i]),u1);

addq(u,u1,&q[i]);

} else

q[i] = u;

}

for ( i = 0; i < n; i++ ) c[i] = q[i];

Line 2646 void nd_mul_c(int mod,ND p,int mul)

Line 2914 void nd_mul_c(int mod,ND p,int mul)

int c,c1;

if ( !p ) return;

if ( mul == 1 ) return;

if ( mod == -1 )

for ( m = BDY(p); m; m = NEXT(m) )

CM(m) = _mulsf(CM(m),mul);

Line 2655 void nd_mul_c(int mod,ND p,int mul)

Line 2924 void nd_mul_c(int mod,ND p,int mul)

}

void nd_mul_c_z(ND p,Z mul)

void nd_mul_c_q(ND p,Q mul)

{

NM m;

Z c;

Q c;

if ( !p || uniz(mul) ) return;

if ( !p ) return;

if ( UNIQ(mul) ) return;

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

CZ(m) = mulz(CZ(m),mul);

mulq(CQ(m),mul,&c); CQ(m) = c;

}

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

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

}

lcm = LCM(p);

NEWNM(m);

CZ(m) = HCZ(p2);

CQ(m) = HCQ(p2);

ndl_sub(lcm,HDL(p1),DL(m));

if ( ndl_check_bound2(p->i1,DL(m)) )

return 0;

t1 = ndv_mul_nm(mod,m,p1);

if ( mod == -1 ) CM(m) = _chsgnsf(HCM(p1));

else if ( mod ) CM(m) = mod-HCM(p1);

else CZ(m) = chsgnz(HCZ(p1));

else chsgnq(HCQ(p1),&CQ(m));

ndl_sub(lcm,HDL(p2),DL(m));

if ( ndl_check_bound2(p->i2,DL(m)) ) {

nd_free(t1);

Line 3004 void ndv_mul_c(int mod,NDV p,int mul)

Line 3274 void ndv_mul_c(int mod,NDV p,int mul)

}

void ndv_mul_c_z(NDV p,Z mul)

void ndv_mul_c_q(NDV p,Q mul)

{

NMV m;

Z c;

Q c;

int len,i;

if ( !p ) return;

len = LEN(p);

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

CZ(m) = mulz(CZ(m),mul);

mulq(CQ(m),mul,&c); CQ(m) = c;

}

Line 3060 void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta

Line 3330 void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta

{

int i,n2,j,s,curlen,homo,h,a,b,k,l,u,min;

UINT *d0,*d1,*d,*dt,*ctab;

Z *ctab_z;

Q *ctab_q;

Z q,q1;

Q q,q1;

UINT c0,c1,c;

NM *p;

NM m,t;

Line 3073 void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta

Line 3343 void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta

if ( mod ) {

c0 = CM(m0); c1 = CM(m1); DMAR(c0,c1,0,mod,c); CM(m) = c;

} else

CZ(m) = mulz(CZ(m0),CZ(m1));

mulq(CQ(m0),CQ(m1),&CQ(m));

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

homo = n&1 ? 1 : 0;

if ( homo ) {

Line 3106 void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta

Line 3376 void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta

ctab = (UINT *)ALLOCA((min+1)*sizeof(UINT));

mkwcm(k,l,mod,ctab);

} else {

ctab_z = (Z *)ALLOCA((min+1)*sizeof(Z));

ctab_q = (Q *)ALLOCA((min+1)*sizeof(Q));

mkwcz(k,l,ctab_z);

mkwc(k,l,ctab_q);

}

for ( j = min; j >= 0; j-- ) {

for ( u = 0; u < nd_wpd; u++ ) d[u] = 0;

Line 3119 void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta

Line 3389 void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta

} else TD(d) = h;

if ( nd_blockmask ) ndl_weight_mask(d);

if ( mod ) c = ctab[j];

else q = ctab_z[j];

else q = ctab_q[j];

p = tab+curlen*j;

if ( j == 0 ) {

for ( u = 0; u < curlen; u++, p++ ) {

Line 3128 void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta

Line 3398 void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta

if ( mod ) {

c0 = CM(tab[u]); DMAR(c0,c,0,mod,c1); CM(tab[u]) = c1;

} else {

CZ(tab[u]) = mulz(CZ(tab[u]),q);

mulq(CQ(tab[u]),q,&q1); CQ(tab[u]) = q1;

}

Line 3140 void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta

Line 3410 void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta

if ( mod ) {

c0 = CM(tab[u]); DMAR(c0,c,0,mod,c1); CM(t) = c1;

} else

CZ(t) = mulz(CZ(tab[u]),q);

mulq(CQ(tab[u]),q,&CQ(t));

*p = t;

}

Line 3157 ND ndv_mul_nm_symbolic(NM m0,NDV p)

Line 3427 ND ndv_mul_nm_symbolic(NM m0,NDV p)

NMV m;

UINT *d,*dt,*dm;

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

Q q;

ND r;

if ( !p ) return 0;

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

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

NMV m;

UINT *d,*dt,*dm;

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

Z q;

Q q;

ND r;

if ( !p ) return 0;

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

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

ndl_add(DL(m),d,DL(mr));

}

} else {

q = CZ(m0);

q = CQ(m0);

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

NEXTNM(mr0,mr);

CZ(mr) = mulz(CZ(m),q);

mulq(CQ(m),q,&CQ(mr));

ndl_add(DL(m),d,DL(mr));

}

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

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

{

NM mq0,mq;

NMV tm;

Q q;

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

ND p,t,r;

N tnm;

if ( !p ) return 0;

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

else {

nv = NV(d);

mq0 = 0;

tm = (NMV)ALLOCA(nmv_adv);

while ( 1 ) {

hindex = mod?head_pbucket(mod,bucket):head_pbucket_z(bucket);

hindex = mod?head_pbucket(mod,bucket):head_pbucket_q(bucket);

if ( hindex < 0 ) break;

p = bucket->body[hindex];

NEXTNM(mq0,mq);

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

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

DMAR(c1,c2,0,mod,c); CM(mq) = c;

CM(tm) = mod-c;

} else {

CZ(mq) = divsz(HCZ(p),HCZ(d));

divsn(NM(HCQ(p)),NM(HCQ(d)),&tnm);

CZ(tm) = chsgnz(CZ(mq));

NTOQ(tnm,SGN(HCQ(p))*SGN(HCQ(d)),CQ(mq));

chsgnq(CQ(mq),&CQ(tm));

}

t = ndv_mul_nmv_trunc(mod,tm,d,HDL(d));

bucket->body[hindex] = nd_remove_head(p);

Line 3289 void ndv_realloc(NDV p,int obpe,int oadv,EPOS oepos)

Line 3562 void ndv_realloc(NDV p,int obpe,int oadv,EPOS oepos)

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

t = (NMV)ALLOCA(nmv_adv);

for ( i = 0; i < len; i++, NMV_OPREV(m), NMV_PREV(mr) ) {

CZ(t) = CZ(m);

CQ(t) = CQ(m);

for ( k = 0; k < nd_wpd; k++ ) DL(t)[k] = 0;

ndl_reconstruct(DL(m),DL(t),obpe,oepos);

CZ(mr) = CZ(t);

CQ(mr) = CQ(t);

ndl_copy(DL(t),DL(mr));

}

BDY(p) = mr0;

Line 3310 NDV ndv_dup_realloc(NDV p,int obpe,int oadv,EPOS oepos

Line 3583 NDV ndv_dup_realloc(NDV p,int obpe,int oadv,EPOS oepos

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

ndl_zero(DL(mr));

ndl_reconstruct(DL(m),DL(mr),obpe,oepos);

CZ(mr) = CZ(m);

CQ(mr) = CQ(m);

}

MKNDV(NV(p),mr0,len,r);

SG(r) = SG(p);

Line 3330 NDV ndv_dup(int mod,NDV p)

Line 3603 NDV ndv_dup(int mod,NDV p)

m0 = m = (NMV)(mod?MALLOC_ATOMIC(len*nmv_adv):MALLOC(len*nmv_adv));

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

ndl_copy(DL(t),DL(m));

CZ(m) = CZ(t);

CQ(m) = CQ(t);

}

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

SG(d) = SG(p);

Line 3346 ND nd_dup(ND p)

Line 3619 ND nd_dup(ND p)

for ( m0 = 0, t = BDY(p); t; t = NEXT(t) ) {

NEXTNM(m0,m);

ndl_copy(DL(t),DL(m));

CZ(m) = CZ(t);

CQ(m) = CQ(t);

}

if ( m0 ) NEXT(m) = 0;

MKND(NV(p),m0,LEN(p),d);

Line 3359 ND nd_dup(ND p)

Line 3632 ND nd_dup(ND p)

void ndv_mod(int mod,NDV p)

{

NMV t,d;

int r;

int r,s,u;

int i,len,dlen;

Obj gfs;

Line 3377 void ndv_mod(int mod,NDV p)

Line 3650 void ndv_mod(int mod,NDV p)

}

else

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

r = remzi(CZ(t),mod);

r = rem(NM(CQ(t)),mod);

if ( r ) {

if ( SGN(CQ(t)) < 0 )

r = mod-r;

if ( DN(CQ(t)) ) {

s = rem(DN(CQ(t)),mod);

if ( !s )

error("ndv_mod : division by 0");

s = invm(s,mod);

DMAR(r,s,0,mod,u); r = u;

}

CM(d) = r;

ndl_copy(DL(t),DL(d));

NMV_ADV(d);

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

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

else if ( NUM(p) ) {

NEWNM(m);

ndl_zero(DL(m));

CZ(m) = qtoz((Q)p);

CQ(m) = (Q)p;

NEXT(m) = 0;

MKND(nd_nvar,m,1,r);

SG(r) = 0;

Line 3472 P ndvtop(int mod,VL vl,VL dvl,NDV p)

Line 3754 P ndvtop(int mod,VL vl,VL dvl,NDV p)

} else if ( mod ) {

STOQ(CM(m),q); c = (P)q;

} else

c = (P)ztoq(CZ(m));

c = CP(m);

d = DL(m);

for ( i = 0, t = c, tvl = dvl; i < n; tvl = NEXT(tvl), i++ ) {

MKV(tvl->v,r); e = GET_EXP(d,i); STOQ(e,q);

Line 3502 NDV ndtondv(int mod,ND p)

Line 3784 NDV ndtondv(int mod,ND p)

#endif

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

ndl_copy(DL(t),DL(m));

CZ(m) = CZ(t);

CQ(m) = CQ(t);

}

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

SG(d) = SG(p);

Line 3522 ND ndvtond(int mod,NDV p)

Line 3804 ND ndvtond(int mod,NDV p)

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

NEXTNM(m0,m);

ndl_copy(DL(t),DL(m));

CZ(m) = CZ(t);

CQ(m) = CQ(t);

}

NEXT(m) = 0;

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

Line 3547 void ndv_print(NDV p)

Line 3829 void ndv_print(NDV p)

}

void ndv_print_z(NDV p)

void ndv_print_q(NDV p)

{

NMV m;

int i,len;

Line 3557 void ndv_print_z(NDV p)

Line 3839 void ndv_print_z(NDV p)

len = LEN(p);

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

printf("+");

printz(CZ(m));

printexpr(CO,(Obj)CQ(m));

printf("*");

ndl_print(DL(m));

}

Line 3732 void nd_nf_p(P f,LIST g,LIST v,int m,struct order_spec

Line 4014 void nd_nf_p(P f,LIST g,LIST v,int m,struct order_spec

NDV ndv;

VL vv,tv;

int stat,nvar,max,e;

union oNDC dn;

if ( !f ) {

*rp = 0;

return;

}

pltovl(v,&vv);

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

Line 3761 void nd_nf_p(P f,LIST g,LIST v,int m,struct order_spec

Line 4048 void nd_nf_p(P f,LIST g,LIST v,int m,struct order_spec

if ( m ) ndv_mod(m,(NDV)BDY(in));

NEXT(in) = 0;

ndv_setup(m,0,in0);

/* dont sort */

ndv_setup(m,0,in0,1);

nd_psn--;

nd_scale=2;

while ( 1 ) {

Line 3793 int nd_to_vect(int mod,UINT *s0,int n,ND d,UINT *r)

Line 4081 int nd_to_vect(int mod,UINT *s0,int n,ND d,UINT *r)

return i;

}

int nd_to_vect_z(UINT *s0,int n,ND d,Z *r)

int nd_to_vect_q(UINT *s0,int n,ND d,Q *r)

{

NM m;

UINT *t,*s;

Line 3803 int nd_to_vect_z(UINT *s0,int n,ND d,Z *r)

Line 4091 int nd_to_vect_z(UINT *s0,int n,ND d,Z *r)

for ( i = 0, s = s0, m = BDY(d); m; m = NEXT(m) ) {

t = DL(m);

for ( ; !ndl_equal(t,s); s += nd_wpd, i++ );

r[i] = CZ(m);

r[i] = CQ(m);

}

for ( i = 0; !r[i]; i++ );

return i;

}

Q *nm_ind_pair_to_vect(int mod,UINT *s0,int n,NM_ind_pair pair)

{

NM m;

NMV mr;

UINT *d,*t,*s;

NDV p;

int i,j,len;

Q *r;

m = pair->mul;

d = DL(m);

p = nd_ps[pair->index];

len = LEN(p);

r = (Q *)CALLOC(n,sizeof(Q));

t = (UINT *)ALLOCA(nd_wpd*sizeof(UINT));

for ( i = j = 0, s = s0, mr = BDY(p); j < len; j++, NMV_ADV(mr) ) {

ndl_add(d,DL(mr),t);

for ( ; !ndl_equal(t,s); s += nd_wpd, i++ );

r[i] = CQ(mr);

}

return r;

}

IndArray nm_ind_pair_to_vect_compress(int mod,UINT *s0,int n,NM_ind_pair pair)

{

NM m;

Line 3857 IndArray nm_ind_pair_to_vect_compress(int mod,UINT *s0

Line 4168 IndArray nm_ind_pair_to_vect_compress(int mod,UINT *s0

return r;

}

int ndv_reduce_vect_q(Q *svect,int trace,int col,IndArray *imat,NM_ind_pair *rp0,int nred)

int ndv_reduce_vect_z(Z *svect,int col,IndArray *imat,NM_ind_pair *rp0,int nred)

{

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

Z cs,mcs,c1,c2,cr,gcd,t;

Q cs,mcs,c1,c2,cr,gcd,t;

IndArray ivect;

unsigned char *ivc;

unsigned short *ivs;

Line 3870 int ndv_reduce_vect_z(Z *svect,int col,IndArray *imat,

Line 4180 int ndv_reduce_vect_z(Z *svect,int col,IndArray *imat,

NMV mr;

NODE rp;

int maxrs;

double hmag;

struct oVECT v;

v.id = O_VECT; v.len = col; v.body = (pointer *)svect;

maxrs = 0;

for ( i = 0; i < col && !svect[i]; i++ );

if ( i == col ) return maxrs;

hmag = p_mag((P)svect[i])*nd_scale;

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

ivect = imat[i];

k = ivect->head;

if ( svect[k] ) {

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

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

redv = trace?nd_ps_trace[rp0[i]->index]:nd_ps[rp0[i]->index];

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

gcd = gcdz_cofactor(svect[k],CZ(mr),&cs,&cr);

igcd_cofactor(svect[k],CQ(mr),&gcd,&cs,&cr);

mcs = chsgnz(cs);

chsgnq(cs,&mcs);

if ( !uniz(cr) )

if ( !UNIQ(cr) ) {

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

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

svect[j] = mulz(svect[j],cr);

mulq(svect[j],cr,&c1); svect[j] = c1;

}

svect[k] = 0; prev = k;

switch ( ivect->width ) {

case 1:

ivc = ivect->index.c;

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

pos = prev+ivc[j]; prev = pos;

svect[pos] = addz(svect[pos],mulz(CZ(mr),mcs));

mulq(CQ(mr),mcs,&c2); addq(svect[pos],c2,&t); svect[pos] = t;

}

break;

case 2:

ivs = ivect->index.s;

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

pos = prev+ivs[j]; prev = pos;

svect[pos] = addz(svect[pos],mulz(CZ(mr),mcs));

mulq(CQ(mr),mcs,&c2); addq(svect[pos],c2,&t); svect[pos] = t;

}

break;

case 4:

ivi = ivect->index.i;

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

pos = prev+ivi[j]; prev = pos;

svect[pos] = addz(svect[pos],mulz(CZ(mr),mcs));

mulq(CQ(mr),mcs,&c2); addq(svect[pos],c2,&t); svect[pos] = t;

}

break;

}

for ( j = k+1; j < col && !svect[j]; j++ );

if ( j == col ) break;

if ( hmag && ((double)p_mag((P)svect[j]) > hmag) ) {

igcdv(&v,&t);

hmag = ((double)p_mag((P)svect[j]))*nd_scale;

}

igcdv(&v,&t);

if ( DP_Print ) {

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

}

return maxrs;

}

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

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

}

NDV vect_to_ndv_z(Z *vect,int spcol,int col,int *rhead,UINT *s0vect)

/* for preprocessed vector */

NDV vect_to_ndv_q(Q *vect,int spcol,int col,int *rhead,UINT *s0vect)

{

int j,k,len;

UINT *p;

Z c;

Q c;

NDV r;

NMV mr0,mr;

Line 4072 NDV vect_to_ndv_z(Z *vect,int spcol,int col,int *rhead

Line 4402 NDV vect_to_ndv_z(Z *vect,int spcol,int col,int *rhead

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

if ( !rhead[j] ) {

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

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

if ( DN(c) )

error("afo");

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

}

MKNDV(nd_nvar,mr0,len,r);

Line 4080 NDV vect_to_ndv_z(Z *vect,int spcol,int col,int *rhead

Line 4412 NDV vect_to_ndv_z(Z *vect,int spcol,int col,int *rhead

}

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

/* for plain vector */

NDV plain_vect_to_ndv_q(Q *vect,int col,UINT *s0vect)

{

int j,k,len;

UINT *p;

Q 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)GC_malloc(nmv_adv*len);

#if 0

ndv_alloc += nmv_adv*len;

#endif

mr = mr0;

p = s0vect;

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

if ( c = vect[k] ) {

if ( DN(c) )

error("afo");

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

}

MKNDV(nd_nvar,mr0,len,r);

return r;

}

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

{

ND_pairs t;

NODE sp0,sp;

int stat;

ND spol;

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

stat = nd_sp(m,0,t,&spol);

stat = nd_sp(m,trace,t,&spol);

if ( !stat ) return 0;

if ( spol ) {

add_pbucket_symbolic(bucket,spol);

Line 4097 int nd_sp_f4(int m,ND_pairs l,PGeoBucket bucket)

Line 4459 int nd_sp_f4(int m,ND_pairs l,PGeoBucket bucket)

return 1;

}

int nd_symbolic_preproc(PGeoBucket bucket,UINT **s0vect,NODE *r)

int nd_symbolic_preproc(PGeoBucket bucket,int trace,UINT **s0vect,NODE *r)

{

NODE rp0,rp;

NM mul,head,s0,s;

Line 4106 int nd_symbolic_preproc(PGeoBucket bucket,UINT **s0vec

Line 4468 int nd_symbolic_preproc(PGeoBucket bucket,UINT **s0vec

UINT *s0v,*p;

NM_ind_pair pair;

ND red;

NDV *ps;

s0 = 0; rp0 = 0; col = 0;

ps = trace?nd_ps_trace:nd_ps;

while ( 1 ) {

head = remove_head_pbucket_symbolic(bucket);

if ( !head ) break;

Line 4120 int nd_symbolic_preproc(PGeoBucket bucket,UINT **s0vec

Line 4484 int nd_symbolic_preproc(PGeoBucket bucket,UINT **s0vec

NEWNM(mul);

ndl_sub(DL(head),DL(h),DL(mul));

if ( ndl_check_bound2(index,DL(mul)) ) return 0;

sugar = TD(DL(mul))+SG(nd_ps[index]);

sugar = TD(DL(mul))+SG(ps[index]);

MKNM_ind_pair(pair,mul,index,sugar);

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

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

add_pbucket_symbolic(bucket,nd_remove_head(red));

NEXTNODE(rp0,rp); BDY(rp) = (pointer)pair;

}

Line 4172 NODE nd_f4(int m)

Line 4536 NODE nd_f4(int m)

l = nd_minsugarp(d,&d);

sugar = SG(l);

bucket = create_pbucket();

stat = nd_sp_f4(m,l,bucket);

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

if ( !stat ) {

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

NEXT(t) = d; d = l;

Line 4180 NODE nd_f4(int m)

Line 4544 NODE nd_f4(int m)

continue;

}

if ( bucket->m < 0 ) continue;

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

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

if ( !col ) {

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

NEXT(t) = d; d = l;

Line 4192 NODE nd_f4(int m)

Line 4556 NODE nd_f4(int m)

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

sugar,eg_f4.exectime+eg_f4.gctime);

if ( 1 )

nflist = nd_f4_red(m,l,s0vect,col,rp0);

nflist = nd_f4_red(m,l,0,s0vect,col,rp0,0);

else

nflist = nd_f4_red_dist(m,l,s0vect,col,rp0);

nflist = nd_f4_red_dist(m,l,s0vect,col,rp0,0);

/* adding new bases */

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

nf = (NDV)BDY(r);

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

g = update_base(g,nh);

Line 4211 NODE nd_f4(int m)

Line 4583 NODE nd_f4(int m)

return g;

}

NODE nd_f4_red(int m,ND_pairs sp0,UINT *s0vect,int col,NODE rp0)

NODE nd_f4_trace(int m)

{

int i,nh,stat,index;

NODE r,g;

ND_pairs d,l,l0,t;

ND spol,red;

NDV nf,redv,nfqv,nfv;

NM s0,s;

NODE rp0,srp0,nflist;

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;

g = 0; d = 0;

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

d = update_pairs(d,g,i);

g = update_base(g,i);

}

while ( d ) {

get_eg(&eg0);

l = nd_minsugarp(d,&d);

sugar = SG(l);

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(1,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(1,d);

continue;

}

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

if ( DP_Print )

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

sugar,eg_f4.exectime+eg_f4.gctime);

nflist = nd_f4_red(m,l,0,s0vect,col,rp0,&l0);

if ( !l0 ) continue;

l = l0;

/* over Q */

bucket = create_pbucket();

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

if ( !stat ) {

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

NEXT(t) = d; d = l;

d = nd_reconstruct(1,d);

continue;

}

if ( bucket->m < 0 ) continue;

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

if ( !col ) {

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

NEXT(t) = d; d = l;

d = nd_reconstruct(1,d);

continue;

}

nflist = nd_f4_red(0,l,1,s0vect,col,rp0,0);

/* adding new bases */

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

nfqv = (NDV)BDY(r);

ndv_removecont(0,nfqv);

if ( !rem(NM(HCQ(nfqv)),m) ) return 0;

if ( nd_nalg ) {

ND nf1;

nf1 = ndvtond(m,nfqv);

nd_monic(0,&nf1);

nd_removecont(0,nf1);

nfqv = ndtondv(0,nf1); nd_free(nf1);

}

nfv = ndv_dup(0,nfqv);

ndv_mod(m,nfv);

ndv_removecont(m,nfv);

nh = ndv_newps(0,nfv,nfqv);

d = update_pairs(d,g,nh);

g = update_base(g,nh);

}

for ( r = g; r; r = NEXT(r) ) BDY(r) = (pointer)nd_ps_trace[(int)BDY(r)];

#if 0

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

#endif

return g;

}

NODE nd_f4_red(int m,ND_pairs sp0,int trace,UINT *s0vect,int col,NODE rp0,ND_pairs *nz)

{

IndArray *imat;

int nsp,nred,i;

int *rhead;

NODE r0,rp;

Line 4234 NODE nd_f4_red(int m,ND_pairs sp0,UINT *s0vect,int col

Line 4706 NODE nd_f4_red(int m,ND_pairs sp0,UINT *s0vect,int col

rhead[imat[i]->head] = 1;

}

if ( m )

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

r0 = nd_f4_red_main(m,sp0,nsp,s0vect,col,rvect,rhead,imat,nred,nz);

else

r0 = nd_f4_red_z_main(sp0,nsp,s0vect,col,rvect,rhead,imat,nred);

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

return r0;

}

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

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

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

{

int spcol,sprow,a;

int i,j,k,l,rank;

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

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

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

int maxrs;

int *spsugar;

ND_pairs *spactive;

spcol = col-nred;

get_eg(&eg0);

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

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

spmat = (int **)ALLOCA(nsp*sizeof(UINT *));

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

spsugar = (int *)ALLOCA(nsp*sizeof(UINT));

spactive = !nz?0:(ND_pairs *)ALLOCA(nsp*sizeof(ND_pairs));

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

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

if ( !spol ) continue;

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

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

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

if ( !rhead[j] ) v[k++] = svect[j];

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

if ( nz )

spactive[sprow] = sp;

sprow++;

}

nd_free(spol);

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

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

if ( m == -1 )

rank = nd_gauss_elim_sf(spmat,spsugar,sprow,spcol,m,colstat);

else

rank = nd_gauss_elim_mod(spmat,spsugar,sprow,spcol,m,colstat);

rank = nd_gauss_elim_mod(spmat,spsugar,spactive,sprow,spcol,m,colstat);

r0 = 0;

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

NEXTNODE(r0,r); BDY(r) =

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

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

GC_free(spmat[i]);

}

if ( r0 ) NEXT(r) = 0;

for ( ; i < sprow; i++ ) GC_free(spmat[i]);

get_eg(&eg2); init_eg(&eg_f4_2); add_eg(&eg_f4_2,&eg1,&eg2);

init_eg(&eg_f4); add_eg(&eg_f4,&eg0,&eg2);

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

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

nsp,nred,sprow,spcol,rank);

fprintf(asir_out,"%fsec\n",eg_f4.exectime+eg_f4.gctime);

}

if ( nz ) {

for ( i = 0; i < rank-1; i++ ) NEXT(spactive[i]) = spactive[i+1];

if ( rank > 0 ) {

NEXT(spactive[rank-1]) = 0;

*nz = spactive[0];

} else

*nz = 0;

}

return r0;

}

NODE nd_f4_red_z_main(ND_pairs sp0,int nsp,UINT *s0vect,int col,

#if 1

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

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

{

int spcol,sprow,a;

Line 4321 NODE nd_f4_red_z_main(ND_pairs sp0,int nsp,UINT *s0vec

Line 4807 NODE nd_f4_red_z_main(ND_pairs sp0,int nsp,UINT *s0vec

NODE r0,r;

ND_pairs sp;

ND spol;

Z **spmat;

Q **spmat;

Z *svect,*v;

Q *svect,*v;

int *colstat;

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

int maxrs;

Line 4331 NODE nd_f4_red_z_main(ND_pairs sp0,int nsp,UINT *s0vec

Line 4817 NODE nd_f4_red_z_main(ND_pairs sp0,int nsp,UINT *s0vec

spcol = col-nred;

get_eg(&eg0);

/* elimination (1st step) */

spmat = (Z **)ALLOCA(nsp*sizeof(Z *));

spmat = (Q **)ALLOCA(nsp*sizeof(Q *));

svect = (Z *)ALLOCA(col*sizeof(Z));

svect = (Q *)ALLOCA(col*sizeof(Q));

spsugar = (int *)ALLOCA(nsp*sizeof(Z));

spsugar = (int *)ALLOCA(nsp*sizeof(Q));

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

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

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

if ( !spol ) continue;

nd_to_vect_z(s0vect,col,spol,svect);

nd_to_vect_q(s0vect,col,spol,svect);

maxrs = ndv_reduce_vect_z(svect,col,imat,rvect,nred);

maxrs = ndv_reduce_vect_q(svect,trace,col,imat,rvect,nred);

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

if ( i < col ) {

spmat[sprow] = v = (Z *)MALLOC(spcol*sizeof(Z));

spmat[sprow] = v = (Q *)MALLOC(spcol*sizeof(Q));

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

if ( !rhead[j] ) v[k++] = svect[j];

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

Line 4359 NODE nd_f4_red_z_main(ND_pairs sp0,int nsp,UINT *s0vec

Line 4845 NODE nd_f4_red_z_main(ND_pairs sp0,int nsp,UINT *s0vec

/* elimination (2nd step) */

colstat = (int *)ALLOCA(spcol*sizeof(int));

rank = nd_gauss_elim_z(spmat,spsugar,sprow,spcol,colstat);

rank = nd_gauss_elim_q(spmat,spsugar,sprow,spcol,colstat);

r0 = 0;

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

NEXTNODE(r0,r); BDY(r) =

(pointer)vect_to_ndv_z(spmat[i],spcol,col,rhead,s0vect);

(pointer)vect_to_ndv_q(spmat[i],spcol,col,rhead,s0vect);

SG((NDV)BDY(r)) = spsugar[i];

/* GC_free(spmat[i]); */

}

Line 4380 NODE nd_f4_red_z_main(ND_pairs sp0,int nsp,UINT *s0vec

Line 4866 NODE nd_f4_red_z_main(ND_pairs sp0,int nsp,UINT *s0vec

}

return r0;

}

#else

void printm(Q **mat,int row,int col)

{

int i,j;

printf("[");

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

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

printexpr(CO,mat[i][j]); printf(" ");

}

printf("]\n");

}

NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,UINT *s0vect,int col,

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

{

int row,a;

int i,j,rank;

NODE r0,r;

ND_pairs sp;

ND spol;

Q **mat;

int *colstat;

int *sugar;

row = nsp+nred;

/* make the matrix */

mat = (Q **)ALLOCA(row*sizeof(Q *));

sugar = (int *)ALLOCA(row*sizeof(int));

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

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

if ( !spol ) continue;

mat[row] = (Q *)MALLOC(col*sizeof(Q));

nd_to_vect_q(s0vect,col,spol,mat[row]);

sugar[row] = SG(spol);

row++;

}

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

mat[row] = nm_ind_pair_to_vect(0,s0vect,col,rvect[i]);

sugar[row] = rvect[i]->sugar;

}

/* elimination */

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

rank = nd_gauss_elim_q(mat,sugar,row,col,colstat);

r0 = 0;

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

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

if ( j == col ) error("nd_f4_red_q_main : cannot happen");

if ( rhead[j] ) continue;

NEXTNODE(r0,r); BDY(r) =

(pointer)plain_vect_to_ndv_q(mat[i],col,s0vect);

SG((NDV)BDY(r)) = sugar[i];

}

if ( r0 ) NEXT(r) = 0;

printf("\n");

return r0;

}

#endif

FILE *nd_write,*nd_read;

void nd_send_int(int a) {

Line 4474 int ox_exec_f4_red(Q proc)

Line 5018 int ox_exec_f4_red(Q proc)

return s;

}

NODE nd_f4_red_dist(int m,ND_pairs sp0,UINT *s0vect,int col,NODE rp0)

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

{

int nsp,nred;

int i,rank,s;

Line 4628 void nd_exec_f4_red_dist()

Line 5172 void nd_exec_f4_red_dist()

if ( m == -1 )

rank = nd_gauss_elim_sf(spmat,spsugar,sprow,spcol,m,colstat);

else

rank = nd_gauss_elim_mod(spmat,spsugar,sprow,spcol,m,colstat);

rank = nd_gauss_elim_mod(spmat,spsugar,0,sprow,spcol,m,colstat);

nd_send_int(rank);

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

nf = vect_to_ndv(spmat[i],spcol,col,rhead,s0vect);

Line 4637 void nd_exec_f4_red_dist()

Line 5181 void nd_exec_f4_red_dist()

fflush(nd_write);

}

/* XXX */

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

int generic_gauss_elim_z(MAT m,MAT *nm,Z *dn,int **ri,int **ci)

{}

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

{

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

int *ci,*ri;

Z dn;

Q dn;

MAT m,nm;

int **wmat;

Line 4655 int nd_gauss_elim_z(Z **mat0,int *sugar,int row,int co

Line 5195 int nd_gauss_elim_z(Z **mat0,int *sugar,int row,int co

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

wmat[i] = (int *)ALLOCA(col*sizeof(int));

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

if ( mat0[i][j] )

if ( mat0[i][j] ) {

wmat[i][j] = remzi(mat0[i][j],mod);

t = rem(NM(mat0[i][j]),mod);

else

if ( SGN(mat0[i][j]) < 0 ) t = mod-t;

wmat[i][j] = t;

} else

wmat[i][j] = 0;

}

rank0 = nd_gauss_elim_mod(wmat,sugar,row,col,mod,colstat);

rank0 = nd_gauss_elim_mod(wmat,sugar,0,row,col,mod,colstat);

NEWMAT(m); m->row = row; m->col = col; m->body = (pointer **)mat0;

rank = generic_gauss_elim_z(m,&nm,&dn,&ri,&ci);

rank = generic_gauss_elim(m,&nm,&dn,&ri,&ci);

if ( rank != rank0 )

error("afo");

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

Line 4671 int nd_gauss_elim_z(Z **mat0,int *sugar,int row,int co

Line 5213 int nd_gauss_elim_z(Z **mat0,int *sugar,int row,int co

mat0[i][j] = 0;

c = col-rank;

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

mat0[i][ri[i]] = dn;

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

mat0[i][ci[j]] = (Z)BDY(nm)[i][j];

mat0[i][ci[j]] = (Q)BDY(nm)[i][j];

}

inv = invm(remzi(dn,mod),mod);

inv = invm(rem(NM(dn),mod),mod);

if ( SGN(dn) < 0 ) inv = mod-inv;

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

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

if ( mat0[i][j] )

if ( mat0[i][j] ) {

t = remzi(mat0[i][j],mod);

t = rem(NM(mat0[i][j]),mod);

else

if ( SGN(mat0[i][j]) < 0 ) t = mod-t;

} else

t = 0;

c = dmar(t,inv,0,mod);

if ( wmat[i][j] != c )

Line 4689 int nd_gauss_elim_z(Z **mat0,int *sugar,int row,int co

Line 5233 int nd_gauss_elim_z(Z **mat0,int *sugar,int row,int co

return rank;

}

int nd_gauss_elim_mod(int **mat0,int *sugar,int row,int col,int md,int *colstat)

int nd_gauss_elim_mod(int **mat0,int *sugar,ND_pairs *spactive,int row,int col,int md,int *colstat)

{

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

unsigned int *t,*pivot,*pk;

unsigned int **mat;

ND_pairs pair;

mat = (unsigned int **)mat0;

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

Line 4710 int nd_gauss_elim_mod(int **mat0,int *sugar,int row,in

Line 5255 int nd_gauss_elim_mod(int **mat0,int *sugar,int row,in

if ( i != rank ) {

t = mat[i]; mat[i] = mat[rank]; mat[rank] = t;

s = sugar[i]; sugar[i] = sugar[rank]; sugar[rank] = s;

if ( spactive ) {

pair = spactive[i]; spactive[i] = spactive[rank];

spactive[rank] = pair;

}

pivot = mat[rank];

s = sugar[rank];

Line 4844 void ndv_save(NDV p,int index)

Line 5393 void ndv_save(NDV p,int index)

write_int(s,&len);

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

saveobj(s,(Obj)ztoq(CZ(m)));

saveobj(s,(Obj)CQ(m));

dl = DL(m);

td = TD(dl);

write_int(s,&td);

Line 4880 NDV ndv_load(int index)

Line 5429 NDV ndv_load(int index)

m0 = m = MALLOC(len*nmv_adv);

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

loadobj(s,&obj); CZ(m) = qtoz((Q)obj);

loadobj(s,&obj); CQ(m) = (Q)obj;

dl = DL(m);

ndl_zero(dl);

read_int(s,&td); TD(dl) = td;

Line 4901 void nd_det(int mod,MAT f,P *rp)

Line 5450 void nd_det(int mod,MAT f,P *rp)

VL fv,tv;

int n,i,j,max,e,nvar,sgn,k0,l0,len0,len,k,l,a;

pointer **m;

Z mone;

Q mone;

P **w;

P mp,r;

NDV **dm;

NDV *t,*mi,*mj;

NDV d,s,mij,mjj;

ND u;

NMV nmv;

UINT *bound;

PGeoBucket bucket;

struct order_spec *ord;

Q dq,dt,ds;

N gn,qn,dn0,nm,dn;

create_order_spec(0,0,&ord);

nd_init_ord(ord);

Line 4916 void nd_det(int mod,MAT f,P *rp)

Line 5470 void nd_det(int mod,MAT f,P *rp)

if ( f->row != f->col )

error("nd_det : non-square matrix");

n = f->row;

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

m = f->body;

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

if ( !nvar ) {

if ( !mod )

detp(CO,(P **)m,n,rp);

else {

w = (P **)almat_pointer(n,n);

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

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

ptomp(mod,(P)m[i][j],&w[i][j]);

detmp(CO,mod,w,n,&mp);

mptop(mp,rp);

}

return;

}

if ( !mod ) {

w = (P **)almat_pointer(n,n);

dq = ONE;

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

dn0 = ONEN;

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

if ( !m[i][j] ) continue;

lgp(m[i][j],&nm,&dn);

gcdn(dn0,dn,&gn); divsn(dn0,gn,&qn); muln(qn,dn,&dn0);

}

if ( !UNIN(dn0) ) {

NTOQ(dn0,1,ds);

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

mulp(CO,(P)m[i][j],(P)ds,&w[i][j]);

mulq(dq,ds,&dt); dq = dt;

} else

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

w[i][j] = (P)m[i][j];

}

m = (pointer **)w;

}

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

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

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

e = getdeg(tv->v,(P)m[i][j]);

max = MAX(e,max);

}

nd_setup_parameters(nvar,1024);

nd_setup_parameters(nvar,max);

dm = (NDV **)almat_pointer(n,n);

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

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

Line 4934 void nd_det(int mod,MAT f,P *rp)

Line 5525 void nd_det(int mod,MAT f,P *rp)

}

d = ptondv(CO,fv,(P)ONE);

if ( mod ) ndv_mod(mod,d);

mone = chsgnz(qtoz(ONE));

chsgnq(ONE,&mone);

for ( j = 0, sgn = 1; j < n; j++ ) {

if ( DP_Print ) fprintf(stderr,"j=%d\n",j);

if ( DP_Print ) fprintf(stderr,".",j);

for ( i = j; i < n && !dm[i][j]; i++ );

if ( i == n ) {

*rp = 0;

Line 4958 void nd_det(int mod,MAT f,P *rp)

Line 5549 void nd_det(int mod,MAT f,P *rp)

}

sgn = -sgn;

}

bound = nd_det_compute_bound(dm,n,j);

if ( ndl_check_bound(bound,bound) )

nd_det_reconstruct(dm,n,j,d);

for ( i = j+1, mj = dm[j], mjj = mj[j]; i < n; i++ ) {

if ( DP_Print ) fprintf(stderr," i=%d\n ",i);

/* if ( DP_Print ) fprintf(stderr," i=%d\n ",i); */

mi = dm[i]; mij = mi[j];

if ( mod )

ndv_mul_c(mod,mij,mod-1);

else

ndv_mul_c_z(mij,mone);

ndv_mul_c_q(mij,mone);

for ( k = j+1; k < n; k++ ) {

if ( DP_Print ) fprintf(stderr,"k=%d ",k);

/* if ( DP_Print ) fprintf(stderr,"k=%d ",k); */

bucket = create_pbucket();

if ( mi[k] ) {

nmv = BDY(mjj); len = LEN(mjj);

Line 4985 void nd_det(int mod,MAT f,P *rp)

Line 5580 void nd_det(int mod,MAT f,P *rp)

u = nd_quo(mod,bucket,d);

mi[k] = ndtondv(mod,u);

}

if ( DP_Print ) fprintf(stderr,"\n",k);

/* if ( DP_Print ) fprintf(stderr,"\n",k); */

}

d = mjj;

}

if ( DP_Print ) fprintf(stderr,"\n",k);

if ( sgn < 0 )

if ( mod )

ndv_mul_c(mod,d,mod-1);

else

ndv_mul_c_z(d,mone);

ndv_mul_c_q(d,mone);

*rp = ndvtop(mod,CO,fv,d);

r = ndvtop(mod,CO,fv,d);

if ( !mod && !UNIQ(dq) )

divsp(CO,r,(P)dq,rp);

else

*rp = r;

}

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

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

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

NMV m;

UINT *d0,*dt,*dm;

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

Z q;

Q q;

ND r;

if ( !p ) return 0;

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

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

}

} else {

q = CZ(m0);

q = CQ(m0);

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

ndl_add(DL(m),d0,DL(tnm));

if ( ndl_reducible(DL(tnm),d) ) {

NEXTNM(mr0,mr);

CZ(mr) = mulz(CZ(m),q);

mulq(CQ(m),q,&CQ(mr));

ndl_copy(DL(tnm),DL(mr));

}

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

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

return r;

}

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

{

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

static NM prev_nm_free_list;

EPOS oepos;

obpe = nd_bpe;

oadv = nmv_adv;

oepos = nd_epos;

if ( obpe < 2 ) nd_bpe = 2;

else if ( obpe < 3 ) nd_bpe = 3;

else if ( obpe < 4 ) nd_bpe = 4;

else if ( obpe < 5 ) nd_bpe = 5;

else if ( obpe < 6 ) nd_bpe = 6;

else if ( obpe < 8 ) nd_bpe = 8;

else if ( obpe < 10 ) nd_bpe = 10;

else if ( obpe < 16 ) nd_bpe = 16;

else if ( obpe < 32 ) nd_bpe = 32;

else error("nd_det_reconstruct : exponent too large");

nd_setup_parameters(nd_nvar,0);

prev_nm_free_list = _nm_free_list;

_nm_free_list = 0;

for ( k = j; k < n; k++ )

for (l = j; l < n; l++ )

ndv_realloc(dm[k][l],obpe,oadv,oepos);

ndv_realloc(d,obpe,oadv,oepos);

prev_nm_free_list = 0;

#if 0

GC_gcollect();

#endif

}

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

{

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

int k,l;

d0 = (UINT *)ALLOCA(nd_wpd*sizeof(UINT));

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

for ( k = 0; k < nd_wpd; k++ ) d0[k] = 0;

for ( k = j; k < n; k++ )

for ( l = j; l < n; l++ )

if ( dm[k][l] ) {

d = ndv_compute_bound(dm[k][l]);

ndl_lcm(d,d0,d1);

t = d1; d1 = d0; d0 = t;

}

r = (UINT *)ALLOCA(nd_wpd*sizeof(UINT));

for ( k = 0; k < nd_wpd; k++ ) r[k] = d0[k];

return r;

}

DL nd_separate_d(UINT *d,UINT *trans)

{

int n,td,i,e,j;

DL a;

ndl_zero(trans);

td = 0;

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

e = GET_EXP(d,i);

PUT_EXP(trans,i,e);

td += MUL_WEIGHT(e,i);

}

if ( nd_ntrans+nd_nalg < nd_nvar ) {

/* homogenized */

i = nd_nvar-1;

e = GET_EXP(d,i);

PUT_EXP(trans,i,e);

td += MUL_WEIGHT(e,i);

}

TD(trans) = td;

if ( nd_blockmask) ndl_weight_mask(trans);

NEWDL(a,nd_nalg);

td = 0;

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

j = nd_ntrans+i;

e = GET_EXP(d,j);

a->d[i] = e;

td += e;

}

a->td = td;

return a;

}

int nd_monic(int mod,ND *p)

{

UINT *trans,*t;

DL alg;

MP mp0,mp;

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

ND r;

DL dl;

DP nm;

NDV ndv;

DAlg inv,cd;

ND s,c;

Q l,mul;

N ln;

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

NumberField nf;

struct oEGT eg0,eg1;

if ( !(nf = get_numberfield()) )

error("nd_monic : current_numberfield is not set");

/* Q coef -> DAlg coef */

NEWNM(ma0); ma = ma0;

m = BDY(*p);

is_lc = 1;

while ( 1 ) {

NEWMP(mp0); mp = mp0;

mp->c = (P)CQ(m);

mp->dl = nd_separate_d(DL(m),DL(ma));

NEWNM(mb);

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

alg = nd_separate_d(DL(m),DL(mb));

if ( !ndl_equal(DL(ma),DL(mb)) )

break;

NEXTMP(mp0,mp); mp->c = (P)CQ(m); mp->dl = alg;

}

NEXT(mp) = 0;

MKDP(nd_nalg,mp0,nm);

MKDAlg(nm,ONE,cd);

if ( is_lc == 1 ) {

/* if the lc is a rational number, we have nothing to do */

if ( !mp0->dl->td )

return 1;

get_eg(&eg0);

invdalg(cd,&inv);

get_eg(&eg1); add_eg(&eg_invdalg,&eg0,&eg1);

/* check the validity of inv */

if ( mod && !rem(NM(inv->dn),mod) )

return 0;

CA(ma) = nf->one;

is_lc = 0;

ln = ONEN;

} else {

muldalg(cd,inv,&CA(ma));

lcmn(ln,NM(CA(ma)->dn),&ln);

}

if ( m ) {

NEXT(ma) = mb; ma = mb;

} else {

NEXT(ma) = 0;

break;

}

/* l = lcm(denoms) */

NTOQ(ln,1,l);

for ( mr0 = 0, m = ma0; m; m = NEXT(m) ) {

divq(l,CA(m)->dn,&mul);

for ( mp = BDY(CA(m)->nm); mp; mp = NEXT(mp) ) {

NEXTNM(mr0,mr);

mulq((Q)mp->c,mul,&CQ(mr));

dl = mp->dl;

td = TD(DL(m));

ndl_copy(DL(m),DL(mr));

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

e = dl->d[i];

PUT_EXP(DL(mr),i+nd_ntrans,e);

td += MUL_WEIGHT(e,i+nd_ntrans);

}

TD(DL(mr)) = td;

if ( nd_blockmask) ndl_weight_mask(DL(mr));

}

NEXT(mr) = 0;

for ( len = 0, mr = mr0; mr; mr = NEXT(mr), len++ );

MKND(NV(*p),mr0,len,r);

/* XXX */

SG(r) = SG(*p);

nd_free(*p);

*p = r;

return 1;

}

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