version 1.4, 2001/06/25 01:35:21 |
version 1.8, 2001/06/25 10:01:28 |
|
|
/* $OpenXM: OpenXM_contrib2/asir2000/engine/Hgfs.c,v 1.3 2001/06/22 08:51:12 noro Exp $ */ |
/* $OpenXM: OpenXM_contrib2/asir2000/engine/Hgfs.c,v 1.7 2001/06/25 06:10:48 noro Exp $ */ |
|
|
#include "ca.h" |
#include "ca.h" |
|
|
Line 13 void lnfsf(int,UM,UM,struct p_pair *,UM,UM); |
|
Line 13 void lnfsf(int,UM,UM,struct p_pair *,UM,UM); |
|
void minipolysf(UM,UM,UM); |
void minipolysf(UM,UM,UM); |
void czsfum(UM,UM *); |
void czsfum(UM,UM *); |
void gensqfrsfum(UM,DUM); |
void gensqfrsfum(UM,DUM); |
|
void sfbmtop(int,BM,V,V,P *); |
|
void pp_sfp(VL,P,P *); |
|
void sfcsump(VL,P,P *); |
|
void mulsfbmarray(int,BM,ML,int,int *,V,V,P *); |
|
|
void fctrsf(p,dcp) |
void fctrsf(p,dcp) |
P p; |
P p; |
Line 534 int sfberle(VL,P,int,GFS *,DCP *); |
|
Line 538 int sfberle(VL,P,int,GFS *,DCP *); |
|
void sfgcdgen(P,ML,ML *); |
void sfgcdgen(P,ML,ML *); |
void sfhenmain(LUM,ML,ML,ML *); |
void sfhenmain(LUM,ML,ML,ML *); |
void ptosflum(int,P,LUM); |
void ptosflum(int,P,LUM); |
void sfhenmain2(LUM,UM,UM,int,LUM *); |
void sfhenmain2(BM,UM,UM,int,BM *); |
|
void ptosfbm(int,P,BM); |
|
|
/* f = f(x,y) */ |
/* f = f(x,y) */ |
|
|
void sfhensel(count,f,x,listp) |
void sfhensel(count,f,x,evp,sfp,listp) |
int count; |
int count; |
P f; |
P f; |
V x; |
V x; |
|
GFS *evp; |
|
P *sfp; |
ML *listp; |
ML *listp; |
{ |
{ |
int i,j; |
int i,j; |
int fn,n,bound; |
int fn,n,bound; |
ML rlist; |
ML rlist; |
LUM fl; |
BM fl; |
VL vl,nvl; |
VL vl,nvl; |
V y; |
V y; |
int dx,dy,mev; |
int dx,dy,mev; |
GFS ev; |
GFS ev; |
P f1,t,yev,c; |
P f1,t,yev,c,sf; |
DCP dc; |
DCP dc; |
LUM gl; |
|
UM w,w1,q,fm,hm; |
UM w,w1,q,fm,hm; |
UM *gm; |
UM *gm; |
|
|
|
|
|
|
bound = dy+1; |
bound = dy+1; |
/* f(x,y) -> f(x,y+ev) */ |
/* f(x,y) -> f(x,y+ev) */ |
fl = LUMALLOC(dx,bound); |
fl = BMALLOC(dx,bound); |
ptosflum(bound,f,fl); |
ptosfbm(bound,f,fl); |
shiftsflum(bound,fl,FTOIF(CONT(ev))); |
shiftsfbm(bound,fl,FTOIF(CONT(ev))); |
|
|
|
/* sf = f(x+ev) */ |
|
sfbmtop(bound,fl,x,y,&sf); |
|
|
/* fm = fl mod y */ |
/* fm = fl mod y */ |
fm = W_UMALLOC(dx); |
fm = W_UMALLOC(dx); |
DEG(fm) = dx; |
cpyum(COEF(fl)[0],fm); |
for ( i = 0; i <= dx; i++ ) |
|
COEF(fm)[i] = COEF(fl)[i][0]; |
|
hm = W_UMALLOC(dx); |
hm = W_UMALLOC(dx); |
|
|
q = W_UMALLOC(dx); |
q = W_UMALLOC(dx); |
|
|
divsfum(fm,gm[i],hm); |
divsfum(fm,gm[i],hm); |
/* fl is replaced by the cofactor of gk mod y^bound */ |
/* fl is replaced by the cofactor of gk mod y^bound */ |
/* rlist->c[i] = gk */ |
/* rlist->c[i] = gk */ |
sfhenmain2(fl,gm[i],hm,bound,(LUM *)&rlist->c[i]); |
sfhenmain2(fl,gm[i],hm,bound,(BM *)&rlist->c[i]); |
cpyum(hm,fm); |
cpyum(hm,fm); |
} |
} |
/* finally, fl must be the lift of gm[fn-1] */ |
/* finally, fl must be the lift of gm[fn-1] */ |
rlist->c[i] = fl; |
rlist->c[i] = fl; |
|
|
|
#if 0 |
/* y -> y-a */ |
/* y -> y-a */ |
w = W_UMALLOC(bound); |
|
w1 = W_UMALLOC(bound); |
|
mev = _chsgnsf(FTOIF(CONT(ev))); |
mev = _chsgnsf(FTOIF(CONT(ev))); |
for ( i = 0; i < fn; i++ ) |
for ( i = 0; i < fn; i++ ) |
shiftsflum(bound,(LUM)(rlist->c[i]),mev); |
shiftsfbm(bound,(BM)(rlist->c[i]),mev); |
|
#endif |
|
*evp = ev; |
|
*sfp = sf; |
*listp = rlist; |
*listp = rlist; |
} |
} |
|
|
Line 747 ML bqlist,cqlist,*listp; |
|
Line 756 ML bqlist,cqlist,*listp; |
|
mulsflum(i+1,l[j],wb0,wb1); |
mulsflum(i+1,l[j],wb0,wb1); |
tlum = wb0; wb0 = wb1; wb1 = tlum; |
tlum = wb0; wb0 = wb1; wb1 = tlum; |
} |
} |
#if 1 |
#if 0 |
/* check */ |
/* check */ |
for ( j = 0, pp = COEF(f), pp1 = COEF(wb0); j <= n; j++ ) |
for ( j = 0, pp = COEF(f), pp1 = COEF(wb0); j <= n; j++ ) |
for ( k = 0; k < i; k++ ) |
for ( k = 0; k < i; k++ ) |
Line 781 ML bqlist,cqlist,*listp; |
|
Line 790 ML bqlist,cqlist,*listp; |
|
/* f = g0*h0 mod y -> f = gk*hk mod y^bound, f is replaced by hk */ |
/* f = g0*h0 mod y -> f = gk*hk mod y^bound, f is replaced by hk */ |
|
|
void sfhenmain2(f,g0,h0,bound,gp) |
void sfhenmain2(f,g0,h0,bound,gp) |
LUM f; |
BM f; |
UM g0,h0; |
UM g0,h0; |
int bound; |
int bound; |
LUM *gp; |
BM *gp; |
{ |
{ |
int i,j,k,l; |
int i,j,k,l; |
int *px,*py; |
int *px,*py; |
int **pp,**pp1; |
int **pp,**pp1; |
int n,np,dr,tmp; |
int n,np,dr,tmp; |
UM wt,wa,wb,wq,wm,q,w1,w2,wh1,wg1; |
UM wt,wa,wb,wq,wm,q,w1,w2,wh1,wg1,ws; |
UM wc,wd,we,wz; |
UM wc,wd,we,wz; |
LUM wb0,wb1; |
BM wb0,wb1; |
int ng,nh; |
int ng,nh; |
LUM fk,gk,hk; |
BM fk,gk,hk; |
|
|
n = f->d; |
n = degsfbm(bound,f); |
ng = g0->d; |
ng = g0->d; |
nh = h0->d; |
nh = h0->d; |
|
|
W_LUMALLOC(n,bound,wb0); W_LUMALLOC(n,bound,wb1); |
W_BMALLOC(n,bound,wb0); W_BMALLOC(n,bound,wb1); |
wt = W_UMALLOC(n); wq = W_UMALLOC(n); q = W_UMALLOC(2*n); |
wt = W_UMALLOC(n); ws = W_UMALLOC(n); |
|
wq = W_UMALLOC(n); q = W_UMALLOC(2*n); |
wg1 = W_UMALLOC(2*n); wh1 = W_UMALLOC(2*n); |
wg1 = W_UMALLOC(2*n); wh1 = W_UMALLOC(2*n); |
|
|
/* fk = gk*hk mod y^k */ |
/* fk = gk*hk mod y^k */ |
W_LUMALLOC(n,bound,fk); |
W_BMALLOC(n,bound,fk); |
DEG(fk) = n; |
cpyum(COEF(f)[0],COEF(fk)[0]); |
for ( j = 0; j <= n; j++ ) |
gk = BMALLOC(ng,bound); |
COEF(fk)[j][0] = COEF(f)[j][0]; |
cpyum(g0,COEF(gk)[0]); |
|
W_BMALLOC(nh,bound,hk); |
|
cpyum(h0,COEF(hk)[0]); |
|
|
gk = LUMALLOC(ng,bound); |
wc = W_UMALLOC(2*n); wd = W_UMALLOC(2*n); |
DEG(gk) = ng; |
we = W_UMALLOC(2*n); wz = W_UMALLOC(2*n); |
for ( j = 0; j <= ng; j++ ) |
|
COEF(gk)[j][0] = COEF(g0)[j]; |
|
|
|
W_LUMALLOC(nh,bound,hk); |
|
DEG(hk) = nh; |
|
for ( j = 0; j <= nh; j++ ) |
|
COEF(hk)[j][0] = COEF(h0)[j]; |
|
|
|
wc = W_UMALLOC(2*n); wd = W_UMALLOC(2*n); we = W_UMALLOC(2*n); wz = W_UMALLOC(2*n); |
|
|
|
/* compute wa,wb s.t. wa*g0+wb*h0 = 1 mod y */ |
/* compute wa,wb s.t. wa*g0+wb*h0 = 1 mod y */ |
w1 = W_UMALLOC(ng); cpyum(g0,w1); |
w1 = W_UMALLOC(ng); cpyum(g0,w1); |
w2 = W_UMALLOC(nh); cpyum(h0,w2); |
w2 = W_UMALLOC(nh); cpyum(h0,w2); |
|
|
#if 0 |
#if 0 |
mulsfum(wa,g0,wc); mulsfum(wb,h0,wd); addsfum(wc,wd,we); |
mulsfum(wa,g0,wc); mulsfum(wb,h0,wd); addsfum(wc,wd,we); |
if ( DEG(we) != 0 || COEF(we)[0] != _onesf() ) |
if ( DEG(we) != 0 || COEF(we)[0] != _onesf() ) |
error("henmain2 : cannot happen"); |
error("henmain2 : cannot happen(euc)"); |
#endif |
#endif |
|
|
fprintf(stderr,"bound=%d\n",bound); |
fprintf(stderr,"bound=%d\n",bound); |
|
|
|
|
/* at this point, f = gk*hk mod y^k */ |
/* at this point, f = gk*hk mod y^k */ |
#if 0 |
#if 0 |
for ( j = 0, pp = COEF(f), pp1 = COEF(fk); j <= n; j++ ) |
for ( j = 0; j < k; j++ ) |
for ( l = 0; l < k; l++ ) |
if ( !isequalum(COEF(f)[j],COEF(fk)[j]) ) |
if ( pp[j][l] != pp1[j][l] ) |
error("henmain2 : cannot happen(history)"); |
error("henmain2 : cannot happen"); |
|
#endif |
#endif |
|
|
/* clear wt */ |
/* clear wt */ |
bzero(COEF(wt),(n+1)*sizeof(int)); |
bzero(COEF(wt),(n+1)*sizeof(int)); |
|
|
/* wt = (f-gk*hk)/y^k */ |
/* wt = (f-gk*hk)/y^k */ |
pp = COEF(f); pp1 = COEF(fk); |
subsfum(COEF(f)[k],COEF(fk)[k],wt); |
for ( j = n; j >= 0; j-- ) |
|
COEF(wt)[j] = _subsf(pp[j][k],pp1[j][k]); |
|
degum(wt,n); |
|
|
|
/* clear wq */ |
/* clear wq */ |
bzero(COEF(wq),(n+1)*sizeof(int)); |
bzero(COEF(wq),(n+1)*sizeof(int)); |
|
|
/* check */ |
/* check */ |
#if 0 |
#if 0 |
if ( DEG(wd) >= 0 || DEG(wg1) > ng ) |
if ( DEG(wd) >= 0 || DEG(wg1) > ng ) |
error("henmain2 : cannot happen"); |
error("henmain2 : cannot happen(adj)"); |
|
|
mulsfum(wg1,h0,wc); mulsfum(wh1,g0,wd); addsfum(wc,wd,we); |
mulsfum(wg1,h0,wc); mulsfum(wh1,g0,wd); addsfum(wc,wd,we); |
subsfum(we,wt,wz); |
subsfum(we,wt,wz); |
|
|
|
|
/* fk += ((wg1*hk+wh1*gk)*y^k+wg1*wh1*y^(2*k) mod y^bound */ |
/* fk += ((wg1*hk+wh1*gk)*y^k+wg1*wh1*y^(2*k) mod y^bound */ |
/* wb0 = wh1*y^k */ |
/* wb0 = wh1*y^k */ |
clearsflum(bound,n,wb0); |
clearsfbm(bound,n,wb0); |
DEG(wb0) = DEG(wh1); |
DEG(wb0) = bound; |
for ( i = 0; i <= DEG(wh1); i++ ) |
cpyum(wh1,COEF(wb0)[k]); |
COEF(wb0)[i][k] = COEF(wh1)[i]; |
|
/* wb1 = gk*wb0 mod y^bound */ |
/* wb1 = gk*wb0 mod y^bound */ |
clearsflum(bound,n,wb1); |
clearsfbm(bound,n,wb1); |
mulsflum(bound,gk,wb0,wb1); |
mulsfbm(bound,gk,wb0,wb1); |
/* fk += wb1 */ |
/* fk += wb1 */ |
addtosflum(bound,wb1,fk); |
addtosfbm(bound,wb1,fk); |
|
|
/* wb0 = wg1*y^k */ |
/* wb0 = wg1*y^k */ |
clearsflum(bound,n,wb0); |
clearsfbm(bound,n,wb0); |
DEG(wb0) = DEG(wg1); |
DEG(wb0) = bound; |
for ( i = 0; i <= DEG(wg1); i++ ) |
cpyum(wg1,COEF(wb0)[k]); |
COEF(wb0)[i][k] = COEF(wg1)[i]; |
|
/* wb1 = hk*wb0 mod y^bound */ |
/* wb1 = hk*wb0 mod y^bound */ |
clearsflum(bound,n,wb1); |
clearsfbm(bound,n,wb1); |
mulsflum(bound,hk,wb0,wb1); |
mulsfbm(bound,hk,wb0,wb1); |
/* fk += wb1 */ |
/* fk += wb1 */ |
addtosflum(bound,wb1,fk); |
addtosfbm(bound,wb1,fk); |
|
|
/* fk += wg1*wh1*y^(2*k) mod y^bound */ |
/* fk += wg1*wh1*y^(2*k) mod y^bound */ |
if ( 2*k < bound ) { |
if ( 2*k < bound ) { |
mulsfum(wg1,wh1,wt); |
mulsfum(wg1,wh1,wt); addsfum(COEF(fk)[2*k],wt,ws); |
for ( i = 0; i <= DEG(wt); i++ ) |
cpyum(ws,COEF(fk)[2*k]); |
COEF(fk)[i][2*k] = _addsf(COEF(fk)[i][2*k],COEF(wt)[i]); |
|
} |
} |
|
|
/* gk += wg1*y^k, hk += wh1*y^k */ |
/* gk += wg1*y^k, hk += wh1*y^k */ |
for ( i = 0; i <= DEG(wg1); i++ ) |
cpyum(wg1,COEF(gk)[k]); |
COEF(gk)[i][k] = COEF(wg1)[i]; |
cpyum(wh1,COEF(hk)[k]); |
for ( i = 0; i <= DEG(wh1); i++ ) |
|
COEF(hk)[i][k] = COEF(wh1)[i]; |
|
} |
} |
fprintf(stderr,"\n"); |
fprintf(stderr,"\n"); |
*gp = gk; |
*gp = gk; |
for ( i = 0; i <= DEG(hk); i++ ) |
DEG(f) = bound; |
for ( j = 0; j <= bound; j++ ) |
for ( i = 0; i < bound; i++ ) |
COEF(f)[i][j] = COEF(hk)[i][j]; |
cpyum(COEF(hk)[i],COEF(f)[i]); |
DEG(f) = DEG(hk); |
|
} |
} |
|
|
void ptosflum(bound,f,fl) |
void ptosflum(bound,f,fl) |
|
|
} |
} |
} |
} |
|
|
|
/* fl->c[i] = coef_y(f,i) */ |
|
|
|
void ptosfbm(bound,f,fl) |
|
int bound; |
|
P f; |
|
BM fl; |
|
{ |
|
DCP dc; |
|
int d,i,n; |
|
UM t; |
|
|
|
DEG(fl) = bound; |
|
t = UMALLOC(bound); |
|
for ( dc = DC(f); dc; dc = NEXT(dc) ) { |
|
d = QTOS(DEG(dc)); |
|
ptosfum(COEF(dc),t); |
|
for ( i = 0; i <= DEG(t); i++ ) |
|
COEF(COEF(fl)[i])[d] = COEF(t)[i]; |
|
} |
|
n = QTOS(DEG(DC(f))); |
|
for ( i = 0; i < bound; i++ ) |
|
degum(COEF(fl)[i],n); |
|
} |
|
|
/* x : main variable */ |
/* x : main variable */ |
|
|
void sflumtop(bound,fl,x,y,fp) |
void sflumtop(bound,fl,x,y,fp) |
|
|
sfumtop(y,w,&COEF(dct)); NEXT(dct) = dc; dc = dct; |
sfumtop(y,w,&COEF(dct)); NEXT(dct) = dc; dc = dct; |
} |
} |
MKP(x,dc,*fp); |
MKP(x,dc,*fp); |
|
} |
|
|
|
/* x : main variable */ |
|
|
|
void sfbmtop(bound,f,x,y,fp) |
|
int bound; |
|
BM f; |
|
V x,y; |
|
P *fp; |
|
{ |
|
UM *c; |
|
int i,j,d,a; |
|
GFS b; |
|
DCP dc0,dc,dct; |
|
|
|
c = COEF(f); |
|
d = DEG(c[0]); |
|
for ( i = 1; i < bound; i++ ) |
|
d = MAX(DEG(c[i]),d); |
|
|
|
dc0 = 0; |
|
for ( i = 0; i <= d; i++ ) { |
|
dc = 0; |
|
for ( j = 0; j < bound; j++ ) { |
|
if ( DEG(c[j]) >= i && (a = COEF(c[j])[i]) ) { |
|
NEWDC(dct); |
|
STOQ(j,DEG(dct)); |
|
MKGFS(IFTOF(a),b); |
|
COEF(dct) = (P)b; |
|
NEXT(dct) = dc; |
|
dc = dct; |
|
} |
|
} |
|
if ( dc ) { |
|
NEWDC(dct); |
|
STOQ(i,DEG(dct)); |
|
MKP(y,dc,COEF(dct)); |
|
NEXT(dct) = dc0; |
|
dc0 = dct; |
|
} |
|
} |
|
if ( dc0 ) |
|
MKP(x,dc0,*fp); |
|
else |
|
*fp = 0; |
|
} |
|
|
|
void sfdtest(P,ML,V,V,DCP *); |
|
|
|
void sfbfctr(f,x,y,evp,dcp) |
|
P f; |
|
V x,y; |
|
GFS *evp; |
|
DCP *dcp; |
|
{ |
|
ML list; |
|
P sf; |
|
|
|
/* sf(x) = f(x+ev) = list->c[0]*list->c[1]*... */ |
|
sfhensel(5,f,x,evp,&sf,&list); |
|
sfdtest(sf,list,x,y,dcp); |
|
} |
|
|
|
/* f = f(x,y) = list->c[0]*list->c[1]*... mod y^list->bound */ |
|
|
|
void sfdtest(f,list,x,y,dcp) |
|
P f; |
|
ML list; |
|
V x,y; |
|
DCP *dcp; |
|
{ |
|
int n,np,bound; |
|
int i,j,k; |
|
int *win; |
|
P g,lcg,factor,cofactor,lcyx; |
|
P csum,csumt; |
|
DCP dcf,dcf0,dc; |
|
BM *c; |
|
BM lcy; |
|
ML wlist; |
|
struct oVL vl1,vl0; |
|
VL vl; |
|
int z; |
|
|
|
/* vl = [x,y] */ |
|
vl0.v = x; vl0.next = &vl1; vl1.v = y; vl1.next = 0; vl = &vl0; |
|
|
|
n = UDEG(f); np = list->n; bound = list->bound; win = W_ALLOC(np+1); |
|
|
|
/* csum = lc(f)*f(1) */ |
|
sfcsump(vl,f,&csum); mulp(vl,csum,COEF(DC(f)),&csumt); csum = csumt; |
|
|
|
wlist = W_MLALLOC(np); wlist->n = list->n; |
|
wlist->bound = list->bound; |
|
c = (BM *)COEF(wlist); |
|
bcopy((char *)COEF(list),(char *)c,(int)(sizeof(BM)*np)); |
|
|
|
/* initialize g by f */ |
|
g = f; mulp(vl,g,COEF(DC(g)),&lcg); |
|
|
|
/* initialize lcy by LC(f) */ |
|
W_BMALLOC(0,bound,lcy); |
|
NEWDC(dc); COEF(dc) = COEF(DC(g)); |
|
DEG(dc) = 0; |
|
NEWP(lcyx); VR(lcyx) = x; DC(lcyx) = dc; |
|
ptosfbm(bound,lcyx,lcy); |
|
|
|
fprintf(stderr,"np = %d\n",np); |
|
for ( g = f, k = 1, dcf = dcf0 = 0, win[0] = 1, --np, z = 0; ; z++ ) { |
|
if ( !(z % 1000) ) fprintf(stderr,"."); |
|
if ( sfdtestmain(vl,lcg,lcy,csum,wlist,k,win,&factor,&cofactor) ) { |
|
NEXTDC(dcf0,dcf); DEG(dcf) = ONE; COEF(dcf) = factor; |
|
g = cofactor; |
|
|
|
/* update csum */ |
|
sfcsump(vl,g,&csum); mulp(vl,csum,COEF(DC(g)),&csumt); csum = csumt; |
|
|
|
/* update lcg */ |
|
mulp(vl,g,COEF(DC(g)),&lcg); |
|
|
|
/* update lcy */ |
|
clearsfbm(bound,0,lcy); |
|
COEF(dc) = COEF(DC(g)); ptosfbm(bound,lcyx,lcy); |
|
|
|
for ( i = 0; i < k - 1; i++ ) |
|
for ( j = win[i] + 1; j < win[i + 1]; j++ ) |
|
c[j-i-1] = c[j]; |
|
for ( j = win[k-1] + 1; j <= np; j++ ) |
|
c[j-k] = c[j]; |
|
if ( ( np -= k ) < k ) |
|
break; |
|
if ( np - win[0] + 1 < k ) |
|
if ( ++k > np ) |
|
break; |
|
else |
|
for ( i = 0; i < k; i++ ) |
|
win[i] = i + 1; |
|
else |
|
for ( i = 1; i < k; i++ ) |
|
win[i] = win[0] + i; |
|
} else if ( !ncombi(1,np,k,win) ) |
|
if ( k == np ) |
|
break; |
|
else |
|
for ( i = 0, ++k; i < k; i++ ) |
|
win[i] = i + 1; |
|
} |
|
fprintf(stderr,"\n"); |
|
NEXTDC(dcf0,dcf); COEF(dcf) = g; |
|
DEG(dcf) = ONE; NEXT(dcf) = 0; *dcp = dcf0; |
|
} |
|
|
|
/* lcy = LC(g), lcg = lcy*g */ |
|
int sfdtestmain(vl,lcg,lcy,csum,list,k,in,fp,cofp) |
|
VL vl; |
|
P lcg; |
|
BM lcy; |
|
P csum; |
|
ML list; |
|
int k; |
|
int *in; |
|
P *fp,*cofp; |
|
{ |
|
P fmul,csumg,q; |
|
V x,y; |
|
|
|
x = vl->v; |
|
y = vl->next->v; |
|
#if 0 |
|
if (!sfctest(g,list,k,in)) |
|
return 0; |
|
#endif |
|
mulsfbmarray(UDEG(lcg),lcy,list,k,in,x,y,&fmul); |
|
if ( csum ) { |
|
sfcsump(vl,fmul,&csumg); |
|
if ( csumg ) { |
|
if ( !divtp(vl,csum,csumg,&q) ) |
|
return 0; |
|
} |
|
} |
|
if ( divtp(vl,lcg,fmul,&q) ) { |
|
pp_sfp(vl,fmul,fp); |
|
pp_sfp(vl,q,cofp); |
|
return 1; |
|
} else |
|
return 0; |
|
} |
|
|
|
#if 0 |
|
int sfctest(g,list,k,in) |
|
P g; |
|
ML list; |
|
int k; |
|
int *in; |
|
{ |
|
register int i; |
|
int q,bound; |
|
int *wm,*wm1,*tmpp; |
|
DCP dc; |
|
Q dvr; |
|
N lcn,cstn,dndn,dmyn,rn; |
|
LUM *l; |
|
|
|
for ( dc = DC(g); dc && DEG(dc); dc = NEXT(dc) ); |
|
if ( dc ) |
|
cstn = NM((Q)COEF(dc)); |
|
else |
|
return 1; |
|
q = list->mod; bound = list->bound; |
|
ntobn(q,NM((Q)COEF(DC(g))),&lcn);; |
|
W_CALLOC(bound+1,int,wm); W_CALLOC(bound+1,int,wm1); |
|
for ( i = 0; i < PL(lcn); i++ ) |
|
wm[i] = BD(lcn)[i]; |
|
for ( i = 0, l = (LUM *)list->c; i < k; i++ ) { |
|
mulpadic(q,bound,wm,COEF(l[in[i]])[0],wm1); |
|
tmpp = wm; wm = wm1; wm1 = tmpp; |
|
} |
|
padictoq(q,bound,wm,&dvr); |
|
kmuln(NM((Q)COEF(DC(g))),cstn,&dndn); divn(dndn,NM(dvr),&dmyn,&rn); |
|
return rn ? 0 : 1; |
|
} |
|
#endif |
|
|
|
/* main var of f is x */ |
|
|
|
void mulsfbmarray(n,lcy,list,k,in,x,y,g) |
|
int n; |
|
BM lcy; |
|
ML list; |
|
int k; |
|
int *in; |
|
V x,y; |
|
P *g; |
|
{ |
|
int bound,i; |
|
BM wb0,wb1,t,lcbm; |
|
BM *l; |
|
|
|
bound = list->bound; |
|
W_BMALLOC(n,bound,wb0); W_BMALLOC(n,bound,wb1); |
|
l = (BM *)list->c; |
|
clearsfbm(bound,n,wb0); |
|
mulsfbm(bound,lcy,l[in[0]],wb0); |
|
for ( i = 1; i < k; i++ ) { |
|
clearsfbm(bound,n,wb1); |
|
mulsfbm(bound,l[in[i]],wb0,wb1); |
|
t = wb0; wb0 = wb1; wb1 = t; |
|
} |
|
sfbmtop(bound,wb0,x,y,g); |
|
} |
|
|
|
void sfcsump(vl,f,s) |
|
VL vl; |
|
P f; |
|
P *s; |
|
{ |
|
P t,u; |
|
DCP dc; |
|
|
|
for ( dc = DC(f), t = 0; dc; dc = NEXT(dc) ) { |
|
addp(vl,COEF(dc),t,&u); t = u; |
|
} |
|
*s = t; |
|
} |
|
|
|
/* *fp = primitive part of f w.r.t. x */ |
|
|
|
void pp_sfp(vl,f,fp) |
|
VL vl; |
|
P f; |
|
P *fp; |
|
{ |
|
V x,y; |
|
int d; |
|
UM t,s,gcd; |
|
DCP dc; |
|
P dvr; |
|
|
|
x = vl->v; |
|
y = vl->next->v; |
|
d = getdeg(y,f); |
|
if ( d == 0 ) |
|
*fp = f; /* XXX */ |
|
else { |
|
t = W_UMALLOC(2*d); |
|
s = W_UMALLOC(2*d); |
|
gcd = W_UMALLOC(2*d); |
|
dc = DC(f); |
|
ptosfum(COEF(dc),gcd); |
|
for ( dc = NEXT(dc); dc; dc = NEXT(dc) ) { |
|
ptosfum(COEF(dc),t); |
|
gcdsfum(gcd,t,s); |
|
cpyum(s,gcd); |
|
} |
|
sfumtop(y,gcd,&dvr); |
|
divsp(vl,f,dvr,fp); |
|
} |
} |
} |