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

Diff for /OpenXM_contrib2/asir2000/engine/Q.c between version 1.1.1.1 and 1.9

version 1.1.1.1, 1999/12/03 07:39:08 version 1.9, 2002/08/14 04:49:52
Line 1 
Line 1 
 /* $OpenXM: OpenXM/src/asir99/engine/Q.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/Q.c,v 1.8 2002/08/08 10:57:01 noro Exp $
   */
 #include "ca.h"  #include "ca.h"
 #include "base.h"  #include "base.h"
 #include "inline.h"  #include "inline.h"
   
 void addq(n1,n2,nr)  void addq(Q n1,Q n2,Q *nr)
 Q n1,n2,*nr;  
 {  {
         N nm,dn,nm1,nm2,nm3,dn0,dn1,dn2,g,g1,g0,m;          N nm,dn,nm1,nm2,nm3,dn0,dn1,dn2,g,g1,g0,m;
         int sgn;          int sgn;
Line 87  Q n1,n2,*nr;
Line 134  Q n1,n2,*nr;
         }          }
 }  }
   
 void subq(n1,n2,nr)  void subq(Q n1,Q n2,Q *nr)
 Q n1,n2,*nr;  
 {  {
         Q m;          Q m;
   
Line 107  Q n1,n2,*nr;
Line 153  Q n1,n2,*nr;
         }          }
 }  }
   
 void mulq(n1,n2,nr)  void mulq(Q n1,Q n2,Q *nr)
 Q n1,n2,*nr;  
 {  {
         N nm,nm1,nm2,dn,dn1,dn2,g;          N nm,nm1,nm2,dn,dn1,dn2,g;
         int sgn;          int sgn;
Line 154  Q n1,n2,*nr;
Line 199  Q n1,n2,*nr;
         }          }
 }  }
   
 void divq(n1,n2,nq)  void divq(Q n1,Q n2,Q *nq)
 Q n1,n2,*nq;  
 {  {
         Q m;          Q m;
   
Line 172  Q n1,n2,*nq;
Line 216  Q n1,n2,*nq;
         }          }
 }  }
   
 void invq(n,nr)  void divsq(Q n1,Q n2,Q *nq)
 Q n,*nr;  
 {  {
           int sgn;
           N tn;
   
           if ( !n2 ) {
                   error("division by 0");
                   *nq = 0;
                   return;
           } else if ( !n1 )
                   *nq = 0;
           else if ( n1 == n2 )
                   *nq = ONE;
           else {
                   divsn(NM(n1),NM(n2),&tn);
                   sgn = SGN(n1)*SGN(n2);
                   NTOQ(tn,sgn,*nq);
           }
   }
   
   void invq(Q n,Q *nr)
   {
         N nm,dn;          N nm,dn;
   
         if ( INT(n) )          if ( INT(n) )
Line 194  Q n,*nr;
Line 257  Q n,*nr;
         }          }
 }  }
   
 void chsgnq(n,nr)  void chsgnq(Q n,Q *nr)
 Q n,*nr;  
 {  {
         Q t;          Q t;
   
Line 206  Q n,*nr;
Line 268  Q n,*nr;
         }          }
 }  }
   
 void pwrq(n1,n,nr)  void pwrq(Q n1,Q n,Q *nr)
 Q n1,n,*nr;  
 {  {
         N nm,dn;          N nm,dn;
         int sgn;          int sgn;
Line 247  Q n1,n,*nr;
Line 308  Q n1,n,*nr;
         }          }
 }  }
   
 int cmpq(q1,q2)  int cmpq(Q q1,Q q2)
 Q q1,q2;  
 {  {
         int sgn;          int sgn;
         N t,s;          N t,s;
Line 282  Q q1,q2;
Line 342  Q q1,q2;
         }          }
 }  }
   
 void remq(n,m,nr)  void remq(Q n,Q m,Q *nr)
 Q n,m;  
 Q *nr;  
 {  {
         N q,r,s;          N q,r,s;
   
Line 302  Q *nr;
Line 360  Q *nr;
         }          }
 }  }
   
 void mkbc(n,t)  /* t = [nC0 nC1 ... nCn] */
 int n;  
 Q *t;  void mkbc(int n,Q *t)
 {  {
         int i;          int i;
         N c,d;          N c,d;
Line 317  Q *t;
Line 375  Q *t;
                 t[i] = t[n-i];                  t[i] = t[n-i];
 }  }
   
 void factorial(n,r)  /*
 int n;   *  Dx^k*x^l = W(k,l,0)*x^l*Dx^k+W(k,l,1)*x^(l-1)*x^(k-1)*+...
 Q *r;   *
    *  t = [W(k,l,0) W(k,l,1) ... W(k,l,min(k,l)]
    *  where W(k,l,i) = i! * kCi * lCi
    */
   
   void mkwc(int k,int l,Q *t)
 {  {
           int i,n,up,low;
           N nm,d,c;
   
           n = MIN(k,l);
           for ( t[0] = ONE, i = 1; i <= n; i++ ) {
                   DM(k-i+1,l-i+1,up,low);
                   if ( up ) {
                           nm = NALLOC(2); PL(nm) = 2; BD(nm)[0] = low; BD(nm)[1] = up;
                   } else {
                           nm = NALLOC(1); PL(nm) = 1; BD(nm)[0] = low;
                   }
                   kmuln(NM(t[i-1]),nm,&d); divin(d,i,&c); NTOQ(c,1,t[i]);
           }
   }
   
   /* mod m table */
   /* XXX : should be optimized */
   
   void mkwcm(int k,int l,int m,int *t)
   {
           int i,n;
           Q *s;
   
           n = MIN(k,l);
           s = (Q *)ALLOCA((n+1)*sizeof(Q));
           mkwc(k,l,s);
           for ( i = 0; i <= n; i++ ) {
                   t[i] = rem(NM(s[i]),m);
           }
   }
   
   #if 0
   void factorial(int n,Q *r)
   {
         Q t,iq,s;          Q t,iq,s;
         unsigned int i,m,m0;          unsigned int i,m,m0;
         unsigned int c;          unsigned int c;
Line 342  Q *r;
Line 439  Q *r;
                 *r = t;                  *r = t;
         }          }
 }  }
   #endif
   
 void invl(a,mod,ar)  void partial_factorial(int s,int e,N *r);
 Q a,mod,*ar;  
   void factorial(int n,Q *r)
 {  {
           N nm;
   
           if ( !n )
                   *r = ONE;
           else if ( n < 0 )
                   *r = 0;
           else {
                   partial_factorial(1,n,&nm);
                   NTOQ(nm,1,*r);
           }
   }
   
   /* s*(s+1)*...*e */
   void partial_factorial(int s,int e,N *r)
   {
           unsigned int len,i,m,m0,c;
           unsigned int *p,*p1,*p2;
           N nm,r1,r2;
   
           /* XXX */
           if ( e-s > 2000 ) {
                   m = (e+s)/2;
                   partial_factorial(s,m,&r1);
                   partial_factorial(m+1,e,&r2);
                   kmuln(r1,r2,r);
                   return;
           }
           /* find i s.t. 2^(i-1) < m <= 2^i */
           for ( i = 0, m = 1; m < e; m <<=1, i++ );
            /* XXX estimate of word length of the result */
           len = (i*(e-s+1)+1+31)/32;
           p = ALLOCA((len+1)*sizeof(int));
           p1 = ALLOCA((len+1)*sizeof(int));
           p[0] = s;
           len = 1;
           for ( i = s+1; (int)i <= e; ) {
                   for ( m0 = m = 1, c = 0; ((int)i <= e) && !c; i++ ) {
                           m0 = m; DM(m0,i,c,m)
                   }
                   if ( c ) {
                           m = m0; i--;
                   }
                   bzero(p1,(len+1)*sizeof(int));
                   muln_1(p,len,m,p1);
                   if ( p1[len] )
                           len++;
                   p2 = p; p = p1; p1 = p2;
           }
           *r = nm = NALLOC(len);
           bcopy(p,BD(nm),sizeof(int)*len);
           PL(nm) = len;
   }
   
   void invl(Q a,Q mod,Q *ar)
   {
         Q f1,f2,a1,a2,q,m,s;          Q f1,f2,a1,a2,q,m,s;
         N qn,rn;          N qn,rn;
   
Line 384  Q a,mod,*ar;
Line 538  Q a,mod,*ar;
   
 int kara_mag=100;  int kara_mag=100;
   
 void kmuln(n1,n2,nr)  void kmuln(N n1,N n2,N *nr)
 N n1,n2,*nr;  
 {  {
         N n,t,s,m,carry;          N n,t,s,m,carry;
         int d,d1,d2,len,i,l;          int d,d1,d2,len,i,l;
Line 428  N n1,n2,*nr;
Line 581  N n1,n2,*nr;
         bcopy((char *)r0,(char *)BD(t),l*sizeof(int));          bcopy((char *)r0,(char *)BD(t),l*sizeof(int));
 }  }
   
 void extractn(n,index,len,nr)  void extractn(N n,int index,int len,N *nr)
 N n;  
 int index,len;  
 N *nr;  
 {  {
         unsigned int *m;          unsigned int *m;
         int l;          int l;
Line 453  N *nr;
Line 603  N *nr;
         }          }
 }  }
   
 void copyn(n,len,p)  void copyn(N n,int len,int *p)
 N n;  
 int len;  
 int *p;  
 {  {
         if ( n )          if ( n )
                 bcopy((char *)BD(n),(char *)p,MIN(PL(n),len)*sizeof(int));                  bcopy((char *)BD(n),(char *)p,MIN(PL(n),len)*sizeof(int));
 }  }
   
 void dupn(n,p)  void dupn(N n,N p)
 N n;  
 N p;  
 {  {
         if ( n )          if ( n )
                 bcopy((char *)n,(char *)p,(1+PL(n))*sizeof(int));                  bcopy((char *)n,(char *)p,(1+PL(n))*sizeof(int));
 }  }
   
 void kmulnmain(n1,n2,nr)  void kmulnmain(N n1,N n2,N *nr)
 N n1,n2,*nr;  
 {  {
         int d1,d2,h,sgn,sgn1,sgn2,len;          int d1,d2,h,sgn,sgn1,sgn2,len;
         N n1lo,n1hi,n2lo,n2hi,hi,lo,mid1,mid2,mid,s1,s2,t1,t2;          N n1lo,n1hi,n2lo,n2hi,hi,lo,mid1,mid2,mid,s1,s2,t1,t2;
Legend:
Removed from v.1.1.1.1  
changed lines
  Added in v.1.9
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>