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

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

version 1.4, 2000/08/22 05:04:06 version 1.5, 2001/10/09 01:36:13
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/up.c,v 1.3 2000/08/21 08:31:28 noro Exp $   * $OpenXM: OpenXM_contrib2/asir2000/engine/up.c,v 1.4 2000/08/22 05:04:06 noro Exp $
 */  */
 #include "ca.h"  #include "ca.h"
 #include <math.h>  #include <math.h>
Line 76  extern int lm_lazy;
Line 76  extern int lm_lazy;
 extern int current_ff;  extern int current_ff;
 extern int GC_dont_gc;  extern int GC_dont_gc;
   
 void monicup(a,b)  void monicup(UP a,UP *b)
 UP a;  
 UP *b;  
 {  {
         UP w;          UP w;
   
Line 91  UP *b;
Line 89  UP *b;
         }          }
 }  }
   
 void simpup(a,b)  void simpup(UP a,UP *b)
 UP a;  
 UP *b;  
 {  {
         int i,d;          int i,d;
         UP c;          UP c;
Line 116  UP *b;
Line 112  UP *b;
         }          }
 }  }
   
 void simpnum(a,b)  void simpnum(Num a,Num *b)
 Num a;  
 Num *b;  
 {  {
         LM lm;          LM lm;
         GF2N gf;          GF2N gf;
Line 139  Num *b;
Line 133  Num *b;
                 }                  }
 }  }
   
 void uremp(p1,p2,rp)  void uremp(P p1,P p2,P *rp)
 P p1,p2;  
 P *rp;  
 {  {
         UP n1,n2,r;          UP n1,n2,r;
   
Line 154  P *rp;
Line 146  P *rp;
         }          }
 }  }
   
 void ugcdp(p1,p2,rp)  void ugcdp(P p1,P p2,P *rp)
 P p1,p2;  
 P *rp;  
 {  {
         UP n1,n2,r;          UP n1,n2,r;
   
Line 165  P *rp;
Line 155  P *rp;
         uptop(r,rp);          uptop(r,rp);
 }  }
   
 void reversep(p1,d,rp)  void reversep(P p1,Q d,P *rp)
 P p1;  
 Q d;  
 P *rp;  
 {  {
         UP n1,r;          UP n1,r;
   
Line 181  P *rp;
Line 168  P *rp;
         }          }
 }  }
   
 void invmodp(p1,d,rp)  void invmodp(P p1,Q d,P *rp)
 P p1;  
 Q d;  
 P *rp;  
 {  {
         UP n1,r;          UP n1,r;
   
Line 197  P *rp;
Line 181  P *rp;
         }          }
 }  }
   
 void addup(n1,n2,nr)  void addup(UP n1,UP n2,UP *nr)
 UP n1,n2;  
 UP *nr;  
 {  {
         UP r,t;          UP r,t;
         int i,d1,d2;          int i,d1,d2;
Line 228  UP *nr;
Line 210  UP *nr;
         }          }
 }  }
   
 void subup(n1,n2,nr)  void subup(UP n1,UP n2,UP *nr)
 UP n1,n2;  
 UP *nr;  
 {  {
         UP r;          UP r;
         int i,d1,d2,d;          int i,d1,d2,d;
Line 263  UP *nr;
Line 243  UP *nr;
         }          }
 }  }
   
 void chsgnup(n1,nr)  void chsgnup(UP n1,UP *nr)
 UP n1;  
 UP *nr;  
 {  {
         UP r;          UP r;
         int d1,i;          int d1,i;
Line 282  UP *nr;
Line 260  UP *nr;
         }          }
 }  }
   
 void hybrid_mulup(ff,n1,n2,nr)  void hybrid_mulup(int ff,UP n1,UP n2,UP *nr)
 int ff;  
 UP n1,n2;  
 UP *nr;  
 {  {
         if ( !n1 || !n2 )          if ( !n1 || !n2 )
                 *nr = 0;                  *nr = 0;
Line 302  UP *nr;
Line 277  UP *nr;
                 }                  }
 }  }
   
 void hybrid_squareup(ff,n1,nr)  void hybrid_squareup(int ff,UP n1,UP *nr)
 int ff;  
 UP n1;  
 UP *nr;  
 {  {
         if ( !n1 )          if ( !n1 )
                 *nr = 0;                  *nr = 0;
Line 322  UP *nr;
Line 294  UP *nr;
                 }                  }
 }  }
   
 void hybrid_tmulup(ff,n1,n2,d,nr)  void hybrid_tmulup(int ff,UP n1,UP n2,int d,UP *nr)
 int ff;  
 UP n1,n2;  
 int d;  
 UP *nr;  
 {  {
         if ( !n1 || !n2 )          if ( !n1 || !n2 )
                 *nr = 0;                  *nr = 0;
Line 343  UP *nr;
Line 311  UP *nr;
                 }                  }
 }  }
   
 void mulup(n1,n2,nr)  void mulup(UP n1,UP n2,UP *nr)
 UP n1,n2;  
 UP *nr;  
 {  {
         UP r;          UP r;
         Num *pc1,*pc,*c1,*c2,*c;          Num *pc1,*pc,*c1,*c2,*c;
Line 374  UP *nr;
Line 340  UP *nr;
   
 /* nr = c*n1 */  /* nr = c*n1 */
   
 void mulcup(c,n1,nr)  void mulcup(Num c,UP n1,UP *nr)
 Num c;  
 UP n1;  
 UP *nr;  
 {  {
         int d;          int d;
         UP r;          UP r;
Line 402  UP *nr;
Line 365  UP *nr;
         }          }
 }  }
   
 void tmulup(n1,n2,d,nr)  void tmulup(UP n1,UP n2,int d,UP *nr)
 UP n1,n2;  
 int d;  
 UP *nr;  
 {  {
         UP r;          UP r;
         Num *pc1,*pc,*c1,*c2,*c;          Num *pc1,*pc,*c1,*c2,*c;
Line 439  UP *nr;
Line 399  UP *nr;
         }          }
 }  }
   
 void squareup(n1,nr)  void squareup(UP n1,UP *nr)
 UP n1;  
 UP *nr;  
 {  {
         UP r;          UP r;
         Num *c1,*c;          Num *c1,*c;
Line 476  UP *nr;
Line 434  UP *nr;
         }          }
 }  }
   
 void remup(n1,n2,nr)  void remup(UP n1,UP n2,UP *nr)
 UP n1,n2;  
 UP *nr;  
 {  {
         UP w,r;          UP w,r;
   
Line 499  UP *nr;
Line 455  UP *nr;
         }          }
 }  }
   
 void remup_destructive(n1,n2)  void remup_destructive(UP n1,UP n2)
 UP n1,n2;  
 {  {
         Num *c1,*c2;          Num *c1,*c2;
         int d1,d2,i,j;          int d1,d2,i,j;
Line 528  UP n1,n2;
Line 483  UP n1,n2;
         n1->d = i;          n1->d = i;
 }  }
   
 void qrup(n1,n2,nq,nr)  void qrup(UP n1,UP n2,UP *nq,UP *nr)
 UP n1,n2;  
 UP *nq,*nr;  
 {  {
         UP w,r,q;          UP w,r,q;
         struct oUP t;          struct oUP t;
Line 565  UP *nq,*nr;
Line 518  UP *nq,*nr;
         }          }
 }  }
   
 void qrup_destructive(n1,n2)  void qrup_destructive(UP n1,UP n2)
 UP n1,n2;  
 {  {
         Num *c1,*c2;          Num *c1,*c2;
         int d1,d2,i,j;          int d1,d2,i,j;
Line 596  UP n1,n2;
Line 548  UP n1,n2;
         n1->d = i;          n1->d = i;
 }  }
   
 void gcdup(n1,n2,nr)  void gcdup(UP n1,UP n2,UP *nr)
 UP n1,n2;  
 UP *nr;  
 {  {
         UP w1,w2,t,r;          UP w1,w2,t,r;
         int d1,d2;          int d1,d2;
Line 636  UP *nr;
Line 586  UP *nr;
   
 /* compute r s.t. a*r = 1 mod m */  /* compute r s.t. a*r = 1 mod m */
   
 void extended_gcdup(a,m,r)  void extended_gcdup(UP a,UP m,UP *r)
 UP a,m;  
 UP *r;  
 {  {
         UP one,g1,g2,a1,a2,a3,b1,b2,b3,inv,quo,rem,t;          UP one,g1,g2,a1,a2,a3,b1,b2,b3,inv,quo,rem,t;
         Num i;          Num i;
Line 659  UP *r;
Line 607  UP *r;
         mulup(b2,inv,r);          mulup(b2,inv,r);
 }  }
   
 void reverseup(n1,d,nr)  void reverseup(UP n1,int d,UP *nr)
 UP n1;  
 int d;  
 UP *nr;  
 {  {
         Num *c1,*c;          Num *c1,*c;
         int i,d1;          int i,d1;
Line 686  UP *nr;
Line 631  UP *nr;
         }          }
 }  }
   
 void invmodup(n1,d,nr)  void invmodup(UP n1,int d,UP *nr)
 UP n1;  
 int d;  
 UP *nr;  
 {  {
         UP r;          UP r;
         Num s,t,u,hinv;          Num s,t,u,hinv;
Line 727  UP *nr;
Line 669  UP *nr;
         }          }
 }  }
   
 void pwrup(n,e,nr)  void pwrup(UP n,Q e,UP *nr)
 UP n;  
 Q e;  
 UP *nr;  
 {  {
         UP y,z,t;          UP y,z,t;
         N en,qn;          N en,qn;
Line 758  UP *nr;
Line 697  UP *nr;
         }          }
 }  }
   
 int compup(n1,n2)  int compup(UP n1,UP n2)
 UP n1,n2;  
 {  {
         int i,r;          int i,r;
   
Line 781  UP n1,n2;
Line 719  UP n1,n2;
         }          }
 }  }
   
 void kmulp(vl,n1,n2,nr)  void kmulp(VL vl,P n1,P n2,P *nr)
 VL vl;  
 P n1,n2;  
 P *nr;  
 {  {
         UP b1,b2,br;          UP b1,b2,br;
   
Line 799  P *nr;
Line 734  P *nr;
         }          }
 }  }
   
 void ksquarep(vl,n1,nr)  void ksquarep(VL vl,P n1,P *nr)
 VL vl;  
 P n1;  
 P *nr;  
 {  {
         UP b1,br;          UP b1,br;
   
Line 817  P *nr;
Line 749  P *nr;
         }          }
 }  }
   
 void kmulup(n1,n2,nr)  void kmulup(UP n1,UP n2,UP *nr)
 UP n1,n2,*nr;  
 {  {
         UP n,t,s,m,carry;          int d1,d2;
         int d,d1,d2,len,i,l;  
         pointer *r,*r0;  
   
         if ( !n1 || !n2 ) {          if ( !n1 || !n2 ) {
                 *nr = 0; return;                  *nr = 0; return;
Line 834  UP n1,n2,*nr;
Line 763  UP n1,n2,*nr;
                 kmulupmain(n1,n2,nr);                  kmulupmain(n1,n2,nr);
 }  }
   
 void ksquareup(n1,nr)  void ksquareup(UP n1,UP *nr)
 UP n1,*nr;  
 {  {
         int d1;          int d1;
         extern Q TWO;          extern Q TWO;
Line 850  UP n1,*nr;
Line 778  UP n1,*nr;
                 ksquareupmain(n1,nr);                  ksquareupmain(n1,nr);
 }  }
   
 void copyup(n1,n2)  void copyup(UP n1,UP n2)
 UP n1,n2;  
 {  {
         n2->d = n1->d;          n2->d = n1->d;
         bcopy((char *)n1->c,(char *)n2->c,(n1->d+1)*sizeof(Q));          bcopy((char *)n1->c,(char *)n2->c,(n1->d+1)*sizeof(Q));
 }  }
   
 void c_copyup(n,len,p)  void c_copyup(UP n,int len,pointer *p)
 UP n;  
 int len;  
 pointer *p;  
 {  {
         if ( n )          if ( n )
                 bcopy((char *)COEF(n),(char *)p,MIN((DEG(n)+1),len)*sizeof(pointer));                  bcopy((char *)COEF(n),(char *)p,MIN((DEG(n)+1),len)*sizeof(pointer));
 }  }
   
 void kmulupmain(n1,n2,nr)  void kmulupmain(UP n1,UP n2,UP *nr)
 UP n1,n2,*nr;  
 {  {
         int d1,d2,h,len;          int d1,d2,h;
         UP n1lo,n1hi,n2lo,n2hi,hi,lo,mid1,mid2,mid,s1,s2,t1,t2;          UP n1lo,n1hi,n2lo,n2hi,hi,lo,mid1,mid2,mid,s1,s2,t1,t2;
   
         d1 = DEG(n1)+1; d2 = DEG(n2)+1; h = (MAX(d1,d2)+1)/2;          d1 = DEG(n1)+1; d2 = DEG(n2)+1; h = (MAX(d1,d2)+1)/2;
Line 886  UP n1,n2,*nr;
Line 809  UP n1,n2,*nr;
         addup(t1,t2,nr);          addup(t1,t2,nr);
 }  }
   
 void ksquareupmain(n1,nr)  void ksquareupmain(UP n1,UP *nr)
 UP n1,*nr;  
 {  {
         int d1,h,len;          int d1,h;
         UP n1lo,n1hi,hi,lo,mid1,mid2,mid,s1,t1,t2;          UP n1lo,n1hi,hi,lo,mid1,mid2,mid,s1,t1,t2;
   
         d1 = DEG(n1)+1; h = (d1+1)/2;          d1 = DEG(n1)+1; h = (d1+1)/2;
Line 904  UP n1,*nr;
Line 826  UP n1,*nr;
         addup(t1,t2,nr);          addup(t1,t2,nr);
 }  }
   
 void rembymulup(n1,n2,nr)  void rembymulup(UP n1,UP n2,UP *nr)
 UP n1,n2;  
 UP *nr;  
 {  {
         int d1,d2,d;          int d1,d2,d;
         UP r1,r2,inv2,t,s,q;          UP r1,r2,inv2,t,s,q;
Line 935  UP *nr;
Line 855  UP *nr;
         inv2 = inverse of reversep(n2) mod x^d          inv2 = inverse of reversep(n2) mod x^d
 */  */
   
 void hybrid_rembymulup_special(ff,n1,n2,inv2,nr)  void hybrid_rembymulup_special(int ff,UP n1,UP n2,UP inv2,UP *nr)
 int ff;  
 UP n1,n2,inv2;  
 UP *nr;  
 {  {
         int d1,d2,d;          int d1,d2,d;
         UP r1,t,s,q,u;          UP r1,t,s,q;
   
         if ( !n2 )          if ( !n2 )
                 error("hybrid_rembymulup : division by 0");                  error("hybrid_rembymulup : division by 0");
Line 962  UP *nr;
Line 879  UP *nr;
         }          }
 }  }
   
 void rembymulup_special(n1,n2,inv2,nr)  void rembymulup_special(UP n1,UP n2,UP inv2,UP *nr)
 UP n1,n2,inv2;  
 UP *nr;  
 {  {
         int d1,d2,d;          int d1,d2,d;
         UP r1,t,s,q,u;          UP r1,t,s,q;
   
         if ( !n2 )          if ( !n2 )
                 error("rembymulup : division by 0");                  error("rembymulup : division by 0");
Line 990  UP *nr;
Line 905  UP *nr;
   
 /* *nr = n1*n2 mod x^d */  /* *nr = n1*n2 mod x^d */
   
 void tkmulup(n1,n2,d,nr)  void tkmulup(UP n1,UP n2,int d,UP *nr)
 UP n1,n2;  
 int d;  
 UP *nr;  
 {  {
         int m;          int m;
         UP n1l,n1h,n2l,n2h,l,h,t,s,u,afo;          UP n1l,n1h,n2l,n2h,l,h,t,s,u;
   
         if ( d < 0 )          if ( d < 0 )
                 error("tkmulup : invalid argument");                  error("tkmulup : invalid argument");
Line 1026  UP *nr;
Line 938  UP *nr;
   
 /* n->n*x^d */  /* n->n*x^d */
   
 void shiftup(n,d,nr)  void shiftup(UP n,int d,UP *nr)
 UP n;  
 int d;  
 UP *nr;  
 {  {
         int dr;          int dr;
         UP r;          UP r;
Line 1044  UP *nr;
Line 953  UP *nr;
         }          }
 }  }
   
 void fft_rembymulup_special(n1,n2,inv2,nr)  void fft_rembymulup_special(UP n1,UP n2,UP inv2,UP *nr)
 UP n1,n2,inv2;  
 UP *nr;  
 {  {
         int d1,d2,d;          int d1,d2,d;
         UP r1,t,s,q,u;          UP r1,t,s,q,u;
Line 1069  UP *nr;
Line 976  UP *nr;
         }          }
 }  }
   
 void set_degreeup(n,d)  void set_degreeup(UP n,int d)
 UP n;  
 int d;  
 {  {
         int i;          int i;
   
Line 1081  int d;
Line 986  int d;
   
 /* n -> n0 + x^d n1 */  /* n -> n0 + x^d n1 */
   
 void decompup(n,d,n0,n1)  void decompup(UP n,int d,UP *n0,UP *n1)
 UP n;  
 int d;  
 UP *n0,*n1;  
 {  {
         int dn;          int dn;
         UP r0,r1;          UP r0,r1;
Line 1112  UP *n0,*n1;
Line 1014  UP *n0,*n1;
   
 /* n -> n mod x^d */  /* n -> n mod x^d */
   
 void truncup(n1,d,nr)  void truncup(UP n1,int d,UP *nr)
 UP n1;  
 int d;  
 UP *nr;  
 {  {
         int i;          int i;
         UP r;          UP r;
Line 1137  UP *nr;
Line 1036  UP *nr;
         }          }
 }  }
   
 int int_bits(t)  int int_bits(int t)
 int t;  
 {  {
         int k;          int k;
   
Line 1148  int t;
Line 1046  int t;
   
 /* n is assumed to be LM or integer coefficient */  /* n is assumed to be LM or integer coefficient */
   
 int maxblenup(n)  int maxblenup(UP n)
 UP n;  
 {  {
         int m,r,i,d;          int m,r,i,d;
         Num *c;          Num *c;
Line 1174  UP n;
Line 1071  UP n;
         return r;          return r;
 }  }
   
 void uptofmarray(mod,n,f)  void uptofmarray(int mod,UP n,ModNum *f)
 int mod;  
 UP n;  
 ModNum *f;  
 {  {
         int d,i;          int d,i;
         unsigned int r;          unsigned int r;
Line 1208  ModNum *f;
Line 1102  ModNum *f;
         }          }
 }  }
   
 void fmarraytoup(f,d,nr)  void fmarraytoup(ModNum *f,int d,UP *nr)
 ModNum *f;  
 int d;  
 UP *nr;  
 {  {
         int i;          int i;
         Q *c;          Q *c;
Line 1234  UP *nr;
Line 1125  UP *nr;
   
 /* f[i]: an array of length n */  /* f[i]: an array of length n */
   
 void uiarraytoup(f,n,d,nr)  void uiarraytoup(unsigned int **f,int n,int d,UP *nr)
 unsigned int **f;  
 int n,d;  
 UP *nr;  
 {  {
         int i,j;          int i,j;
         unsigned int *fi;          unsigned int *fi;
Line 1269  UP *nr;
Line 1157  UP *nr;
         }          }
 }  }
   
 void adj_coefup(n,m,m2,nr)  void adj_coefup(UP n,N m,N m2,UP *nr)
 UP n;  
 N m,m2;  
 UP *nr;  
 {  {
         int d;          int d;
         Q *c,*cr;          Q *c,*cr;
Line 1304  UP *nr;
Line 1189  UP *nr;
   
 /* n is assumed to have positive integer coefficients. */  /* n is assumed to have positive integer coefficients. */
   
 void remcup(n,mod,nr)  void remcup(UP n,N mod,UP *nr)
 UP n;  
 N mod;  
 UP *nr;  
 {  {
         int i,d;          int i,d;
         Q *c,*cr;          Q *c,*cr;
Line 1338  UP *nr;
Line 1220  UP *nr;
   
 void fft_mulup_main(UP,UP,int,UP *);  void fft_mulup_main(UP,UP,int,UP *);
   
 void fft_mulup(n1,n2,nr)  void fft_mulup(UP n1,UP n2,UP *nr)
 UP n1,n2;  
 UP *nr;  
 {  {
         int d1,d2,d,b1,b2,h;          int d1,d2,d,b1,b2,h;
         UP n1lo,n1hi,n2lo,n2hi,lo,hi,t1,t2,mid1,mid2,mid,s1,s2;          UP n1lo,n1hi,n2lo,n2hi,lo,hi,t1,t2,mid1,mid2,mid,s1,s2;
Line 1374  UP *nr;
Line 1254  UP *nr;
         }          }
 }  }
   
 void trunc_fft_mulup(n1,n2,dbd,nr)  void trunc_fft_mulup(UP n1,UP n2,int dbd,UP *nr)
 UP n1,n2;  
 int dbd;  
 UP *nr;  
 {  {
         int d1,d2,b1,b2,m;          int d1,d2,b1,b2,m;
         UP n1l,n1h,n2l,n2h,l,h,t,s,u;          UP n1l,n1h,n2l,n2h,l,h,t,s,u;
Line 1414  UP *nr;
Line 1291  UP *nr;
         }          }
 }  }
   
 void fft_squareup(n1,nr)  void fft_squareup(UP n1,UP *nr)
 UP n1;  
 UP *nr;  
 {  {
         int d1,d,h,len,b1;          int d1,d,h,b1;
         UP n1lo,n1hi,hi,lo,mid1,mid2,mid,s1,t1,t2;          UP n1lo,n1hi,hi,lo,mid1,mid2,mid,s1,t1,t2;
   
         if ( !n1 )          if ( !n1 )
Line 1455  UP *nr;
Line 1330  UP *nr;
  * n1 == n2 => squaring   * n1 == n2 => squaring
  */   */
   
 void fft_mulup_main(n1,n2,dbd,nr)  void fft_mulup_main(UP n1,UP n2,int dbd,UP *nr)
 UP n1,n2;  
 UP *nr;  
 {  {
         ModNum *f1,*f2,*w,*fr;          ModNum *f1,*f2,*w,*fr;
         ModNum **frarray,**fa;          ModNum **frarray,**fa;
Line 1526  UP *nr;
Line 1399  UP *nr;
 #if 0  #if 0
 /* inefficient version */  /* inefficient version */
   
 void crup(f,d,mod,index,m,r)  void crup(ModNum **f,int d,int *mod,int index,N m,UP *r)
 ModNum **f;  
 int d;  
 int *mod;  
 int index;  
 N m;  
 UP *r;  
 {  {
         N *cof,*c;          N *cof,*c;
         int *inv;          int *inv;
Line 1571  UP *r;
Line 1438  UP *r;
 #else  #else
 /* improved version */  /* improved version */
   
 void crup(f,d,mod,index,m,r)  void crup(ModNum **f,int d,int *mod,int index,N m,UP *r)
 ModNum **f;  
 int d;  
 int *mod;  
 int index;  
 N m;  
 UP *r;  
 {  {
         N cof,c,t,w,w1;          N cof,c,t,w,w1;
         struct oN fc;          struct oN fc;
Line 1637  UP *r;
Line 1498  UP *r;
  * return: n1*n2 mod Primes[modind[0]]*.prime...*Primes[modind[nmod-1]].prime   * return: n1*n2 mod Primes[modind[0]]*.prime...*Primes[modind[nmod-1]].prime
  */   */
   
 void fft_mulup_specialmod_main(n1,n2,dbd,modind,nmod,nr)  void fft_mulup_specialmod_main(UP n1,UP n2,int dbd,int *modind,int nmod,UP *nr)
 UP n1,n2;  
 int dbd;  
 int *modind;  
 int nmod;  
 UP *nr;  
 {  {
         ModNum *f1,*f2,*w,*fr;          ModNum *f1,*f2,*w,*fr;
         ModNum **frarray,**fa;          ModNum **frarray;
         N m,m1,m2;          N m,m1,m2;
         unsigned int *modarray;          unsigned int *modarray;
         int d1,d2,dmin,i,mod,root,d,cond,bound;          int d1,d2,dmin,i,root,d,cond,bound;
         UP r;  
   
         if ( !n1 || !n2 ) {          if ( !n1 || !n2 ) {
                 *nr = 0; return;                  *nr = 0; return;
Legend:
Removed from v.1.4  
changed lines
  Added in v.1.5
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>