version 1.5, 2001/07/04 07:19:20 |
version 1.6, 2001/10/09 01:36:09 |
|
|
* DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE, |
* DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE, |
* PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE. |
* PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE. |
* |
* |
* $OpenXM: OpenXM_contrib2/asir2000/engine/H.c,v 1.4 2001/07/03 01:41:25 noro Exp $ |
* $OpenXM: OpenXM_contrib2/asir2000/engine/H.c,v 1.5 2001/07/04 07:19:20 noro Exp $ |
*/ |
*/ |
#include "ca.h" |
#include "ca.h" |
#include "inline.h" |
#include "inline.h" |
#include "base.h" |
#include "base.h" |
#include <math.h> |
#include <math.h> |
|
|
void modfctrp(P,int,int,DCP *); |
|
void gensqfrum(int,UM,struct oDUM *); |
|
void srchum(int,UM,UM,UM); |
|
UM *resberle(int,UM,UM *); |
|
int substum(int,UM,int); |
|
void ddd(int,UM,UM *); |
|
void canzas(int,UM,int,UM *,UM *); |
|
int divum(int,UM,UM,UM); |
|
void randum(int,int,UM); |
|
void pwrmodum(int,UM,int,UM,UM); |
|
void spwrum(int,UM,UM *,UM,N,UM); |
|
void spwrum0(int,UM,UM,N,UM); |
|
void mulum(int,UM,UM,UM); |
|
void mulsum(int,UM,int,UM); |
|
void gcdum(int,UM,UM,UM); |
|
void mult_mod_tab(UM,int,UM *,UM,int); |
|
void make_qmat(UM,int,UM *,int ***); |
|
void null_mod(int **,int,int,int *); |
|
void null_to_sol(int **,int *,int,int,UM *); |
|
void newddd(int,UM,UM *); |
|
int irred_check(UM,int); |
|
int berlekamp(UM,int,int,UM *,UM *); |
|
int nfctr_mod(UM,int); |
|
void minipoly_mod(int,UM,UM,UM); |
|
int find_root(int,UM,int *); |
|
void showum(UM); |
|
void showumat(int **,int); |
|
|
|
void henmain2(LUM,UM,UM,UM,UM,int,int,LUM *); |
|
void addtolum(int,int,LUM,LUM); |
|
void clearlum(int,int,LUM); |
|
void henprep2(int,int,int,UM,UM,UM,UM,UM,UM,UM); |
|
void henprep(P,ML,ML,ML *,ML *); |
|
|
|
#if 1 |
#if 1 |
#define Mulum mulum |
#define Mulum mulum |
#define Divum divum |
#define Divum divum |
Line 100 void henprep(P,ML,ML,ML *,ML *); |
|
Line 66 void henprep(P,ML,ML,ML *,ML *); |
|
|
|
LUM LUMALLOC(); |
LUM LUMALLOC(); |
|
|
struct p_pair { |
void berle(int index,int count,P f,ML *listp) |
UM p0; |
|
UM p1; |
|
struct p_pair *next; |
|
}; |
|
|
|
void lnf_mod(int,int,UM,UM,struct p_pair *,UM,UM); |
|
|
|
void berle(index,count,f,listp) |
|
int index,count; |
|
P f; |
|
ML *listp; |
|
{ |
{ |
UM wf,wf1,wf2,wfs,gcd; |
UM wf,wf1,wf2,wfs,gcd; |
ML flist; |
ML flist; |
|
|
ptr[i] = ( ptr[i] * hd ) % m; |
ptr[i] = ( ptr[i] * hd ) % m; |
} |
} |
|
|
int berlecnt(mod,f) |
int berlecnt(int mod,UM f) |
register int mod; |
|
UM f; |
|
{ |
{ |
register int i,j,**c; |
register int i,j,**c; |
int d,dr,n; |
int d,dr,n; |
|
|
|
|
/* XXX berlecntmain should not be used for large mod */ |
/* XXX berlecntmain should not be used for large mod */ |
|
|
int berlecntmain(mod,n,m,c) |
int berlecntmain(int mod,int n,int m,int **c) |
register int mod; |
|
int n,m; |
|
register int **c; |
|
{ |
{ |
register int *p1,*p2,i,j,k,l,a; |
register int *p1,*p2,i,j,k,l,a; |
int *tmp,inv; |
int *tmp,inv; |
Line 212 register int **c; |
|
Line 162 register int **c; |
|
return ( cfs ); |
return ( cfs ); |
} |
} |
|
|
UM *berlemain(mod,f,fp) |
UM *berlemain(int mod,UM f,UM *fp) |
register int mod; |
|
UM f; |
|
UM *fp; |
|
{ |
{ |
UM wg,ws,wf,f0,gcd,q; |
UM wg,ws,wf,f0,gcd,q; |
int n; |
int n; |
|
|
return ( fp ); |
return ( fp ); |
} |
} |
|
|
void hensel(index,count,f,listp) |
void hensel(int index,int count,P f,ML *listp) |
int index,count; |
|
P f; |
|
ML *listp; |
|
{ |
{ |
register int i,j; |
register int i,j; |
int q,n,bound; |
int q,n,bound; |
|
|
} |
} |
} |
} |
|
|
void hensel2(index,count,f,listp) |
void hensel2(int index,int count,P f,ML *listp) |
int index,count; |
|
P f; |
|
ML *listp; |
|
{ |
{ |
register int i,j; |
register int i,j; |
int mod,q,n,bound,dx; |
int mod,q,n,bound,dx; |
int *p; |
|
ML blist,clist,bqlist,cqlist,rlist; |
ML blist,clist,bqlist,cqlist,rlist; |
UM fm,qfm,gm,qgm,hm,qhm,qam,qbm,w; |
UM fm,qfm,gm,qgm,hm,qhm,qam,qbm,w; |
UM *b; |
UM *b; |
LUM fl,tl; |
LUM fl,tl; |
LUM *l; |
int k; |
int dr,k; |
|
|
|
dx = UDEG(f); |
dx = UDEG(f); |
if ( dx == 1 ) { |
if ( dx == 1 ) { |
|
|
f = g0*h0 mod m -> f = gk*hk mod m^(bound), f is replaced by hk |
f = g0*h0 mod m -> f = gk*hk mod m^(bound), f is replaced by hk |
*/ |
*/ |
|
|
void henmain2(f,g0,h0,a0,b0,m,bound,gp) |
void henmain2(LUM f,UM g0,UM h0,UM a0,UM b0,int m,int bound,LUM *gp) |
LUM f; |
|
UM g0,h0,a0,b0; |
|
int m,bound; |
|
LUM *gp; |
|
{ |
{ |
int n,dg,dh,i,k,j,dg1,dh1; |
int n,dg,dh,i,k,j,dg1,dh1; |
UM wu,wr,ws,wt,q,wh1,wg1,wc,wd,we,wz,w1,w2; |
UM wu,wr,ws,wt,q,wh1,wg1,wc,wd,we,wz; |
LUM wb0,wb1,wb2,fk,gk,hk; |
LUM wb0,wb1,wb2,fk,gk,hk; |
|
|
n = DEG(f); dg = DEG(g0); dh = DEG(h0); |
n = DEG(f); dg = DEG(g0); dh = DEG(h0); |
|
|
COEF(f)[i][j] = COEF(hk)[i][j]; |
COEF(f)[i][j] = COEF(hk)[i][j]; |
} |
} |
|
|
void clearlum(n,bound,f) |
void clearlum(int n,int bound,LUM f) |
int n,bound; |
|
LUM f; |
|
{ |
{ |
int i; |
int i; |
|
|
|
|
|
|
/* g += f */ |
/* g += f */ |
|
|
void addtolum(m,bound,f,g) |
void addtolum(int m,int bound,LUM f,LUM g) |
int m,bound; |
|
LUM f; |
|
LUM g; |
|
{ |
{ |
int n,i; |
int n,i; |
|
|
|
|
addpadic(m,bound,COEF(f)[i],COEF(g)[i]); |
addpadic(m,bound,COEF(f)[i],COEF(g)[i]); |
} |
} |
|
|
void hsq(index,count,f,nindex,dcp) |
void hsq(int index,int count,P f,int *nindex,DCP *dcp) |
int index,count,*nindex; |
|
P f; |
|
DCP *dcp; |
|
{ |
{ |
register int i,j,k; |
register int i,j,k; |
register int **pp,**fpp; |
register int **pp,**fpp; |
|
|
*dcp = 0; |
*dcp = 0; |
} |
} |
|
|
void gcdgen(f,blist,clistp) |
void gcdgen(P f,ML blist,ML *clistp) |
P f; |
|
ML blist,*clistp; |
|
{ |
{ |
register int i; |
register int i; |
int n,d,mod,np; |
int n,d,mod,np; |
Line 695 ML blist,*clistp; |
|
Line 620 ML blist,*clistp; |
|
/* find a,b s.t. qa*qg+qb*qh=1 mod q, qg=g mod mod, qh=h mod mod */ |
/* find a,b s.t. qa*qg+qb*qh=1 mod q, qg=g mod mod, qh=h mod mod */ |
/* q = mod^k */ |
/* q = mod^k */ |
|
|
void henprep2(mod,q,k,f,g,h,qg,qh,qa,qb) |
void henprep2(int mod,int q,int k,UM f,UM g,UM h,UM qg,UM qh,UM qa,UM qb) |
int mod,q,k; |
|
UM f,g,h,qg,qh,qa,qb; |
|
{ |
{ |
int n; |
int n; |
UM wg,wh,wa,wb; |
UM wg,wh,wa,wb; |
UM wt,ws,wu; |
|
ML bl,cl,bql,cql; |
ML bl,cl,bql,cql; |
P ff; |
P ff; |
|
|
Line 745 UM f,g,h,qg,qh,qa,qb; |
|
Line 667 UM f,g,h,qg,qh,qa,qb; |
|
henprep(f,blist,clist,&bqlist,&cqlist); |
henprep(f,blist,clist,&bqlist,&cqlist); |
*/ |
*/ |
|
|
void henprep(f,blist,clist,bqlistp,cqlistp) |
void henprep(P f,ML blist,ML clist,ML *bqlistp,ML *cqlistp) |
P f; |
|
ML blist,clist,*bqlistp,*cqlistp; |
|
{ |
{ |
register int i,j,k,*px,*py,*pz; |
register int i,j,k,*px,*py,*pz; |
int n,pmax,dr,tmp,p,p1,mod,np,b,q; |
int n,pmax,dr,tmp,p,p1,mod,np,b,q; |
Line 828 ML blist,clist,*bqlistp,*cqlistp; |
|
Line 748 ML blist,clist,*bqlistp,*cqlistp; |
|
henmain(fl,bqlist,cqlist,listp) |
henmain(fl,bqlist,cqlist,listp) |
*/ |
*/ |
|
|
void henmain(f,bqlist,cqlist,listp) |
void henmain(LUM f,ML bqlist,ML cqlist,ML *listp) |
LUM f; |
|
ML bqlist,cqlist,*listp; |
|
{ |
{ |
register int i,j,k; |
register int i,j,k; |
int *px,*py; |
int *px,*py; |
Line 898 ML bqlist,cqlist,*listp; |
|
Line 816 ML bqlist,cqlist,*listp; |
|
static double M; |
static double M; |
static int E; |
static int E; |
|
|
int mignotte(q,f) |
int mignotte(int q,P f) |
int q; |
|
P f; |
|
{ |
{ |
int p; |
int p; |
unsigned int *b; |
unsigned int *b; |
|
|
return (int)ceil( (0.31*(E+UDEG(f)+1)+log10((double)M)) / log10((double)q) ); |
return (int)ceil( (0.31*(E+UDEG(f)+1)+log10((double)M)) / log10((double)q) ); |
} |
} |
|
|
int mig(q,d,f) |
int mig(int q,int d,P f) |
int q,d; |
|
P f; |
|
{ |
{ |
int p; |
int p; |
unsigned int *b; |
unsigned int *b; |
|
|
return (int)ceil( (0.31*(E+d+1)+log10((double)M)) / log10((double)q) ); |
return (int)ceil( (0.31*(E+d+1)+log10((double)M)) / log10((double)q) ); |
} |
} |
|
|
void sqad(man,exp) |
void sqad(unsigned int man,int exp) |
unsigned int man; |
|
int exp; |
|
{ |
{ |
int e,sqe; |
int e,sqe; |
unsigned int t; |
unsigned int t; |
|
|
} |
} |
} |
} |
|
|
void ptolum(q,bound,f,fl) |
void ptolum(int q,int bound,P f,LUM fl) |
int q,bound; |
|
P f; |
|
LUM fl; |
|
{ |
{ |
DCP dc; |
DCP dc; |
int i,j; |
int i,j; |
|
|
} |
} |
} |
} |
|
|
void modfctrp(p,mod,flag,dcp) |
void modfctrp(P p,int mod,int flag,DCP *dcp) |
P p; |
|
int mod,flag; |
|
DCP *dcp; |
|
{ |
{ |
int cm,n,i,j,k; |
int cm,n,i,j,k; |
DCP dc,dc0; |
DCP dc,dc0; |
|
|
NEXT(dc) = 0; *dcp = dc0; |
NEXT(dc) = 0; *dcp = dc0; |
} |
} |
|
|
void gensqfrum(mod,p,dc) |
void gensqfrum(int mod,UM p,struct oDUM *dc) |
int mod; |
|
UM p; |
|
struct oDUM *dc; |
|
{ |
{ |
int n,i,j,d; |
int n,i,j,d; |
UM t,s,g,f,f1,b; |
UM t,s,g,f,f1,b; |
Line 1160 struct oDUM *dc; |
|
Line 1063 struct oDUM *dc; |
|
} |
} |
|
|
#if 0 |
#if 0 |
void srchum(mod,p1,p2,gr) |
void srchum(int mod,UM p1,UM p2,UM gr) |
int mod; |
|
UM p1,p2,gr; |
|
{ |
{ |
UM m,m1,m2,q,r,t,g1,g2; |
UM m,m1,m2,q,r,t,g1,g2; |
int lc,d,d1,d2,i,j,k,l,l1,l2,l3,tmp,adj; |
int lc,d,d1,d2,i,j,k,l,l1,l2,l3,tmp,adj; |
|
|
} |
} |
} |
} |
|
|
UM *resberle(mod,f,fp) |
UM *resberle(int mod,UM f,UM *fp) |
register int mod; |
|
UM f; |
|
UM *fp; |
|
{ |
{ |
UM w,wg,ws,wf,f0,gcd,q,res; |
UM w,wg,ws,wf,f0,gcd,q,res; |
int n; |
int n; |
|
|
return ( fp ); |
return ( fp ); |
} |
} |
|
|
int substum(mod,p,a) |
int substum(int mod,UM p,int a) |
int mod; |
|
UM p; |
|
int a; |
|
{ |
{ |
int i,j,s; |
int i,j,s; |
int *c; |
int *c; |
|
|
} |
} |
#endif |
#endif |
|
|
void ddd(mod,f,r) |
void ddd(int mod,UM f,UM *r) |
int mod; |
|
UM f,*r; |
|
{ |
{ |
register int i,j; |
register int i,j; |
int d,n; |
int d,n; |
|
|
} |
} |
|
|
#if 0 |
#if 0 |
void canzas(mod,f,d,base,r) |
void canzas(int mod,UM f,int d,UM *base,UM *r) |
int mod; |
|
UM f,*base,*r; |
|
{ |
{ |
UM t,s,u,w,g,o,q; |
UM t,s,u,w,g,o,q; |
N n1,n2,n3,n4,n5; |
N n1,n2,n3,n4,n5; |
|
|
} |
} |
} |
} |
#else |
#else |
void canzas(mod,f,d,base,r) |
void canzas(int mod,UM f,int d,UM *base,UM *r) |
int mod; |
|
UM f,*base,*r; |
|
{ |
{ |
UM t,s,u,w,g,o,q; |
UM t,s,u,w,g,o,q; |
N n1,n2,n3,n4,n5; |
N n1,n2,n3,n4,n5; |
|
|
} |
} |
#endif |
#endif |
|
|
void randum(mod,d,p) |
void randum(int mod,int d,UM p) |
int mod,d; |
|
UM p; |
|
{ |
{ |
unsigned int n; |
unsigned int n; |
int i; |
int i; |
|
|
COEF(p)[i] = ((unsigned int)random()) % mod; |
COEF(p)[i] = ((unsigned int)random()) % mod; |
} |
} |
|
|
void pwrmodum(mod,p,e,f,pr) |
void pwrmodum(int mod,UM p,int e,UM f,UM pr) |
int mod,e; |
|
UM p,f,pr; |
|
{ |
{ |
UM wt,ws,q; |
UM wt,ws,q; |
|
|
|
|
} |
} |
} |
} |
|
|
void spwrum(mod,m,base,f,e,r) |
void spwrum(int mod,UM m,UM *base,UM f,N e,UM r) |
int mod; |
|
UM f,m,r; |
|
UM *base; |
|
N e; |
|
{ |
{ |
int a,n,i; |
int a,n,i; |
N e1,an; |
N e1,an; |
|
|
} |
} |
} |
} |
|
|
void spwrum0(mod,m,f,e,r) |
void spwrum0(int mod,UM m,UM f,N e,UM r) |
int mod; |
|
UM f,m,r; |
|
N e; |
|
{ |
{ |
UM t,s,q; |
UM t,s,q; |
N e1; |
N e1; |
|
|
} |
} |
|
|
#if 0 |
#if 0 |
void Mulum(mod,p1,p2,pr) |
void Mulum(int mod,UM p1,UM p2,UM pr) |
register int mod; |
|
UM p1,p2,pr; |
|
{ |
{ |
register int *pc1,*pcr; |
register int *pc1,*pcr; |
register int mul,i,j,d1,d2; |
register int mul,i,j,d1,d2; |
|
|
DEG(pr) = d1 + d2; |
DEG(pr) = d1 + d2; |
} |
} |
|
|
void Mulsum(mod,p,n,pr) |
void Mulsum(int mod,UM p,int n,UM pr) |
register int mod,n; |
|
UM p,pr; |
|
{ |
{ |
register int *sp,*dp; |
register int *sp,*dp; |
register int i; |
register int i; |
|
|
*dp = (*sp * n) % mod; |
*dp = (*sp * n) % mod; |
} |
} |
|
|
int Divum(mod,p1,p2,pq) |
int Divum(int mod,UM p1,UM p2,UM pq) |
register int mod; |
|
UM p1,p2,pq; |
|
{ |
{ |
register int *pc1,*pct; |
register int *pc1,*pct; |
register int tmp,i,j,inv; |
register int tmp,i,j,inv; |
|
|
return( i ); |
return( i ); |
} |
} |
|
|
void Gcdum(mod,p1,p2,pr) |
void Gcdum(int mod,UM p1,UM p2,UM pr) |
register int mod; |
|
UM p1,p2,pr; |
|
{ |
{ |
register int *sp,*dp; |
register int *sp,*dp; |
register int i,inv; |
register int i,inv; |
|
|
} |
} |
#endif |
#endif |
|
|
void mult_mod_tab(p,mod,tab,r,d) |
void mult_mod_tab(UM p,int mod,UM *tab,UM r,int d) |
UM p,r; |
|
UM *tab; |
|
int mod,d; |
|
{ |
{ |
UM w,w1,c; |
UM w,w1,c; |
int n,i; |
int n,i; |
|
|
} |
} |
} |
} |
|
|
void make_qmat(p,mod,tab,mp) |
void make_qmat(UM p,int mod,UM *tab,int ***mp) |
UM p; |
|
int mod; |
|
UM *tab; |
|
int ***mp; |
|
{ |
{ |
int n,i,j; |
int n,i,j; |
int *c; |
int *c; |
|
|
mat[i][i] = (mat[i][i]+mod-1) % mod; |
mat[i][i] = (mat[i][i]+mod-1) % mod; |
} |
} |
|
|
void null_mod(mat,mod,n,ind) |
void null_mod(int **mat,int mod,int n,int *ind) |
int **mat; |
|
int *ind; |
|
int mod,n; |
|
{ |
{ |
int i,j,l,s,h,inv; |
int i,j,l,s,h,inv; |
int *t,*u; |
int *t,*u; |
|
|
} |
} |
} |
} |
|
|
void null_to_sol(mat,ind,mod,n,r) |
void null_to_sol(int **mat,int *ind,int mod,int n,UM *r) |
int **mat; |
|
int *ind; |
|
int mod,n; |
|
UM *r; |
|
{ |
{ |
int i,j,k,l; |
int i,j,k,l; |
int *c; |
int *c; |
Line 1729 null_mod(mat,mod,n,ind) |
|
Line 1585 null_mod(mat,mod,n,ind) |
|
null_to_sol(mat,ind,mod,n,r) |
null_to_sol(mat,ind,mod,n,r) |
*/ |
*/ |
|
|
void newddd(mod,f,r) |
void newddd(int mod,UM f,UM *r) |
int mod; |
|
UM f,*r; |
|
{ |
{ |
register int i,j; |
register int i,j; |
int d,n; |
int d,n; |
|
|
r[j] = 0; |
r[j] = 0; |
} |
} |
|
|
int nfctr_mod(f,mod) |
int nfctr_mod(UM f,int mod) |
int mod; |
|
UM f; |
|
{ |
{ |
register int i,j; |
register int i,j; |
int d,n; |
int d,n; |
|
|
return j; |
return j; |
} |
} |
|
|
int irred_check(f,mod) |
int irred_check(UM f,int mod) |
UM f; |
|
int mod; |
|
{ |
{ |
register int i,j; |
register int i,j; |
int d,n; |
int d,n; |
|
|
return 1; |
return 1; |
} |
} |
|
|
int berlekamp(p,mod,df,tab,r) |
int berlekamp(UM p,int mod,int df,UM *tab,UM *r) |
UM p; |
|
int mod,df; |
|
UM *tab,*r; |
|
{ |
{ |
int n,i,j,k,nf,d,nr; |
int n,i,j,k,nf,d,nr; |
int **mat; |
int **mat; |
|
|
} |
} |
} |
} |
} |
} |
|
/* NOTREACHED */ |
|
error("berlekamp : cannot happen"); |
|
return -1; |
} |
} |
|
|
void minipoly_mod(mod,f,p,mp) |
void minipoly_mod(int mod,UM f,UM p,UM mp) |
int mod; |
|
UM f,p,mp; |
|
{ |
{ |
struct p_pair *list,*l,*l1,*lprev; |
struct p_pair *list,*l,*l1,*lprev; |
int n,d; |
int n,d; |
|
|
} |
} |
} |
} |
|
|
void lnf_mod(mod,n,p0,p1,list,np0,np1) |
void lnf_mod(int mod,int n,UM p0,UM p1,struct p_pair *list,UM np0,UM np1) |
int mod,n; |
|
UM p0,p1; |
|
struct p_pair *list; |
|
UM np0,np1; |
|
{ |
{ |
int inv,h,d1; |
int inv,h,d1; |
UM t0,t1,s0,s1; |
UM t0,t1,s0,s1; |
|
|
} |
} |
} |
} |
|
|
int find_root(mod,p,root) |
int find_root(int mod,UM p,int *root) |
int mod; |
|
UM p; |
|
int *root; |
|
{ |
{ |
UM *r; |
UM *r; |
int i,j; |
int i,j; |
|
|
return j; |
return j; |
} |
} |
|
|
void showum(p) |
void showum(UM p) |
UM p; |
|
{ |
{ |
int i; |
int i; |
int *c; |
int *c; |
|
|
printf("\n"); |
printf("\n"); |
} |
} |
|
|
void showumat(mat,n) |
void showumat(int **mat,int n) |
int **mat; |
|
int n; |
|
{ |
{ |
int i,j; |
int i,j; |
|
|