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

Diff for /OpenXM_contrib2/asir2000/engine/gfs.c between version 1.6 and 1.10

version 1.6, 2001/06/20 09:30:34 version 1.10, 2001/11/06 09:40:36
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/gfs.c,v 1.5 2001/05/28 08:22:01 noro Exp $   * $OpenXM: OpenXM_contrib2/asir2000/engine/gfs.c,v 1.9 2001/10/09 01:36:12 noro Exp $
 */  */
 #include "ca.h"  #include "ca.h"
   
Line 59  int *current_gfs_plus1;
Line 59  int *current_gfs_plus1;
 int *current_gfs_ntoi;  int *current_gfs_ntoi;
 int *current_gfs_iton;  int *current_gfs_iton;
   
 void chsgngfs();  
 void generate_defpoly_um();  
   
 struct prim_root_info {  struct prim_root_info {
         int p;          int p;
         int extdeg;          int extdeg;
Line 473  struct prim_root_info prim_root_info_tab[] = {
Line 470  struct prim_root_info prim_root_info_tab[] = {
 {16349,1,0,2}, {16361,1,0,3}, {16363,1,0,2}, {16369,1,0,7}, {16381,1,0,2},  {16349,1,0,2}, {16361,1,0,3}, {16363,1,0,2}, {16369,1,0,7}, {16381,1,0,2},
 };  };
   
 void dec_um(p,a,u)  void dec_um(int p,int a,UM u)
 int p,a;  
 UM u;  
 {  {
         int i;          int i;
   
Line 491  UM u;
Line 486  UM u;
  * current_gfs_iton[p-1] = 0   * current_gfs_iton[p-1] = 0
  */   */
   
 void setmod_sf(p,n)  void setmod_sf(int p,int n)
 int p,n;  
 {  {
         int r,i,q1,q,t,t1;          int r,i,q1,q,t,t1;
         UM dp;          UM dp;
Line 504  int p,n;
Line 498  int p,n;
         if ( !r ) {          if ( !r ) {
                 generate_defpoly_um(p,n,dp);                  generate_defpoly_um(p,n,dp);
                 r = generate_primitive_root_enc(p,n,dp);                  r = generate_primitive_root_enc(p,n,dp);
                   if ( !r )
                           error("setmod_sf : primitive root not found");
         }          }
         current_gfs_p = p;          current_gfs_p = p;
         current_gfs_q = q;          current_gfs_q = q;
Line 531  int p,n;
Line 527  int p,n;
         }          }
 }  }
   
 int search_defpoly_and_primitive_root(p,n,dp)  int search_defpoly_and_primitive_root(int p,int n,UM dp)
 int p,n;  
 UM dp;  
 {  {
         int l,min,max,mid,p1,i,ind,t;          int l,min,max,mid,p1,i,ind,t;
   
Line 570  UM dp;
Line 564  UM dp;
         return prim_root_info_tab[i].prim_root;          return prim_root_info_tab[i].prim_root;
 }  }
   
 void generate_defpoly_um(p,n,dp)  void generate_defpoly_um(int p,int n,UM dp)
 int p,n;  
 UM dp;  
 {  {
         int i,j,a,c,q;          int i,j,a,q;
         UM wf,wdf,wgcd;          UM wf,wdf,wgcd;
   
         wf = W_UMALLOC(n);          wf = W_UMALLOC(n);
Line 600  UM dp;
Line 592  UM dp;
         }          }
 }  }
   
 int generate_primitive_root_enc(p,n,dp)  int generate_primitive_root_enc(int p,int n,UM dp)
 int p,n;  
 UM dp;  
 {  {
         int i,r,rj,j,q;          int i,r,rj,j,q;
   
Line 618  UM dp;
Line 608  UM dp;
                 if ( j == q-1 )                  if ( j == q-1 )
                         return r;                          return r;
         }          }
           /* not found */
           return 0;
 }  }
   
 /* [a(p)]*[b(p)] in GF(p^n) -> [a(x)*b(x) mod dp(x)]_{x->p} */  /* [a(p)]*[b(p)] in GF(p^n) -> [a(x)*b(x) mod dp(x)]_{x->p} */
   
 int mulremum_enc(p,n,dp,a,b)  int mulremum_enc(int p,int n,UM dp,int a,int b)
 int p,n;  
 UM dp;  
 int a,b;  
 {  {
         int i,dr,r;          int i,dr,r;
         UM wa,wb,wc,wq;          UM wa,wb,wc,wq;
Line 650  int a,b;
Line 639  int a,b;
         return r;          return r;
 }  }
   
 void gfs_galois_action(a,e,c)  /* sigma : alpha -> alpha^q */
 GFS a;  
 Q e;  void gfs_galois_action(GFS a,Q e,GFS *c)
 GFS *c;  
 {  {
         Q p;          Q q;
         int i,k;          int i,k;
         GFS t,s;          GFS t,s;
   
         t = a;          t = a;
         k = QTOS(e);          k = QTOS(e);
         STOQ(current_gfs_p,p);          STOQ(current_gfs_q,q);
         for ( i = 0; i < k; i++ ) {          for ( i = 0; i < k; i++ ) {
                 pwrgfs(t,p,&s); t = s;                  pwrgfs(t,q,&s); t = s;
         }          }
         *c = t;          *c = t;
 }  }
   
 void qtogfs(a,c)  /* GF(pn)={0,1,a,a^2,...} -> GF(pm)={0,1,b,b^2,...}; a->b^k */
 Q a;  
 GFS *c;  void gfs_embed(GFS z,int k,int pm,GFS *c)
 {  {
           int t;
   
           if ( !z )
                   *c = 0;
           else {
                   t = dmar(k,CONT(z),0,pm-1);
                   MKGFS(t,*c);
           }
   }
   
   void qtogfs(Q a,GFS *c)
   {
         int s;          int s;
   
         s = QTOS(a)%current_gfs_q;          s = QTOS(a)%current_gfs_q;
Line 683  GFS *c;
Line 683  GFS *c;
                 MKGFS(current_gfs_ntoi[s],*c);                  MKGFS(current_gfs_ntoi[s],*c);
 }  }
   
 void mqtogfs(a,c)  void mqtogfs(MQ a,GFS *c)
 MQ a;  
 GFS *c;  
 {  {
         if ( !a )          if ( !a )
                 *c = 0;                  *c = 0;
Line 694  GFS *c;
Line 692  GFS *c;
         }          }
 }  }
   
 void gfstomq(a,c)  void gfstomq(GFS a,MQ *c)
 GFS a;  
 MQ *c;  
 {  {
         if ( !a )          if ( !a )
                 *c = 0;                  *c = 0;
Line 705  MQ *c;
Line 701  MQ *c;
         }          }
 }  }
   
 void ntogfs(a,b)  void ntogfs(Obj a,GFS *b)
 Obj a;  
 GFS *b;  
 {  {
         P t;          P t;
   
Line 716  GFS *b;
Line 710  GFS *b;
         if ( !a || (OID(a)==O_N && NID(a) == N_GFS) )          if ( !a || (OID(a)==O_N && NID(a) == N_GFS) )
                 *b = (GFS)a;                  *b = (GFS)a;
         else if ( OID(a) == O_N && NID(a) == N_M )          else if ( OID(a) == O_N && NID(a) == N_M )
                 mqtogfs(a,b);                  mqtogfs((MQ)a,b);
         else if ( OID(a) == O_N && NID(a) == N_Q ) {          else if ( OID(a) == O_N && NID(a) == N_Q ) {
                 ptomp(current_gfs_p,(P)a,&t); mqtogfs(t,b);                  ptomp(current_gfs_p,(P)a,&t); mqtogfs((MQ)t,b);
         } else          } else
                 error("ntogfs : invalid argument");                  error("ntogfs : invalid argument");
 }  }
   
 void addgfs(a,b,c)  void addgfs(GFS a,GFS b,GFS *c)
 GFS a,b;  
 GFS *c;  
 {  {
         int ai,bi,ci;          int ai,bi,ci;
         GFS z;          GFS z;
   
         ntogfs(a,&z); a = z;          ntogfs((Obj)a,&z); a = z;
         ntogfs(b,&z); b = z;          ntogfs((Obj)b,&z); b = z;
         if ( !a )          if ( !a )
                 *c = b;                  *c = b;
         else if ( !b )          else if ( !b )
Line 764  GFS *c;
Line 756  GFS *c;
         }          }
 }  }
   
 void subgfs(a,b,c)  void subgfs(GFS a,GFS b,GFS *c)
 GFS a,b;  
 GFS *c;  
 {  {
         GFS t,z;          GFS t,z;
   
         ntogfs(a,&z); a = z;          ntogfs((Obj)a,&z); a = z;
         ntogfs(b,&z); b = z;          ntogfs((Obj)b,&z); b = z;
         if ( !b )          if ( !b )
                 *c = a;                  *c = a;
         else {          else {
Line 780  GFS *c;
Line 770  GFS *c;
         }          }
 }  }
   
 void mulgfs(a,b,c)  void mulgfs(GFS a,GFS b,GFS *c)
 GFS a,b;  
 GFS *c;  
 {  {
         int ai;          int ai;
         GFS z;          GFS z;
   
         ntogfs(a,&z); a = z;          ntogfs((Obj)a,&z); a = z;
         ntogfs(b,&z); b = z;          ntogfs((Obj)b,&z); b = z;
         if ( !a || !b )          if ( !a || !b )
                 *c = 0;                  *c = 0;
         else {          else {
Line 799  GFS *c;
Line 787  GFS *c;
         }          }
 }  }
   
 void divgfs(a,b,c)  void divgfs(GFS a,GFS b,GFS *c)
 GFS a,b;  
 GFS *c;  
 {  {
         int ai;          int ai;
         GFS z;          GFS z;
   
         ntogfs(a,&z); a = z;          ntogfs((Obj)a,&z); a = z;
         ntogfs(b,&z); b = z;          ntogfs((Obj)b,&z); b = z;
         if ( !b )          if ( !b )
                 error("divgfs : division by 0");                  error("divgfs : division by 0");
         else if ( !a )          else if ( !a )
Line 820  GFS *c;
Line 806  GFS *c;
         }          }
 }  }
   
 void chsgngfs(a,c)  void chsgngfs(GFS a,GFS *c)
 GFS a,*c;  
 {  {
         int ai;          int ai;
         GFS z;          GFS z;
   
         ntogfs(a,&z); a = z;          ntogfs((Obj)a,&z); a = z;
         if ( !a )          if ( !a )
                 *c = 0;                  *c = 0;
         else if ( current_gfs_q1&1 )          else if ( current_gfs_q1&1 )
Line 840  GFS a,*c;
Line 825  GFS a,*c;
         }          }
 }  }
   
 void pwrgfs(a,b,c)  void pwrgfs(GFS a,Q b,GFS *c)
 GFS a;  
 Q b;  
 GFS *c;  
 {  {
         N an,tn,rn;          N an,tn,rn;
         GFS t,s,z;          GFS t,s,z;
   
         ntogfs(a,&z); a = z;          ntogfs((Obj)a,&z); a = z;
         if ( !b )          if ( !b )
                 MKGFS(0,*c);                  MKGFS(0,*c);
         else if ( !a )          else if ( !a )
Line 868  GFS *c;
Line 850  GFS *c;
         }          }
 }  }
   
 int cmpgfs(a,b)  int cmpgfs(GFS a,GFS b)
 GFS a,b;  
 {  {
         GFS z;          GFS z;
   
         ntogfs(a,&z); a = z;          ntogfs((Obj)a,&z); a = z;
         if ( !a )          if ( !a )
                 return !b ? 0 : -1;                  return !b ? 0 : -1;
         else          else
Line 889  GFS a,b;
Line 870  GFS a,b;
                 }                  }
 }  }
   
 void randomgfs(r)  void randomgfs(GFS *r)
 GFS *r;  
 {  {
         unsigned int t;          unsigned int t;
   
Line 900  GFS *r;
Line 880  GFS *r;
         if ( !t )          if ( !t )
                 *r = 0;                  *r = 0;
         else {          else {
                 if ( t == current_gfs_q1 )                  if ( t == (unsigned int)current_gfs_q1 )
                         t = 0;                          t = 0;
                 MKGFS(t,*r);                  MKGFS(t,*r);
         }          }
Line 908  GFS *r;
Line 888  GFS *r;
   
 /* arithmetic operations for 'immediate values of GFS */  /* arithmetic operations for 'immediate values of GFS */
   
 int _addsf(a,b)  int _addsf(int a,int b)
 int a,b;  
 {  {
         if ( !a )          if ( !a )
                 return b;                  return b;
Line 942  int a,b;
Line 921  int a,b;
         }          }
 }  }
   
 int _chsgnsf(a)  int _chsgnsf(int a)
 int a;  
 {  {
         if ( !a )          if ( !a )
                 return 0;                  return 0;
Line 959  int a;
Line 937  int a;
         }          }
 }  }
   
 int _subsf(a,b)  int _subsf(int a,int b)
 int a,b;  
 {  {
         if ( !a )          if ( !a )
                 return _chsgnsf(b);                  return _chsgnsf(b);
Line 970  int a,b;
Line 947  int a,b;
                 return _addsf(a,_chsgnsf(b));                  return _addsf(a,_chsgnsf(b));
 }  }
   
 int _mulsf(a,b)  int _mulsf(int a,int b)
 int a,b;  
 {  {
         if ( !a || !b )          if ( !a || !b )
                 return 0;                  return 0;
Line 983  int a,b;
Line 959  int a,b;
         }          }
 }  }
   
 int _invsf(a)  int _invsf(int a)
 int a;  
 {  {
         if ( !a )          if ( !a ) {
                 error("_invsf : division by 0");                  error("_invsf : division by 0");
         else {                  /* NOTREACHED */
                   return -1;
           } else {
                 a = current_gfs_q1 - IFTOF(a);                  a = current_gfs_q1 - IFTOF(a);
                 return FTOIF(a);                  return FTOIF(a);
         }          }
 }  }
   
 int _divsf(a,b)  int _divsf(int a,int b)
 int a,b;  
 {  {
         if ( !b )          if ( !b ) {
                 error("_divsf : division by 0");                  error("_divsf : division by 0");
         else if ( !a )                  /* NOTREACHED */
                   return -1;
           } else if ( !a )
                 return 0;                  return 0;
         else {          else {
                 a = IFTOF(a) - IFTOF(b);                  a = IFTOF(a) - IFTOF(b);
Line 1009  int a,b;
Line 987  int a,b;
         }          }
 }  }
   
 int _pwrsf(a,b)  int _pwrsf(int a,int b)
 int a,b;  
 {  {
         GFS at,ct;          GFS at,ct;
         Q bt;          Q bt;
Line 1035  int _onesf()
Line 1012  int _onesf()
         return FTOIF(0);          return FTOIF(0);
 }  }
   
 int _itosf(n)  int _itosf(int n)
 int n;  
 {  {
         int i;          int i;
   
Line 1050  int n;
Line 1026  int n;
         return i;          return i;
 }  }
   
 int _isonesf(a)  int _isonesf(int a)
 int a;  
 {  {
         return a == FTOIF(0);          return a == FTOIF(0);
 }  }
Line 1077  int characteristic_sf()
Line 1052  int characteristic_sf()
         return current_gfs_p;          return current_gfs_p;
 }  }
   
   int extdeg_sf()
   {
           return UDEG(current_gfs_ext);
   }
Legend:
Removed from v.1.6  
changed lines
  Added in v.1.10
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>