OpenXM_contrib2/asir2000/engine/Hgfs.c - diff

Return to Hgfs.c CVS log

Up to [local] / OpenXM_contrib2 / asir2000 / engine

Diff for /OpenXM_contrib2/asir2000/engine/Hgfs.c between version 1.16 and 1.19

version 1.16, 2001/09/03 01:04:26

version 1.19, 2001/10/30 07:25:58

Line 1

/* $OpenXM: OpenXM_contrib2/asir2000/engine/Hgfs.c,v 1.15 2001/08/02 03:59:15 noro Exp $ */

/* $OpenXM: OpenXM_contrib2/asir2000/engine/Hgfs.c,v 1.18 2001/10/09 01:36:10 noro Exp $ */

#include "ca.h"

struct p_pair {

void lnfsf(int n,UM p0,UM p1,struct p_pair *list,UM np0,UM np1);

UM p0;

UM p1;

struct p_pair *next;

};

void canzassf(UM,int,UM *);

int comp_dum(DUM a,DUM b)

void lnfsf(int,UM,UM,struct p_pair *,UM,UM);

void minipolysf(UM,UM,UM);

void czsfum(UM,UM *);

void gensqfrsfum(UM,DUM);

void sfbmtop(BM,V,V,P *);

void cont_pp_sfp(VL,P,P *,P *);

void sfcsump(VL,P,P *);

void mulsfbmarray(int,BM,ML,int,int *,V,V,P *);

void const_term(P,UM);

void sfbsqfr(P,V,V,DCP *);

void sfusqfr(P,DCP *);

int comp_dum(a,b)

DUM a,b;

{

if ( DEG(a->f) > DEG(b->f) )

return -1;

Line 33 DUM a,b;

Line 14 DUM a,b;

return 0;

}

void fctrsf(p,dcp)

void fctrsf(P p,DCP *dcp)

P p;

DCP *dcp;

{

int n,i,j,k;

DCP dc,dc0;

P lc;

P zp;

UM mp;

UM *tl;

Obj obj;

struct oDUM *udc,*udc1;

simp_ff(p,&zp); p = zp;

simp_ff((Obj)p,&obj); p = (P)obj;

if ( !p ) {

*dcp = 0; return;

}

Line 92 DCP *dcp;

Line 71 DCP *dcp;

NEXT(dc) = 0; *dcp = dc0;

}

void gensqfrsfum(p,dc)

void gensqfrsfum(UM p,struct oDUM *dc)

UM p;

struct oDUM *dc;

{

int n,i,j,d,mod;

UM t,s,g,f,f1,b;

Line 147 struct oDUM *dc;

Line 124 struct oDUM *dc;

}

void randsfum(d,p)

void randsfum(int d,UM p)

int d;

UM p;

{

int i;

Line 159 UM p;

Line 134 UM p;

p->d = i;

}

void pwrmodsfum(p,e,f,pr)

void pwrmodsfum(UM p,int e,UM f,UM pr)

int e;

UM p,f,pr;

{

UM wt,ws,q;

Line 189 UM p,f,pr;

Line 162 UM p,f,pr;

}

void spwrsfum(m,f,e,r)

void spwrsfum(UM m,UM f,N e,UM r)

UM f,m,r;

N e;

{

UM t,s,q;

N e1;

Line 213 N e;

Line 184 N e;

}

void tracemodsfum(m,f,e,r)

void tracemodsfum(UM m,UM f,int e,UM r)

UM f,m,r;

int e;

{

UM t,s,q,u;

int i;

Line 235 int e;

Line 204 int e;

cpyum(s,r);

}

void make_qmatsf(p,tab,mp)

void make_qmatsf(UM p,UM *tab,int ***mp)

UM p;

UM *tab;

int ***mp;

{

int n,i,j;

int *c;

Line 259 int ***mp;

Line 225 int ***mp;

mat[i][i] = _subsf(mat[i][i],one);

}

void nullsf(mat,n,ind)

void nullsf(int **mat,int n,int *ind)

int **mat;

int *ind;

int n;

{

int i,j,l,s,h,inv;

int *t,*u;

Line 294 int n;

Line 257 int n;

}

void null_to_solsf(mat,ind,n,r)

void null_to_solsf(int **mat,int *ind,int n,UM *r)

int **mat;

int *ind;

int n;

UM *r;

{

int i,j,k,l;

int *c;

Line 327 nullsf(mat,n,ind)

Line 286 nullsf(mat,n,ind)

null_to_solsf(ind,n,r)

void czsfum(f,r)

void czsfum(UM f,UM *r)

UM f,*r;

{

int i,j;

int d,n,ord;

Line 382 UM f,*r;

Line 340 UM f,*r;

r[j] = 0;

}

int berlekampsf(p,df,tab,r)

int berlekampsf(UM p,int df,UM *tab,UM *r)

UM p;

int df;

UM *tab,*r;

{

int n,i,j,k,nf,d,nr;

int **mat;

Line 431 UM *tab,*r;

Line 386 UM *tab,*r;

}

/* NOT REACHED */

error("berlekampsf : cannot happen");

return 0;

}

void minipolysf(f,p,mp)

void minipolysf(UM f,UM p,UM mp)

UM f,p,mp;

{

struct p_pair *list,*l,*l1,*lprev;

int n,d;

Line 469 UM f,p,mp;

Line 426 UM f,p,mp;

}

void lnfsf(n,p0,p1,list,np0,np1)

void lnfsf(int n,UM p0,UM p1,struct p_pair *list,UM np0,UM np1)

int n;

UM p0,p1;

struct p_pair *list;

UM np0,np1;

{

int inv,h,d1;

int h,d1;

UM t0,t1,s0,s1;

struct p_pair *l;

Line 492 UM np0,np1;

Line 445 UM np0,np1;

}

int find_rootsf(p,root)

int find_rootsf(UM p,int *root)

UM p;

int *root;

{

UM *r;

int i,j,n;

int i,n;

n = DEG(p);

r = ALLOCA((DEG(p))*sizeof(UM));

Line 507 int *root;

Line 458 int *root;

return n;

}

void canzassf(f,d,r)

void canzassf(UM f,int d,UM *r)

UM f,*r;

int d;

{

UM t,s,u,w,g,o;

N n1,n2,n3,n4,n5;

UM *b;

int n,m,i,q,ed;

int n,q,ed;

if ( DEG(f) == d ) {

r[0] = UMALLOC(d); cpyum(f,r[0]);

Line 560 void ptosfbm(int,P,BM);

Line 509 void ptosfbm(int,P,BM);

/* f = f(x,y) */

void sfhensel(count,f,x,evp,sfp,listp)

void sfhensel(int count,P f,V x,GFS *evp,P *sfp,ML *listp)

int count;

P f;

V x;

GFS *evp;

P *sfp;

ML *listp;

{

int i,j;

int i;

int fn,n;

int fn;

ML rlist;

BM fl;

VL vl,nvl;

V y;

int dx,dy,mev;

int dx,dy,bound;

GFS ev;

P f1,t,yev,c,sf;

P f1,t,c,sf;

DCP dc;

UM w,w1,q,fm,hm;

UM q,fm,hm;

UM *gm;

struct oEGT tmp0,tmp1,eg_hensel,eg_hensel_t;

Line 611 ML *listp;

Line 554 ML *listp;

ptosfum(dc->c,gm[i]);

}

/* set bound */

bound = dy+2;

/* f(x,y) -> f(x,y+ev) */

fl = BMALLOC(dx,dy);

fl = BMALLOC(dx,bound);

ptosfbm(dy,f,fl);

ptosfbm(bound,f,fl);

if ( ev ) shiftsfbm(fl,FTOIF(CONT(ev)));

/* sf = f(x+ev) */

Line 625 ML *listp;

Line 571 ML *listp;

hm = W_UMALLOC(dx);

q = W_UMALLOC(dx);

rlist = MLALLOC(fn); rlist->n = fn; rlist->bound = dy;

rlist = MLALLOC(fn); rlist->n = fn; rlist->bound = bound;

fprintf(asir_out,"%d candidates\n",fn);

init_eg(&eg_hensel);

for ( i = 0; i < fn-1; i++ ) {

Line 635 ML *listp;

Line 581 ML *listp;

get_eg(&tmp0);

/* fl = gm[i]*hm mod y */

divsfum(fm,gm[i],hm);

/* fl is replaced by the cofactor of gk mod y^dy */

/* fl is replaced by the cofactor of gk mod y^bound */

/* rlist->c[i] = gk */

sfhenmain2(fl,gm[i],hm,dy,(BM *)&rlist->c[i]);

sfhenmain2(fl,gm[i],hm,bound,(BM *)&rlist->c[i]);

cpyum(hm,fm);

get_eg(&tmp1); add_eg(&eg_hensel_t,&tmp0,&tmp1);

add_eg(&eg_hensel,&tmp0,&tmp1);

Line 662 ML *listp;

Line 608 ML *listp;

/* main variable of f = x */

int sfberle(vl,f,count,ev,dcp)

int sfberle(VL vl,P f,int count,GFS *ev,DCP *dcp)

VL vl;

P f;

int count;

GFS *ev;

DCP *dcp;

{

UM wf,wf1,wf2,wfs,gcd;

ML flist;

int fn,n;

int fn,fn1,n;

GFS m,fm;

DCP dc,dct,dc0;

VL nvl;

V x,y;

P g,lc,lc0,f0;

P lc,lc0,f0;

Obj obj;

int j,q1,index,i;

clctv(vl,f,&nvl); vl = nvl;

x = vl->v; y = vl->next->v;

simp_ff(f,&g); g = f;

simp_ff((Obj)f,&obj); f = (P)obj;

n = QTOS(DEG(DC(f)));

wf = W_UMALLOC(n); wf1 = W_UMALLOC(n); wf2 = W_UMALLOC(n);

wfs = W_UMALLOC(n); gcd = W_UMALLOC(n);

Line 716 DCP *dcp;

Line 657 DCP *dcp;

}

void sfgcdgen(f,blist,clistp)

void sfgcdgen(P f,ML blist,ML *clistp)

P f;

ML blist,*clistp;

{

int i;

int n,d,np;

Line 747 ML blist,*clistp;

Line 686 ML blist,*clistp;

/* f = g0*h0 mod y -> f = gk*hk mod y^(dy+1), f is replaced by hk */

void sfhenmain2(f,g0,h0,dy,gp)

void sfhenmain2(BM f,UM g0,UM h0,int dy,BM *gp)

BM f;

UM g0,h0;

int dy;

BM *gp;

{

int i,j,k,l;

int i,k;

int *px,*py;

int dx;

int **pp,**pp1;

UM wt,wa,wb,q,w1,w2,wh1,wg1,ws;

int dx,np,dr,tmp;

UM wt,wa,wb,wm,q,w1,w2,wh1,wg1,ws;

UM wc,wd,we,wz;

BM wb0,wb1;

int dg,dh;

Line 858 BM *gp;

Line 791 BM *gp;

/* fl->c[i] = coef_y(f,i) */

void ptosfbm(dy,f,fl)

void ptosfbm(int dy,P f,BM fl)

int dy;

P f;

BM fl;

{

DCP dc;

int d,i,dx;

Line 885 BM fl;

Line 815 BM fl;

/* x : main variable */

void sfbmtop(f,x,y,fp)

void sfbmtop(BM f,V x,V y,P *fp)

BM f;

V x,y;

P *fp;

{

UM *c;

int i,j,d,a,dy;

Line 926 P *fp;

Line 853 P *fp;

*fp = 0;

}

void sfsqfr(f,dcp)

void sfsqfr(P f,DCP *dcp)

P f;

DCP *dcp;

{

P g;

Obj obj;

V x;

DCP dc;

VL vl;

simp_ff(f,&g); f = g;

simp_ff((Obj)f,&obj); f = (P)obj;

clctv(CO,f,&vl);

if ( !vl ) {

/* f is a const */

Line 943 DCP *dcp;

Line 867 DCP *dcp;

} else if ( !NEXT(vl) )

sfusqfr(f,dcp);

else if ( !NEXT(NEXT(vl)) )

sfbsqfr(f,x,NEXT(vl)->v,dcp);

sfbsqfr(f,vl->v,NEXT(vl)->v,dcp);

else

error("sfsqfr : not implemented yet");

}

void sfusqfr(f,dcp)

void sfusqfr(P f,DCP *dcp)

P f;

DCP *dcp;

{

DCP dc,dct;

struct oDUM *udc;

Line 978 DCP *dcp;

Line 900 DCP *dcp;

*dcp = dct;

}

void sfbsqfr(f,x,y,dcp)

void sfbsqfr(P f,V x,V y,DCP *dcp)

P f;

V x,y;

DCP *dcp;

{

P t,rf,cx,cy;

VL vl,rvl;

Line 1005 DCP *dcp;

Line 924 DCP *dcp;

void sfdtest(P,ML,V,V,DCP *);

void sfbfctr(f,x,y,dcp)

void sfbfctr(P f,V x,V y,DCP *dcp)

P f;

V x,y;

DCP *dcp;

{

ML list;

P sf;

Line 1043 DCP *dcp;

Line 959 DCP *dcp;

/* f = f(x,y) = list->c[0]*list->c[1]*... mod y^(list->bound+1) */

void sfdtest(f,list,x,y,dcp)

void sfdtest(P f,ML list,V x,V y,DCP *dcp)

P f;

ML list;

V x,y;

DCP *dcp;

{

int np,dx,dy;

int i,j,k;

int *win;

P g,lcg,factor,cofactor,lcyx;

P t,csum;

P csum;

DCP dcf,dcf0,dc;

BM *c;

BM lcy;

Line 1061 DCP *dcp;

Line 973 DCP *dcp;

ML wlist;

struct oVL vl1,vl0;

VL vl;

int z;

int z,dt,dtok;

/* vl = [x,y] */

vl0.v = x; vl0.next = &vl1; vl1.v = y; vl1.next = 0; vl = &vl0;

Line 1073 DCP *dcp;

Line 985 DCP *dcp;

win = W_ALLOC(np+1);

wlist = W_MLALLOC(np);

wlist->n = list->n;

wlist->bound = dy;

wlist->bound = list->bound;

c = (BM *)COEF(wlist);

bcopy((char *)COEF(list),(char *)c,(int)(sizeof(BM)*np));

Line 1098 DCP *dcp;

Line 1010 DCP *dcp;

ptosfbm(dy,lcyx,lcy);

fprintf(stderr,"np = %d\n",np);

dtok = 0;

for ( g = f, k = 1, dcf = dcf0 = 0, win[0] = 1, --np, z = 0; ; z++ ) {

if ( !(z % 1000) ) fprintf(stderr,".");

if ( sfdtestmain(vl,lcg,lcg0,lcy,csum,wlist,k,win,&factor,&cofactor) ) {

dt = sfdegtest(dy,wlist,k,win);

if ( dt )

dtok++;

if ( dt && sfdtestmain(vl,lcg,lcg0,lcy,csum,wlist,

k,win,&factor,&cofactor) ) {

NEXTDC(dcf0,dcf); DEG(dcf) = ONE; COEF(dcf) = factor;

g = cofactor;

Line 1113 DCP *dcp;

Line 1030 DCP *dcp;

/* update csum */

sfcsump(vl,lcg,&csum);

/* update dy */

dy = getdeg(y,g);

/* update lcy */

clearbm(0,lcy);

COEF(dc) = COEF(DC(g));

Line 1141 DCP *dcp;

Line 1061 DCP *dcp;

for ( i = 0, ++k; i < k; i++ )

win[i] = i + 1;

}

fprintf(stderr,"\n");

fprintf(stderr,"total %d, omitted by degtest %d\n",z,z-dtok);

NEXTDC(dcf0,dcf); COEF(dcf) = g;

DEG(dcf) = ONE; NEXT(dcf) = 0; *dcp = dcf0;

}

void extractcoefbm(BM f,int d,UM r)

{

int j;

UM fj;

for ( j = DEG(f); j >= 0; j-- ) {

fj = COEF(f)[j];

if ( fj && DEG(fj) >= d ) {

COEF(r)[j] = COEF(fj)[d];

} else

COEF(r)[j] = 0;

}

degum(r,DEG(f));

}

/* deg_y(prod mod y^(bound+1)) <= dy ? */

int sfdegtest(int dy,ML list,int k,int *in)

{

int bound,dx,dx1,i,j;

UM w,w1,w2,wt;

BM t;

bound = list->bound;

w = W_UMALLOC(bound);

w1 = W_UMALLOC(bound);

w2 = W_UMALLOC(bound);

clearum(w,bound);

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

t = (BM)list->c[in[i]];

dx = degbm(t);

dx1 = dx-1;

/* t = t->c[0] + t->c[1]*y + ... + t->c[j]*y^j + ... */

/* extract coef. of x^dx1 and add it to w */

extractcoefbm(t,dx1,w1);

addsfum(w,w1,w2); wt = w; w = w2; w2 = wt;

}

for ( j = bound; j >= dy; j-- )

if ( COEF(w)[j] )

break;

return j <= dy ? 1 : 0;

}

/* lcy = LC(g), lcg = lcy*g, lcg0 = const part of lcg */

int sfdtestmain(vl,lcg,lcg0,lcy,csum,list,k,in,fp,cofp)

VL vl;

int sfdtestmain(VL vl,P lcg,UM lcg0,BM lcy,P csum,ML list,

P lcg;

int k,int *in,P *fp,P *cofp)

UM lcg0;

BM lcy;

P csum;

ML list;

int k;

int *in;

P *fp,*cofp;

{

P fmul,csumg,q,cont;

V x,y;

Line 1181 P *fp,*cofp;

Line 1137 P *fp,*cofp;

return 0;

}

void const_term(f,c)

void const_term(P f,UM c)

P f;

UM c;

{

DCP dc;

Line 1194 UM c;

Line 1148 UM c;

DEG(c) = -1;

}

void const_term_sfbm(f,c)

void const_term_sfbm(BM f,UM c)

BM f;

UM c;

{

int i,dy;

Line 1211 UM c;

Line 1163 UM c;

/* lcy*(product of const part) | lcg0 ? */

int sfctest(lcg0,lcy,list,k,in)

int sfctest(UM lcg0,BM lcy,ML list,int k,int *in)

UM lcg0;

BM lcy;

ML list;

int k;

int *in;

{

DCP dc;

int dy,i,dr;

UM t,s,u,w;

BM *l;

Line 1249 int *in;

Line 1195 int *in;

/* main var of f is x */

void mulsfbmarray(dx,lcy,list,k,in,x,y,g)

void mulsfbmarray(int dx,BM lcy,ML list,int k,int *in,V x,V y,P *g)

int dx;

BM lcy;

ML list;

int k;

int *in;

V x,y;

P *g;

{

int dy,i;

BM wb0,wb1,t,lcbm;

BM wb0,wb1,t;

BM *l;

dy = list->bound;

Line 1275 P *g;

Line 1214 P *g;

sfbmtop(wb0,x,y,g);

}

void sfcsump(vl,f,s)

void sfcsump(VL vl,P f,P *s)

VL vl;

P f;

P *s;

{

P t,u;

DCP dc;

Line 1291 P *s;

Line 1227 P *s;

/* *fp = primitive part of f w.r.t. x */

void cont_pp_sfp(vl,f,cp,fp)

void cont_pp_sfp(VL vl,P f,P *cp,P *fp)

VL vl;

P f;

P *cp,*fp;

{

V x,y;

int d;

Line 1325 P *cp,*fp;

Line 1258 P *cp,*fp;

}

int divtp_by_sfbm(vl,f,g,qp)

int divtp_by_sfbm(VL vl,P f,P g,P *qp)

VL vl;

P f,g;

P *qp;

{

V x,y;

int fx,fy,gx,gy;

Line 1369 P *qp;

Line 1299 P *qp;

if ( j >= 0 )

return 0;

sfbmtop(ql,x,y,qp);

return 1;

}

/* XXX generate an irreducible poly of degree n */

void generate_defpoly_sfum(n,dp)

extern int current_gfs_q1;

int n;

UM *dp;

void generate_defpoly_sfum(int n,UM *dp)

{

UM r,dr,t,g;

UM *f;

int *c,*w;

int max,i,j;

*dp = r = UMALLOC(n);

DEG(r) = n;

c = COEF(r);

c[n] = _onesf();

max = current_gfs_q1;

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

bzero(w,n*sizeof(int));

dr = W_UMALLOC(n); t = W_UMALLOC(n); g = W_UMALLOC(n);

f = (UM *)ALLOCA((n+1)*sizeof(UM));

while ( 1 ) {

for ( i = 0; i < n && w[i] == max; i++ );

if ( i == n ) {

/* XXX cannot happen */

error("generate_defpoly_sfum : cannot happen");

}

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

w[j] = 0;

w[i]++;

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

c[i] = w[i]?FTOIF(w[i]-1):0;

if ( !c[0] )

continue;

diffsfum(r,dr); cpyum(r,t); gcdsfum(t,dr,g);

if ( DEG(g) > 0 )

continue;

czsfum(r,f);

for ( i = 0; f[i]; i++ );

if ( i == 1 )

return;

}

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