[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.1 and 1.5

version 1.1, 1999/12/03 07:39:08 version 1.5, 2018/03/29 01:32:52
Line 1 
Line 1 
 /* $OpenXM: OpenXM/src/asir99/engine/gfpn.c,v 1.1.1.1 1999/11/10 08:12:26 noro Exp $ */  /*
    * Copyright (c) 1994-2000 FUJITSU LABORATORIES LIMITED
    * All rights reserved.
    *
    * FUJITSU LABORATORIES LIMITED ("FLL") hereby grants you a limited,
    * non-exclusive and royalty-free license to use, copy, modify and
    * redistribute, solely for non-commercial and non-profit purposes, the
    * computer program, "Risa/Asir" ("SOFTWARE"), subject to the terms and
    * conditions of this Agreement. For the avoidance of doubt, you acquire
    * only a limited right to use the SOFTWARE hereunder, and FLL or any
    * third party developer retains all rights, including but not limited to
    * copyrights, in and to the SOFTWARE.
    *
    * (1) FLL does not grant you a license in any way for commercial
    * purposes. You may use the SOFTWARE only for non-commercial and
    * non-profit purposes only, such as academic, research and internal
    * business use.
    * (2) The SOFTWARE is protected by the Copyright Law of Japan and
    * international copyright treaties. If you make copies of the SOFTWARE,
    * with or without modification, as permitted hereunder, you shall affix
    * to all such copies of the SOFTWARE the above copyright notice.
    * (3) An explicit reference to this SOFTWARE and its copyright owner
    * shall be made on your publication or presentation in any form of the
    * results obtained by use of the SOFTWARE.
    * (4) In the event that you modify the SOFTWARE, you shall notify FLL by
    * e-mail at risa-admin@sec.flab.fujitsu.co.jp of the detailed specification
    * for such modification or the source code of the modified part of the
    * SOFTWARE.
    *
    * THE SOFTWARE IS PROVIDED AS IS WITHOUT ANY WARRANTY OF ANY KIND. FLL
    * MAKES ABSOLUTELY NO WARRANTIES, EXPRESSED, IMPLIED OR STATUTORY, AND
    * EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS
    * FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT OF THIRD PARTIES'
    * RIGHTS. NO FLL DEALER, AGENT, EMPLOYEES IS AUTHORIZED TO MAKE ANY
    * MODIFICATIONS, EXTENSIONS, OR ADDITIONS TO THIS WARRANTY.
    * UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, TORT, CONTRACT,
    * OR OTHERWISE, SHALL FLL BE LIABLE TO YOU OR ANY OTHER PERSON FOR ANY
    * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL
    * DAMAGES OF ANY CHARACTER, INCLUDING, WITHOUT LIMITATION, DAMAGES
    * ARISING OUT OF OR RELATING TO THE SOFTWARE OR THIS AGREEMENT, DAMAGES
    * FOR LOSS OF GOODWILL, WORK STOPPAGE, OR LOSS OF DATA, OR FOR ANY
    * DAMAGES, EVEN IF FLL SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF
    * SUCH DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY. EVEN IF A PART
    * OF THE SOFTWARE HAS BEEN DEVELOPED BY A THIRD PARTY, THE THIRD PARTY
    * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
    * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.
    *
    * $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 6  void chsgngfpn(GFPN,GFPN *);
Line 54  void chsgngfpn(GFPN,GFPN *);
   
 UP current_mod_gfpn;  UP current_mod_gfpn;
   
 void setmod_gfpn(p)  void setmod_gfpn(P p)
 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)  void getmod_gfpn(UP *up)
 UP *up;  
 {  {
         *up = current_mod_gfpn;    *up = current_mod_gfpn;
 }  }
   
 void ptogfpn(q,l)  void ptogfpn(Obj q,GFPN *l)
 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(q,l)  void gfpntop(GFPN q,P *l)
 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(n,r)  void simpgfpn(GFPN n,GFPN *r)
 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(a,b)  void ntogfpn(Obj a,GFPN *b)
 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(a,b,c)  void addgfpn(GFPN a,GFPN b,GFPN *c)
 GFPN a,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(a,b,c)  void subgfpn(GFPN a,GFPN b,GFPN *c)
 GFPN a,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(a,b,c)  void mulgfpn(GFPN a,GFPN b,GFPN *c)
 GFPN a,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(a,c)  void squaregfpn(GFPN a,GFPN *c)
 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(a,b,c)  void divgfpn(GFPN a,GFPN b,GFPN *c)
 GFPN a,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(b,c)  void invgfpn(GFPN b,GFPN *c)
 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(a,c)  void chsgngfpn(GFPN a,GFPN *c)
 GFPN a,*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(a,b,c)  void pwrgfpn(GFPN a,Q b,GFPN *c)
 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(a,b)  int cmpgfpn(GFPN a,GFPN b)
 GFPN a,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(r)  void randomgfpn(GFPN *r)
 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.1  
changed lines
  Added in v.1.5
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>