[BACK]Return to H.c CVS log [TXT][DIR] Up to [local] / OpenXM_contrib2 / asir2000 / engine

Diff for /OpenXM_contrib2/asir2000/engine/H.c between version 1.5 and 1.6

version 1.5, 2001/07/04 07:19:20 version 1.6, 2001/10/09 01:36:09
Line 45 
Line 45 
  * 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;
Line 153  ML *listp;
Line 108  ML *listp;
                 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;
Line 183  UM f;
Line 136  UM f;
   
 /* 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;
Line 244  UM *fp;
Line 191  UM *fp;
         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;
Line 284  ML *listp;
Line 228  ML *listp;
         }          }
 }  }
   
 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 ) {
Line 370  ML *listp;
Line 309  ML *listp;
         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);
Line 510  LUM *gp;
Line 445  LUM *gp;
                         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;
   
Line 522  LUM f;
Line 455  LUM f;
   
 /* 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;
   
Line 534  LUM g;
Line 464  LUM g;
                 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;
Line 663  DCP *dcp;
Line 590  DCP *dcp;
         *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;
Line 916  P f;
Line 832  P f;
         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;
Line 935  P f;
Line 849  P f;
         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;
Line 973  int exp;
Line 885  int exp;
         }          }
 }  }
   
 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;
Line 1009  LUM fl;
Line 918  LUM fl;
         }          }
 }  }
   
 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;
Line 1104  DCP *dcp;
Line 1010  DCP *dcp;
         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;
Line 1232  UM p1,p2,gr;
Line 1133  UM p1,p2,gr;
         }          }
 }  }
   
 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;
Line 1268  UM *fp;
Line 1166  UM *fp;
         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;
Line 1291  int a;
Line 1186  int a;
 }  }
 #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;
Line 1339  UM f,*r;
Line 1232  UM f,*r;
 }  }
   
 #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;
Line 1379  UM f,*base,*r;
Line 1270  UM f,*base,*r;
         }          }
 }  }
 #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;
Line 1420  UM f,*base,*r;
Line 1309  UM f,*base,*r;
 }  }
 #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;
Line 1432  UM p;
Line 1319  UM p;
                 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;
   
Line 1460  UM p,f,pr;
Line 1345  UM p,f,pr;
         }          }
 }  }
   
 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;
Line 1492  N e;
Line 1373  N e;
         }          }
 }  }
   
 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;
Line 1518  N e;
Line 1396  N e;
 }  }
   
 #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;
Line 1539  UM p1,p2,pr;
Line 1415  UM p1,p2,pr;
         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;
Line 1551  UM p,pr;
Line 1425  UM p,pr;
                 *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;
Line 1589  UM p1,p2,pq;
Line 1461  UM p1,p2,pq;
         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;
Line 1618  UM p1,p2,pr;
Line 1488  UM p1,p2,pr;
 }  }
 #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;
Line 1639  int mod,d;
Line 1506  int mod,d;
                 }                  }
 }  }
   
 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;
Line 1662  int ***mp;
Line 1525  int ***mp;
                 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;
Line 1696  int mod,n;
Line 1556  int mod,n;
         }          }
 }  }
   
 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;
Line 1774  UM f,*r;
Line 1628  UM f,*r;
         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;
Line 1817  UM f;
Line 1669  UM f;
         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;
Line 1862  int mod;
Line 1712  int mod;
         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;
Line 1911  UM *tab,*r;
Line 1758  UM *tab,*r;
                         }                          }
                 }                  }
         }          }
           /* 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;
Line 1950  UM f,p,mp;
Line 1798  UM f,p,mp;
         }          }
 }  }
   
 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;
Line 1974  UM np0,np1;
Line 1818  UM np0,np1;
         }          }
 }  }
   
 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;
Line 1990  int *root;
Line 1831  int *root;
         return j;          return j;
 }  }
   
 void showum(p)  void showum(UM p)
 UM p;  
 {  {
         int i;          int i;
         int *c;          int *c;
Line 2002  UM p;
Line 1842  UM p;
         printf("\n");          printf("\n");
 }  }
   
 void showumat(mat,n)  void showumat(int **mat,int n)
 int **mat;  
 int n;  
 {  {
         int i,j;          int i,j;
   
Legend:
Removed from v.1.5  
changed lines
  Added in v.1.6
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>