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

Diff for /OpenXM_contrib2/asir2000/engine/gfpn.c between version 1.4 and 1.5

version 1.4, 2001/10/09 01:36:11 version 1.5, 2018/03/29 01:32:52
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/gfpn.c,v 1.3 2000/08/22 05:04:05 noro Exp $   * $OpenXM: OpenXM_contrib2/asir2000/engine/gfpn.c,v 1.4 2001/10/09 01:36:11 noro Exp $
 */  */
 #include "ca.h"  #include "ca.h"
 #include "base.h"  #include "base.h"
Line 56  UP current_mod_gfpn;
Line 56  UP current_mod_gfpn;
   
 void setmod_gfpn(P p)  void setmod_gfpn(P p)
 {  {
         UP t;    UP t;
   
         ptoup(p,&t); uptolmup(t,&current_mod_gfpn);    ptoup(p,&t); uptolmup(t,&current_mod_gfpn);
 }  }
   
 void getmod_gfpn(UP *up)  void getmod_gfpn(UP *up)
 {  {
         *up = current_mod_gfpn;    *up = current_mod_gfpn;
 }  }
   
 void ptogfpn(Obj q,GFPN *l)  void ptogfpn(Obj q,GFPN *l)
 {  {
         UP q1,q2;    UP q1,q2;
   
         if ( !q || (OID(q)==O_N && NID(q)==N_GFPN) ) {    if ( !q || (OID(q)==O_N && NID(q)==N_GFPN) ) {
                 *l = (GFPN)q;      *l = (GFPN)q;
         } else if ( (OID(q)==O_N && NID(q)==N_Q) || OID(q)==O_P ) {    } else if ( (OID(q)==O_N && NID(q)==N_Q) || OID(q)==O_P ) {
                 ptoup((P)q,&q1); uptolmup(q1,&q2);      ptoup((P)q,&q1); uptolmup(q1,&q2);
                 MKGFPN(q2,*l);      MKGFPN(q2,*l);
         } else    } else
                 error("ptogfpn : invalid argument");      error("ptogfpn : invalid argument");
 }  }
   
 void gfpntop(GFPN q,P *l)  void gfpntop(GFPN q,P *l)
 {  {
         if ( !q )    if ( !q )
                 *l = 0;      *l = 0;
         else if ( NID(q) == N_GFPN )    else if ( NID(q) == N_GFPN )
                 uptop(q->body,l);      uptop(q->body,l);
         else    else
                 *l = (P)q;      *l = (P)q;
 }  }
   
 void simpgfpn(GFPN n,GFPN *r)  void simpgfpn(GFPN n,GFPN *r)
 {  {
         UP rem,t;    UP rem,t;
   
         if ( !n )    if ( !n )
                 *r = 0;      *r = 0;
         else if ( NID(n) != N_GFPN )    else if ( NID(n) != N_GFPN )
                 *r = n;      *r = n;
         else {    else {
                 simpup(n->body,&t);      simpup(n->body,&t);
                 remup(t,current_mod_gfpn,&rem);      remup(t,current_mod_gfpn,&rem);
                 MKGFPN(rem,*r);      MKGFPN(rem,*r);
         }    }
 }  }
   
 #define NZGFPN(a) ((a)&&(OID(a)==O_N)&&(NID(a)==N_GFPN))  #define NZGFPN(a) ((a)&&(OID(a)==O_N)&&(NID(a)==N_GFPN))
   
 void ntogfpn(Obj a,GFPN *b)  void ntogfpn(Obj a,GFPN *b)
 {  {
         UP t;    UP t;
         LM lm;    LM lm;
   
         if ( !a || (OID(a)==O_N && NID(a) == N_GFPN) )    if ( !a || (OID(a)==O_N && NID(a) == N_GFPN) )
                 *b = (GFPN)a;      *b = (GFPN)a;
         else if ( OID(a) == O_N && (NID(a) == N_LM || NID(a) == N_Q) ) {    else if ( OID(a) == O_N && (NID(a) == N_LM || NID(a) == N_Q) ) {
                 qtolm((Q)a,&lm);      qtolm((Q)a,&lm);
                 if ( !lm )      if ( !lm )
                         *b = 0;        *b = 0;
                 else {      else {
                         t = UPALLOC(0); t->d = 0; t->c[0] = (Num)lm;        t = UPALLOC(0); t->d = 0; t->c[0] = (Num)lm;
                         MKGFPN(t,*b);        MKGFPN(t,*b);
                 }      }
         } else    } else
                 error("ntogfpn : invalid argument");      error("ntogfpn : invalid argument");
 }  }
   
 void addgfpn(GFPN a,GFPN b,GFPN *c)  void addgfpn(GFPN a,GFPN b,GFPN *c)
 {  {
         UP t,t1,t2;    UP t,t1,t2;
         GFPN z;    GFPN z;
   
         ntogfpn((Obj)a,&z); a = z; ntogfpn((Obj)b,&z); b = z;    ntogfpn((Obj)a,&z); a = z; ntogfpn((Obj)b,&z); b = z;
         if ( !a )    if ( !a )
                 *c = b;      *c = b;
         else if ( !b )    else if ( !b )
                 *c = a;      *c = a;
         else {    else {
                 addup(a->body,b->body,&t);      addup(a->body,b->body,&t);
                 simpup(t,&t1);      simpup(t,&t1);
                 remup(t1,current_mod_gfpn,&t2);      remup(t1,current_mod_gfpn,&t2);
                 MKGFPN(t2,*c);      MKGFPN(t2,*c);
         }    }
 }  }
   
 void subgfpn(GFPN a,GFPN b,GFPN *c)  void subgfpn(GFPN a,GFPN b,GFPN *c)
 {  {
         UP t,t1,t2;    UP t,t1,t2;
         GFPN z;    GFPN z;
   
         ntogfpn((Obj)a,&z); a = z; ntogfpn((Obj)b,&z); b = z;    ntogfpn((Obj)a,&z); a = z; ntogfpn((Obj)b,&z); b = z;
         if ( !a )    if ( !a )
                 chsgngfpn(b,c);      chsgngfpn(b,c);
         else if ( !b )    else if ( !b )
                 *c = a;      *c = a;
         else {    else {
                 subup(a->body,b->body,&t);      subup(a->body,b->body,&t);
                 simpup(t,&t1);      simpup(t,&t1);
                 remup(t1,current_mod_gfpn,&t2);      remup(t1,current_mod_gfpn,&t2);
                 MKGFPN(t2,*c);      MKGFPN(t2,*c);
         }    }
 }  }
   
 extern int up_lazy;  extern int up_lazy;
   
 void mulgfpn(GFPN a,GFPN b,GFPN *c)  void mulgfpn(GFPN a,GFPN b,GFPN *c)
 {  {
         UP t,t1,t2;    UP t,t1,t2;
         GFPN z;    GFPN z;
   
         ntogfpn((Obj)a,&z); a = z; ntogfpn((Obj)b,&z); b = z;    ntogfpn((Obj)a,&z); a = z; ntogfpn((Obj)b,&z); b = z;
         if ( !a || !b )    if ( !a || !b )
                 *c = 0;      *c = 0;
         else {    else {
                 up_lazy=1;      up_lazy=1;
                 mulup(a->body,b->body,&t);      mulup(a->body,b->body,&t);
                 up_lazy=0;      up_lazy=0;
                 simpup(t,&t1);      simpup(t,&t1);
                 remup(t1,current_mod_gfpn,&t2);      remup(t1,current_mod_gfpn,&t2);
                 MKGFPN(t2,*c);      MKGFPN(t2,*c);
         }    }
 }  }
   
 void squaregfpn(GFPN a,GFPN *c)  void squaregfpn(GFPN a,GFPN *c)
 {  {
         UP t,t1,t2;    UP t,t1,t2;
         GFPN z;    GFPN z;
   
         ntogfpn((Obj)a,&z); a = z;    ntogfpn((Obj)a,&z); a = z;
         if ( !a )    if ( !a )
                 *c = 0;      *c = 0;
         else {    else {
                 squareup(a->body,&t);      squareup(a->body,&t);
                 simpup(t,&t1);      simpup(t,&t1);
                 remup(t1,current_mod_gfpn,&t2);      remup(t1,current_mod_gfpn,&t2);
                 MKGFPN(t2,*c);      MKGFPN(t2,*c);
         }    }
 }  }
   
 void divgfpn(GFPN a,GFPN b,GFPN *c)  void divgfpn(GFPN a,GFPN b,GFPN *c)
 {  {
         UP t,t1,i,s;    UP t,t1,i,s;
         GFPN z;    GFPN z;
   
         ntogfpn((Obj)a,&z); a = z; ntogfpn((Obj)b,&z); b = z;    ntogfpn((Obj)a,&z); a = z; ntogfpn((Obj)b,&z); b = z;
         if ( !b )    if ( !b )
                 error("divgfpn: division by 0");      error("divgfpn: division by 0");
         else if ( !a )    else if ( !a )
                 *c = 0;      *c = 0;
         else {    else {
                 extended_gcdup(b->body,current_mod_gfpn,&i);      extended_gcdup(b->body,current_mod_gfpn,&i);
                 mulup(a->body,i,&t);      mulup(a->body,i,&t);
                 simpup(t,&t1);      simpup(t,&t1);
                 remup(t1,current_mod_gfpn,&s);      remup(t1,current_mod_gfpn,&s);
                 MKGFPN(s,*c);      MKGFPN(s,*c);
         }    }
 }  }
   
 void invgfpn(GFPN b,GFPN *c)  void invgfpn(GFPN b,GFPN *c)
 {  {
         UP i,t;    UP i,t;
         GFPN z;    GFPN z;
   
         ntogfpn((Obj)b,&z); b = z;    ntogfpn((Obj)b,&z); b = z;
         if ( !b )    if ( !b )
                 error("divgfpn: division by 0");      error("divgfpn: division by 0");
         else {    else {
                 simpup(b->body,&t);      simpup(b->body,&t);
                 extended_gcdup(t,current_mod_gfpn,&i);      extended_gcdup(t,current_mod_gfpn,&i);
                 MKGFPN(i,*c);      MKGFPN(i,*c);
         }    }
 }  }
   
 void chsgngfpn(GFPN a,GFPN *c)  void chsgngfpn(GFPN a,GFPN *c)
 {  {
         GFPN z;    GFPN z;
         UP t,t1;    UP t,t1;
   
         ntogfpn((Obj)a,&z); a = z;    ntogfpn((Obj)a,&z); a = z;
         if ( !a )    if ( !a )
                 *c = 0;      *c = 0;
         else {    else {
                 simpup(a->body,&t);      simpup(a->body,&t);
                 chsgnup(t,&t1);      chsgnup(t,&t1);
                 MKGFPN(t1,*c);      MKGFPN(t1,*c);
         }    }
 }  }
   
 void pwrgfpn(GFPN a,Q b,GFPN *c)  void pwrgfpn(GFPN a,Q b,GFPN *c)
 {  {
         UP t,s;    UP t,s;
         GFPN r;    GFPN r;
         Q b0;    Q b0;
   
         if ( !b ) {    if ( !b ) {
                 t = UPALLOC(0); t->d = 0; t->c[0] = (Num)ONELM; MKGFPN(t,*c);      t = UPALLOC(0); t->d = 0; t->c[0] = (Num)ONELM; MKGFPN(t,*c);
         } else if ( !a )    } else if ( !a )
                 *c = 0;      *c = 0;
         else {    else {
                 DUPQ(b,b0); SGN(b0)=1;      DUPQ(b,b0); SGN(b0)=1;
                 simpup(a->body,&s);      simpup(a->body,&s);
                 hybrid_generic_powermodup(s,current_mod_gfpn,b0,&t);      hybrid_generic_powermodup(s,current_mod_gfpn,b0,&t);
                 MKGFPN(t,r);      MKGFPN(t,r);
                 if ( SGN(b) < 0 )      if ( SGN(b) < 0 )
                         invgfpn(r,c);        invgfpn(r,c);
                 else      else
                         *c = r;        *c = r;
         }    }
 }  }
   
 int cmpgfpn(GFPN a,GFPN b)  int cmpgfpn(GFPN a,GFPN b)
 {  {
         GFPN z;    GFPN z;
   
         ntogfpn((Obj)a,&z); a = z; ntogfpn((Obj)b,&z); b = z;    ntogfpn((Obj)a,&z); a = z; ntogfpn((Obj)b,&z); b = z;
         if ( !a )    if ( !a )
                 if ( !b )      if ( !b )
                         return 0;        return 0;
                 else      else
                         return -1;        return -1;
         else if ( !b )    else if ( !b )
                         return 1;        return 1;
         else    else
                 return compup(a->body,b->body);      return compup(a->body,b->body);
 }  }
   
 void randomgfpn(GFPN *r)  void randomgfpn(GFPN *r)
 {  {
         int i,d;    int i,d;
         LM *tb;    LM *tb;
         UP t;    UP t;
   
         if ( !current_mod_gfpn )    if ( !current_mod_gfpn )
                 error("randomgfpn : current_mod_gfpn is not set");      error("randomgfpn : current_mod_gfpn is not set");
         d = current_mod_gfpn->d;    d = current_mod_gfpn->d;
         t = UPALLOC(d-1);    t = UPALLOC(d-1);
         for ( i = 0, tb = (LM *)t->c; i < d; i++ )    for ( i = 0, tb = (LM *)t->c; i < d; i++ )
                 random_lm(&tb[i]);      random_lm(&tb[i]);
         for ( i = d-1; i >= 0 && !tb[i]; i-- );    for ( i = d-1; i >= 0 && !tb[i]; i-- );
         if ( i < 0 )    if ( i < 0 )
                 *r = 0;      *r = 0;
         else {    else {
                 t->d = i; MKGFPN(t,*r);      t->d = i; MKGFPN(t,*r);
         }    }
 }  }
Legend:
Removed from v.1.4  
changed lines
  Added in v.1.5
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>