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

Diff for /OpenXM_contrib2/asir2000/engine/C.c between version 1.1 and 1.13

version 1.1, 1999/12/03 07:39:07 version 1.13, 2003/01/04 09:06:17
Line 1 
Line 1 
 /* $OpenXM: OpenXM/src/asir99/engine/C.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/C.c,v 1.12 2002/11/01 06:47:41 noro Exp $
   */
 #include "ca.h"  #include "ca.h"
 #include "inline.h"  #include "inline.h"
 #include "base.h"  #include "base.h"
Line 6 
Line 54 
 V up_var;  V up_var;
   
 /* binary has at least 32 leading 0 chars. */  /* binary has at least 32 leading 0 chars. */
 void binaryton(binary,np)  void binaryton(char *binary,N *np)
 char *binary;  
 N *np;  
 {  {
         int i,w,len;          int i,w,len;
         N n;          N n;
Line 32  N *np;
Line 78  N *np;
 }  }
   
 /* hex has at least 8 leading 0 chars. */  /* hex has at least 8 leading 0 chars. */
 void hexton(hex,np)  void hexton(char *hex,N *np)
 char *hex;  
 N *np;  
 {  {
         int i,w,len;          int i,w,len;
         N n;          N n;
Line 57  N *np;
Line 101  N *np;
         }          }
 }  }
   
 void ntobn(base,n,nrp)  void ntobn(int base,N n,N *nrp)
 int base;  
 N n,*nrp;  
 {  {
         int i,d,plc;          int i,d,plc;
         unsigned int *c,*x,*w;          unsigned int *c,*x,*w;
Line 95  N n,*nrp;
Line 137  N n,*nrp;
                 BD(nr)[i] = c[i];                  BD(nr)[i] = c[i];
 }  }
   
 void bnton(base,n,nrp)  void bnton(int base,N n,N *nrp)
 int base;  
 N n,*nrp;  
 {  {
         unsigned int carry;          unsigned int carry;
         unsigned int *x,*w;          unsigned int *x,*w;
Line 125  N n,*nrp;
Line 165  N n,*nrp;
                 BD(nr)[i] = x[i];                  BD(nr)[i] = x[i];
 }  }
   
 void ptomp(m,p,pr)  void ptomp(int m,P p,P *pr)
 int m;  
 P p;  
 P *pr;  
 {  {
         DCP dc,dcr,dcr0;          DCP dc,dcr,dcr0;
         Q q;          Q q;
Line 162  P *pr;
Line 199  P *pr;
         }          }
 }  }
   
 void mptop(f,gp)  void mptop(P f,P *gp)
 P f;  
 P *gp;  
 {  {
         DCP dc,dcr,dcr0;          DCP dc,dcr,dcr0;
         Q q;          Q q;
Line 181  P *gp;
Line 216  P *gp;
         }          }
 }  }
   
 void ptolmp(p,pr)  void ptosfp(P p,P *pr)
 P p;  
 P *pr;  
 {  {
         DCP dc,dcr,dcr0;          DCP dc,dcr,dcr0;
           GFS a;
           P t;
   
           if ( !p )
                   *pr = 0;
           else if ( NUM(p) ) {
                   if ( NID((Num)p) == N_GFS )
                           *pr = (P)p;
                   else {
                           qtogfs((Q)p,&a); *pr = (P)a;
                   }
           } else {
                   for ( dc = DC(p), dcr0 = 0; dc; dc = NEXT(dc) ) {
                           ptosfp(COEF(dc),&t);
                           if ( t ) {
                                   NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc); COEF(dcr) = t;
                           }
                   }
                   if ( !dcr0 )
                           *pr = 0;
                   else {
                           NEXT(dcr) = 0; MKP(VR(p),dcr0,*pr);
                   }
           }
   }
   
   void sfptop(P f,P *gp)
   {
           DCP dc,dcr,dcr0;
           Q q;
           MQ fq;
   
           if ( !f )
                   *gp = 0;
           else if ( NUM(f) ) {
                   gfstomq((GFS)f,&fq);
                   STOQ(CONT(fq),q);
                   *gp = (P)q;
           } else {
                   for ( dc = DC(f), dcr0 = 0; dc; dc = NEXT(dc) ) {
                           NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc); sfptop(COEF(dc),&COEF(dcr));
                   }
                   NEXT(dcr) = 0; MKP(VR(f),dcr0,*gp);
           }
   }
   
   void sf_galois_action(P p,Q e,P *pr)
   {
           DCP dc,dcr,dcr0;
           GFS a;
           P t;
   
           if ( !p )
                   *pr = 0;
           else if ( NUM(p) ) {
                   gfs_galois_action((GFS)p,e,&a); *pr = (P)a;
           } else {
                   for ( dc = DC(p), dcr0 = 0; dc; dc = NEXT(dc) ) {
                           sf_galois_action(COEF(dc),e,&t);
                           if ( t ) {
                                   NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc); COEF(dcr) = t;
                           }
                   }
                   if ( !dcr0 )
                           *pr = 0;
                   else {
                           NEXT(dcr) = 0; MKP(VR(p),dcr0,*pr);
                   }
           }
   }
   
   /* GF(pn)={0,1,a,a^2,...} -> GF(pm)={0,1,b,b^2,..} ; a -> b^k */
   
   void sf_embed(P p,int k,int pm,P *pr)
   {
           DCP dc,dcr,dcr0;
           GFS a;
           P t;
   
           if ( !p )
                   *pr = 0;
           else if ( NUM(p) ) {
                   gfs_embed((GFS)p,k,pm,&a); *pr = (P)a;
           } else {
                   for ( dc = DC(p), dcr0 = 0; dc; dc = NEXT(dc) ) {
                           sf_embed(COEF(dc),k,pm,&t);
                           if ( t ) {
                                   NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc); COEF(dcr) = t;
                           }
                   }
                   if ( !dcr0 )
                           *pr = 0;
                   else {
                           NEXT(dcr) = 0; MKP(VR(p),dcr0,*pr);
                   }
           }
   }
   
   void ptolmp(P p,P *pr)
   {
           DCP dc,dcr,dcr0;
         LM a;          LM a;
         P t;          P t;
   
Line 208  P *pr;
Line 342  P *pr;
         }          }
 }  }
   
 void lmptop(f,gp)  void lmptop(P f,P *gp)
 P f;  
 P *gp;  
 {  {
         DCP dc,dcr,dcr0;          DCP dc,dcr,dcr0;
         Q q;          Q q;
Line 227  P *gp;
Line 359  P *gp;
         }          }
 }  }
   
 void ptoum(m,f,wf)  void ptoum(int m,P f,UM wf)
 int m;  
 P f;  
 UM wf;  
 {  {
         unsigned int r;          unsigned int r;
         int i;          int i;
Line 248  UM wf;
Line 377  UM wf;
         degum(wf,UDEG(f));          degum(wf,UDEG(f));
 }  }
   
 void umtop(v,w,f)  void umtop(V v,UM w,P *f)
 V v;  
 UM w;  
 P *f;  
 {  {
         int *c;          int *c;
         DCP dc,dc0;          DCP dc,dc0;
Line 274  P *f;
Line 400  P *f;
         }          }
 }  }
   
 void ptoup(n,nr)  void ptosfum(P f,UM wf)
 P n;  
 UP *nr;  
 {  {
           GFS c;
           int i;
         DCP dc;          DCP dc;
   
           if ( OID(f) == O_N ) {
                   DEG(wf) = 0;
                   ntogfs((Obj)f,&c);
                   COEF(wf)[0] = FTOIF(CONT(c));
                   return;
           }
   
           for ( i = UDEG(f); i >= 0; i-- )
                   COEF(wf)[i] = 0;
   
           for ( dc = DC(f); dc; dc = NEXT(dc) ) {
                   ntogfs((Obj)COEF(dc),&c);
                   if ( c )
                           COEF(wf)[QTOS(DEG(dc))] = FTOIF(CONT(c));
           }
           degum(wf,UDEG(f));
   }
   
   void sfumtop(V v,UM w,P *f)
   {
           int *c;
           DCP dc,dc0;
           int i,t;
           GFS q;
   
           if ( DEG(w) < 0 )
                   *f = 0;
           else if ( DEG(w) == 0 ) {
                   t = COEF(w)[0];
                   t = IFTOF(t);
                   MKGFS(t,q);
                   *f = (P)q;
           } else {
                   for ( i = DEG(w), c = COEF(w), dc0 = 0; i >= 0; i-- )
                           if ( c[i] ) {
                                   NEXTDC(dc0,dc);
                                   STOQ(i,DEG(dc));
                                   t = COEF(w)[i];
                                   t = IFTOF(t);
                                   MKGFS(t,q);
                                   COEF(dc) = (P)q;
                           }
                   NEXT(dc) = 0;
                   MKP(v,dc0,*f);
           }
   }
   
   void ptoup(P n,UP *nr)
   {
           DCP dc;
         UP r;          UP r;
         int d;          int d;
   
Line 297  UP *nr;
Line 474  UP *nr;
         }          }
 }  }
   
 void uptop(n,nr)  void uptop(UP n,P *nr)
 UP n;  
 P *nr;  
 {  {
         int i;          int i;
         DCP dc0,dc;          DCP dc0,dc;
Line 319  P *nr;
Line 494  P *nr;
         }          }
 }  }
   
 void ulmptoum(m,f,wf)  void ulmptoum(int m,UP f,UM wf)
 int m;  
 UP f;  
 UM wf;  
 {  {
         int i,d;          int i,d;
         LM *c;          LM *c;
Line 337  UM wf;
Line 509  UM wf;
         }          }
 }  }
   
 void objtobobj(base,p,rp)  void objtobobj(int base,Obj p,Obj *rp)
 int base;  
 Obj p;  
 Obj *rp;  
 {  {
         if ( !p )          if ( !p )
                 *rp = 0;                  *rp = 0;
Line 363  Obj *rp;
Line 532  Obj *rp;
                 }                  }
 }  }
   
 void bobjtoobj(base,p,rp)  void bobjtoobj(int base,Obj p,Obj *rp)
 int base;  
 Obj p;  
 Obj *rp;  
 {  {
         if ( !p )          if ( !p )
                 *rp = 0;                  *rp = 0;
Line 389  Obj *rp;
Line 555  Obj *rp;
                 }                  }
 }  }
   
 void numtobnum(base,p,rp)  void numtobnum(int base,Num p,Num *rp)
 int base;  
 Num p;  
 Num *rp;  
 {  {
         N nm,dn,body;          N nm,dn,body;
         Q q;          Q q;
Line 422  Num *rp;
Line 585  Num *rp;
                 }                  }
 }  }
   
 void bnumtonum(base,p,rp)  void bnumtonum(int base,Num p,Num *rp)
 int base;  
 Num p;  
 Num *rp;  
 {  {
         N nm,dn,body;          N nm,dn,body;
         Q q;          Q q;
Line 455  Num *rp;
Line 615  Num *rp;
                 }                  }
 }  }
   
 void ptobp(base,p,rp)  void ptobp(int base,P p,P *rp)
 int base;  
 P p;  
 P *rp;  
 {  {
         DCP dcr0,dcr,dc;          DCP dcr0,dcr,dc;
   
Line 474  P *rp;
Line 631  P *rp;
         }          }
 }  }
   
 void bptop(base,p,rp)  void bptop(int base,P p,P *rp)
 int base;  
 P p;  
 P *rp;  
 {  {
         DCP dcr0,dcr,dc;          DCP dcr0,dcr,dc;
   
Line 493  P *rp;
Line 647  P *rp;
         }          }
 }  }
   
 void listtoblist(base,p,rp)  void listtoblist(int base,LIST p,LIST *rp)
 int base;  
 LIST p;  
 LIST *rp;  
 {  {
         NODE nr0,nr,n;          NODE nr0,nr,n;
   
Line 512  LIST *rp;
Line 663  LIST *rp;
         }          }
 }  }
   
 void blisttolist(base,p,rp)  void blisttolist(int base,LIST p,LIST *rp)
 int base;  
 LIST p;  
 LIST *rp;  
 {  {
         NODE nr0,nr,n;          NODE nr0,nr,n;
   
Line 531  LIST *rp;
Line 679  LIST *rp;
         }          }
 }  }
   
 void vecttobvect(base,p,rp)  void vecttobvect(int base,VECT p,VECT *rp)
 int base;  
 VECT p;  
 VECT *rp;  
 {  {
         int i,l;          int i,l;
         VECT r;          VECT r;
Line 549  VECT *rp;
Line 694  VECT *rp;
         }          }
 }  }
   
 void bvecttovect(base,p,rp)  void bvecttovect(int base,VECT p,VECT *rp)
 int base;  
 VECT p;  
 VECT *rp;  
 {  {
         int i,l;          int i,l;
         VECT r;          VECT r;
Line 567  VECT *rp;
Line 709  VECT *rp;
         }          }
 }  }
   
 void mattobmat(base,p,rp)  void mattobmat(int base,MAT p,MAT *rp)
 int base;  
 MAT p;  
 MAT *rp;  
 {  {
         int row,col,i,j;          int row,col,i,j;
         MAT r;          MAT r;
Line 586  MAT *rp;
Line 725  MAT *rp;
         }          }
 }  }
   
 void bmattomat(base,p,rp)  void bmattomat(int base,MAT p,MAT *rp)
 int base;  
 MAT p;  
 MAT *rp;  
 {  {
         int row,col,i,j;          int row,col,i,j;
         MAT r;          MAT r;
Line 605  MAT *rp;
Line 741  MAT *rp;
         }          }
 }  }
   
 void n32ton27(g,rp)  void n32ton27(N g,N *rp)
 N g;  
 N *rp;  
 {  {
         int i,j,k,l,r,bits,words;          int i,j,k,l,r,bits,words;
         unsigned int t;          unsigned int t;
Line 631  N *rp;
Line 765  N *rp;
         b[words-1] &= ((1<<r)-1);          b[words-1] &= ((1<<r)-1);
 }  }
   
 void n27ton32(a,rp)  void n27ton32(N a,N *rp)
 N a;  
 N *rp;  
 {  {
         int i,j,k,l,r,bits,words;          int i,j,k,l,r,bits,words;
         unsigned int t;          unsigned int t;
Line 656  N *rp;
Line 788  N *rp;
         }          }
 }  }
   
 void mptoum(p,pr)  void mptoum(P p,UM pr)
 P p;  
 UM pr;  
 {  {
         DCP dc;          DCP dc;
   
Line 674  UM pr;
Line 804  UM pr;
         }          }
 }  }
   
 void umtomp(v,p,pr)  void umtomp(V v,UM p,P *pr)
 V v;  
 UM p;  
 P *pr;  
 {  {
         DCP dc,dc0;          DCP dc,dc0;
         int i;          int i;
Line 695  P *pr;
Line 822  P *pr;
                         }                          }
                 NEXT(dc) = 0; MKP(v,dc0,*pr);                  NEXT(dc) = 0; MKP(v,dc0,*pr);
         }          }
   }
   
   /* f(p) -> f(x) */
   
   void enc_to_p(int p,int a,V v,P *pr)
   {
           DCP dc,dct;
           int i,c;
           Q dq,cq;
   
           dc = 0;
           for ( i = 0; a; i++, a /= p ) {
                   c = a%p;
                   if ( c ) {
                           STOQ(i,dq); STOQ(c,cq);
                           NEWDC(dct); DEG(dct) = dq; COEF(dct) = (P)cq;
                           NEXT(dct) = dc; dc = dct;
                   }
           }
           MKP(v,dc,*pr);
 }  }
Legend:
Removed from v.1.1  
changed lines
  Added in v.1.13
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>