[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.10 and 1.15

version 1.10, 2001/06/29 09:08:53 version 1.15, 2018/03/29 01:32:51
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/C.c,v 1.9 2001/06/25 01:35:20 noro Exp $   * $OpenXM: OpenXM_contrib2/asir2000/engine/C.c,v 1.14 2003/01/16 00:33:28 noro Exp $
 */  */
 #include "ca.h"  #include "ca.h"
 #include "inline.h"  #include "inline.h"
Line 54 
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;
         char buf[33];    char buf[33];
   
         binary += strlen(binary)%32;    binary += strlen(binary)%32;
         len = strlen(binary);    len = strlen(binary);
         w = len/32; /* sufficient for holding binary */    w = len/32; /* sufficient for holding binary */
         n = NALLOC(w);    n = NALLOC(w);
         for ( i = 0; i < w; i++ ) {    for ( i = 0; i < w; i++ ) {
                 strncpy(buf,binary+len-32*(i+1),32); buf[32] = 0;      strncpy(buf,binary+len-32*(i+1),32); buf[32] = 0;
                 n->b[i] = strtoul(buf,0,2);      n->b[i] = strtoul(buf,0,2);
         }    }
         for ( i = w-1; i >= 0 && !n->b[i]; i-- );    for ( i = w-1; i >= 0 && !n->b[i]; i-- );
         if ( i < 0 )    if ( i < 0 )
                 *np = 0;      *np = 0;
         else {    else {
                 n->p = i+1;      n->p = i+1;
                 *np = n;      *np = n;
         }    }
 }  }
   
 /* 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;
         char buf[9];    char buf[9];
   
         hex += strlen(hex)%8;    hex += strlen(hex)%8;
         len = strlen(hex);    len = strlen(hex);
         w = len/8; /* sufficient for holding hex */    w = len/8; /* sufficient for holding hex */
         n = NALLOC(w);    n = NALLOC(w);
         for ( i = 0; i < w; i++ ) {    for ( i = 0; i < w; i++ ) {
                 strncpy(buf,hex+len-8*(i+1),8); buf[8] = 0;      strncpy(buf,hex+len-8*(i+1),8); buf[8] = 0;
                 n->b[i] = strtoul(buf,0,16);      n->b[i] = strtoul(buf,0,16);
         }    }
         for ( i = w-1; i >= 0 && !n->b[i]; i-- );    for ( i = w-1; i >= 0 && !n->b[i]; i-- );
         if ( i < 0 )    if ( i < 0 )
                 *np = 0;      *np = 0;
         else {    else {
                 n->p = i+1;      n->p = i+1;
                 *np = n;      *np = n;
         }    }
 }  }
   
 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;
         unsigned int r;    unsigned int r;
         L m;    L m;
         N nr;    N nr;
   
         if ( !n ) {    if ( !n ) {
                 *nrp = NULL;      *nrp = NULL;
                 return;      return;
         }    }
   
         d = PL(n);    d = PL(n);
         w = BD(n);    w = BD(n);
   
         for ( i = 1, m = 1; m <= LBASE/(L)base; m *= base, i++ );    for ( i = 1, m = 1; m <= LBASE/(L)base; m *= base, i++ );
   
         c = (unsigned int *)W_ALLOC(d*i+1);    c = (unsigned int *)W_ALLOC(d*i+1);
         x = (unsigned int *)W_ALLOC(d+1);    x = (unsigned int *)W_ALLOC(d+1);
         for ( i = 0; i < d; i++ )    for ( i = 0; i < d; i++ )
                 x[i] = w[i];      x[i] = w[i];
         for ( plc = 0; d >= 1; plc++ ) {    for ( plc = 0; d >= 1; plc++ ) {
                 for ( i = d - 1, r = 0; i >= 0; i-- ) {      for ( i = d - 1, r = 0; i >= 0; i-- ) {
                         DSAB((unsigned int)base,r,x[i],x[i],r)        DSAB((unsigned int)base,r,x[i],x[i],r)
                 }      }
                 c[plc] = r;      c[plc] = r;
                 if ( !x[d-1] ) d--;      if ( !x[d-1] ) d--;
         }    }
   
         *nrp = nr = NALLOC(plc); INITRC(nr);    *nrp = nr = NALLOC(plc); INITRC(nr);
         PL(nr) = plc;    PL(nr) = plc;
         for ( i = 0; i < plc; i++ )    for ( i = 0; i < plc; i++ )
                 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;
         int i,j,d,plc;    int i,j,d,plc;
         N nr;    N nr;
   
         if ( !n ) {    if ( !n ) {
                 *nrp = 0;      *nrp = 0;
                 return;      return;
         }    }
   
         d = PL(n);    d = PL(n);
         w = BD(n);    w = BD(n);
         x = (unsigned int *)W_ALLOC(d + 1);    x = (unsigned int *)W_ALLOC(d + 1);
   
         for ( plc = 0, i = d - 1; i >= 0; i-- ) {    for ( plc = 0, i = d - 1; i >= 0; i-- ) {
                 for ( carry = w[i],j = 0; j < plc; j++ ) {      for ( carry = w[i],j = 0; j < plc; j++ ) {
                         DMA(x[j],(unsigned int)base,carry,carry,x[j])        DMA(x[j],(unsigned int)base,carry,carry,x[j])
                 }      }
                 if ( carry ) x[plc++] = carry;      if ( carry ) x[plc++] = carry;
         }    }
         *nrp = nr = NALLOC(plc); INITRC(nr);    *nrp = nr = NALLOC(plc); INITRC(nr);
         PL(nr) = plc;    PL(nr) = plc;
         for ( i = 0; i < plc; i++ )    for ( i = 0; i < plc; i++ )
                 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;
         unsigned int a,b;    unsigned int a,b;
         P t;    P t;
         MQ s;    MQ s;
   
         if ( !p )    if ( !p )
                 *pr = 0;      *pr = 0;
         else if ( NUM(p) ) {    else if ( NUM(p) ) {
                 q = (Q)p;      q = (Q)p;
                 a = rem(NM(q),m);      a = rem(NM(q),m);
                 if ( a && (SGN(q) < 0) )      if ( a && (SGN(q) < 0) )
                         a = m-a;        a = m-a;
                 b = !DN(q)?1:rem(DN(q),m);      b = !DN(q)?1:rem(DN(q),m);
                 if ( !b )      if ( !b )
                         error("ptomp : denominator = 0");        error("ptomp : denominator = 0");
                 a = dmar(a,invm(b,m),0,m); STOMQ(a,s); *pr = (P)s;      a = dmar(a,invm(b,m),0,m); STOMQ(a,s); *pr = (P)s;
         } else {    } else {
                 for ( dc = DC(p), dcr0 = 0; dc; dc = NEXT(dc) ) {      for ( dc = DC(p), dcr0 = 0; dc; dc = NEXT(dc) ) {
                         ptomp(m,COEF(dc),&t);        ptomp(m,COEF(dc),&t);
                         if ( t ) {        if ( t ) {
                                 NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc); COEF(dcr) = t;          NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc); COEF(dcr) = t;
                         }        }
                 }      }
                 if ( !dcr0 )      if ( !dcr0 )
                         *pr = 0;        *pr = 0;
                 else {      else {
                         NEXT(dcr) = 0; MKP(VR(p),dcr0,*pr);        NEXT(dcr) = 0; MKP(VR(p),dcr0,*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;
   
         if ( !f )    if ( !f )
                 *gp = 0;      *gp = 0;
         else if ( NUM(f) )    else if ( NUM(f) )
                 STOQ(CONT((MQ)f),q),*gp = (P)q;      STOQ(CONT((MQ)f),q),*gp = (P)q;
         else {    else {
                 for ( dc = DC(f), dcr0 = 0; dc; dc = NEXT(dc) ) {      for ( dc = DC(f), dcr0 = 0; dc; dc = NEXT(dc) ) {
                         NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc); mptop(COEF(dc),&COEF(dcr));        NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc); mptop(COEF(dc),&COEF(dcr));
                 }      }
                 NEXT(dcr) = 0; MKP(VR(f),dcr0,*gp);      NEXT(dcr) = 0; MKP(VR(f),dcr0,*gp);
         }    }
 }  }
   
 void ptosfp(p,pr)  void ptosfp(P p,P *pr)
 P p;  
 P *pr;  
 {  {
         DCP dc,dcr,dcr0;    DCP dc,dcr,dcr0;
         GFS a;    GFS a;
         P t;    P t;
   
         if ( !p )    if ( !p )
                 *pr = 0;      *pr = 0;
         else if ( NUM(p) ) {    else if ( NUM(p) ) {
                 qtogfs((Q)p,&a); *pr = (P)a;      if ( NID((Num)p) == N_GFS )
         } else {        *pr = (P)p;
                 for ( dc = DC(p), dcr0 = 0; dc; dc = NEXT(dc) ) {      else {
                         ptosfp(COEF(dc),&t);        qtogfs((Q)p,&a); *pr = (P)a;
                         if ( t ) {      }
                                 NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc); COEF(dcr) = t;    } else {
                         }      for ( dc = DC(p), dcr0 = 0; dc; dc = NEXT(dc) ) {
                 }        ptosfp(COEF(dc),&t);
                 if ( !dcr0 )        if ( t ) {
                         *pr = 0;          NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc); COEF(dcr) = t;
                 else {        }
                         NEXT(dcr) = 0; MKP(VR(p),dcr0,*pr);      }
                 }      if ( !dcr0 )
         }        *pr = 0;
       else {
         NEXT(dcr) = 0; MKP(VR(p),dcr0,*pr);
       }
     }
 }  }
   
 void sfptop(f,gp)  void sfptop(P f,P *gp)
 P f;  
 P *gp;  
 {  {
         DCP dc,dcr,dcr0;    DCP dc,dcr,dcr0;
         Q q;    Q q;
         MQ fq;    MQ fq;
   
         if ( !f )    if ( !f )
                 *gp = 0;      *gp = 0;
         else if ( NUM(f) ) {    else if ( NUM(f) ) {
                 gfstomq((GFS)f,&fq);      gfstomq((GFS)f,&fq);
                 STOQ(CONT(fq),q);      STOQ(CONT(fq),q);
                 *gp = (P)q;      *gp = (P)q;
         } else {    } else {
                 for ( dc = DC(f), dcr0 = 0; dc; dc = NEXT(dc) ) {      for ( dc = DC(f), dcr0 = 0; dc; dc = NEXT(dc) ) {
                         NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc); sfptop(COEF(dc),&COEF(dcr));        NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc); sfptop(COEF(dc),&COEF(dcr));
                 }      }
                 NEXT(dcr) = 0; MKP(VR(f),dcr0,*gp);      NEXT(dcr) = 0; MKP(VR(f),dcr0,*gp);
         }    }
 }  }
   
 void sf_galois_action(p,e,pr)  void sfptopsfp(P f,V v,P *gp)
 P p;  
 Q e;  
 P *pr;  
 {  {
         DCP dc,dcr,dcr0;    DCP dc,dcr,dcr0;
         GFS a;    Q q;
         P t;    P fq;
   
         if ( !p )    if ( !f )
                 *pr = 0;      *gp = 0;
         else if ( NUM(p) ) {    else if ( NUM(f) )
                 gfs_galois_action(p,e,&a); *pr = (P)a;      gfstopgfs((GFS)f,v,gp);
         } else {    else {
                 for ( dc = DC(p), dcr0 = 0; dc; dc = NEXT(dc) ) {      for ( dc = DC(f), dcr0 = 0; dc; dc = NEXT(dc) ) {
                         sf_galois_action(COEF(dc),e,&t);        NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc);
                         if ( t ) {        sfptopsfp(COEF(dc),v,&COEF(dcr));
                                 NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc); COEF(dcr) = t;      }
                         }      NEXT(dcr) = 0; MKP(VR(f),dcr0,*gp);
                 }    }
                 if ( !dcr0 )  
                         *pr = 0;  
                 else {  
                         NEXT(dcr) = 0; MKP(VR(p),dcr0,*pr);  
                 }  
         }  
 }  }
   
   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 */  /* GF(pn)={0,1,a,a^2,...} -> GF(pm)={0,1,b,b^2,..} ; a -> b^k */
   
 void sf_embed(p,k,pm,pr)  void sf_embed(P p,int k,int pm,P *pr)
 P p;  
 int k,pm;  
 P *pr;  
 {  {
         DCP dc,dcr,dcr0;    DCP dc,dcr,dcr0;
         GFS a;    GFS a;
         P t;    P t;
   
         if ( !p )    if ( !p )
                 *pr = 0;      *pr = 0;
         else if ( NUM(p) ) {    else if ( NUM(p) ) {
                 gfs_embed(p,k,pm,&a); *pr = (P)a;      gfs_embed((GFS)p,k,pm,&a); *pr = (P)a;
         } else {    } else {
                 for ( dc = DC(p), dcr0 = 0; dc; dc = NEXT(dc) ) {      for ( dc = DC(p), dcr0 = 0; dc; dc = NEXT(dc) ) {
                         sf_embed(COEF(dc),k,pm,&t);        sf_embed(COEF(dc),k,pm,&t);
                         if ( t ) {        if ( t ) {
                                 NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc); COEF(dcr) = t;          NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc); COEF(dcr) = t;
                         }        }
                 }      }
                 if ( !dcr0 )      if ( !dcr0 )
                         *pr = 0;        *pr = 0;
                 else {      else {
                         NEXT(dcr) = 0; MKP(VR(p),dcr0,*pr);        NEXT(dcr) = 0; MKP(VR(p),dcr0,*pr);
                 }      }
         }    }
 }  }
   
 void ptolmp(p,pr)  void ptolmp(P p,P *pr)
 P p;  
 P *pr;  
 {  {
         DCP dc,dcr,dcr0;    DCP dc,dcr,dcr0;
         LM a;    LM a;
         P t;    P t;
   
         if ( !p )    if ( !p )
                 *pr = 0;      *pr = 0;
         else if ( NUM(p) ) {    else if ( NUM(p) ) {
                 qtolm((Q)p,&a); *pr = (P)a;      qtolm((Q)p,&a); *pr = (P)a;
         } else {    } else {
                 for ( dc = DC(p), dcr0 = 0; dc; dc = NEXT(dc) ) {      for ( dc = DC(p), dcr0 = 0; dc; dc = NEXT(dc) ) {
                         ptolmp(COEF(dc),&t);        ptolmp(COEF(dc),&t);
                         if ( t ) {        if ( t ) {
                                 NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc); COEF(dcr) = t;          NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc); COEF(dcr) = t;
                         }        }
                 }      }
                 if ( !dcr0 )      if ( !dcr0 )
                         *pr = 0;        *pr = 0;
                 else {      else {
                         NEXT(dcr) = 0; MKP(VR(p),dcr0,*pr);        NEXT(dcr) = 0; MKP(VR(p),dcr0,*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;
   
         if ( !f )    if ( !f )
                 *gp = 0;      *gp = 0;
         else if ( NUM(f) ) {    else if ( NUM(f) ) {
                 NTOQ(((LM)f)->body,1,q); *gp = (P)q;      NTOQ(((LM)f)->body,1,q); *gp = (P)q;
         } else {    } else {
                 for ( dc = DC(f), dcr0 = 0; dc; dc = NEXT(dc) ) {      for ( dc = DC(f), dcr0 = 0; dc; dc = NEXT(dc) ) {
                         NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc); lmptop(COEF(dc),&COEF(dcr));        NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc); lmptop(COEF(dc),&COEF(dcr));
                 }      }
                 NEXT(dcr) = 0; MKP(VR(f),dcr0,*gp);      NEXT(dcr) = 0; MKP(VR(f),dcr0,*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;
         DCP dc;    DCP dc;
   
         for ( i = UDEG(f); i >= 0; i-- )    for ( i = UDEG(f); i >= 0; i-- )
                 COEF(wf)[i] = 0;      COEF(wf)[i] = 0;
   
         for ( dc = DC(f); dc; dc = NEXT(dc) ) {    for ( dc = DC(f); dc; dc = NEXT(dc) ) {
                 r = rem(NM((Q)COEF(dc)),m);      r = rem(NM((Q)COEF(dc)),m);
                 if ( r && (SGN((Q)COEF(dc)) < 0) )      if ( r && (SGN((Q)COEF(dc)) < 0) )
                         r = m-r;        r = m-r;
                 COEF(wf)[QTOS(DEG(dc))] = r;      COEF(wf)[QTOS(DEG(dc))] = r;
         }    }
         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;
         int i;    int i;
         Q q;    Q q;
   
         if ( DEG(w) < 0 )    if ( DEG(w) < 0 )
                 *f = 0;      *f = 0;
         else if ( DEG(w) == 0 )    else if ( DEG(w) == 0 )
                 STOQ(COEF(w)[0],q), *f = (P)q;      STOQ(COEF(w)[0],q), *f = (P)q;
         else {    else {
                 for ( i = DEG(w), c = COEF(w), dc0 = 0; i >= 0; i-- )      for ( i = DEG(w), c = COEF(w), dc0 = 0; i >= 0; i-- )
                         if ( c[i] ) {        if ( c[i] ) {
                                 NEXTDC(dc0,dc);          NEXTDC(dc0,dc);
                                 STOQ(i,DEG(dc));          STOQ(i,DEG(dc));
                                 STOQ(c[i],q), COEF(dc) = (P)q;          STOQ(c[i],q), COEF(dc) = (P)q;
                         }        }
                 NEXT(dc) = 0;      NEXT(dc) = 0;
                 MKP(v,dc0,*f);      MKP(v,dc0,*f);
         }    }
 }  }
   
 void ptosfum(f,wf)  void ptosfum(P f,UM wf)
 P f;  
 UM wf;  
 {  {
         GFS c;    GFS c;
         int i;    int i;
         DCP dc;    DCP dc;
   
         if ( OID(f) == O_N ) {    if ( OID(f) == O_N ) {
                 DEG(wf) = 0;      DEG(wf) = 0;
                 COEF(wf)[0] = FTOIF(CONT((GFS)f));      ntogfs((Obj)f,&c);
                 return;      COEF(wf)[0] = FTOIF(CONT(c));
         }      return;
     }
   
         for ( i = UDEG(f); i >= 0; i-- )    for ( i = UDEG(f); i >= 0; i-- )
                 COEF(wf)[i] = 0;      COEF(wf)[i] = 0;
   
         for ( dc = DC(f); dc; dc = NEXT(dc) ) {    for ( dc = DC(f); dc; dc = NEXT(dc) ) {
                 c = (GFS)COEF(dc);      ntogfs((Obj)COEF(dc),&c);
                 if ( c )      if ( c )
                         COEF(wf)[QTOS(DEG(dc))] = FTOIF(CONT(c));        COEF(wf)[QTOS(DEG(dc))] = FTOIF(CONT(c));
         }    }
         degum(wf,UDEG(f));    degum(wf,UDEG(f));
 }  }
   
 void sfumtop(v,w,f)  void sfumtop(V v,UM w,P *f)
 V v;  
 UM w;  
 P *f;  
 {  {
         int *c;    int *c;
         DCP dc,dc0;    DCP dc,dc0;
         int i,t;    int i,t;
         GFS q;    GFS q;
   
         if ( DEG(w) < 0 )    if ( DEG(w) < 0 )
                 *f = 0;      *f = 0;
         else if ( DEG(w) == 0 ) {    else if ( DEG(w) == 0 ) {
                 t = COEF(w)[0];      t = COEF(w)[0];
                 t = IFTOF(t);      t = IFTOF(t);
                 MKGFS(t,q);      MKGFS(t,q);
                 *f = (P)q;      *f = (P)q;
         } else {    } else {
                 for ( i = DEG(w), c = COEF(w), dc0 = 0; i >= 0; i-- )      for ( i = DEG(w), c = COEF(w), dc0 = 0; i >= 0; i-- )
                         if ( c[i] ) {        if ( c[i] ) {
                                 NEXTDC(dc0,dc);          NEXTDC(dc0,dc);
                                 STOQ(i,DEG(dc));          STOQ(i,DEG(dc));
                                 t = COEF(w)[i];          t = COEF(w)[i];
                                 t = IFTOF(t);          t = IFTOF(t);
                                 MKGFS(t,q);          MKGFS(t,q);
                                 COEF(dc) = (P)q;          COEF(dc) = (P)q;
                         }        }
                 NEXT(dc) = 0;      NEXT(dc) = 0;
                 MKP(v,dc0,*f);      MKP(v,dc0,*f);
         }    }
 }  }
   
 void ptoup(n,nr)  void ptoup(P n,UP *nr)
 P n;  
 UP *nr;  
 {  {
         DCP dc;    DCP dc;
         UP r;    UP r;
         int d;    int d;
   
         if ( !n )    if ( !n )
                 *nr = 0;      *nr = 0;
         else if ( OID(n) == O_N ) {    else if ( OID(n) == O_N ) {
                 *nr = r = UPALLOC(0);      *nr = r = UPALLOC(0);
                 DEG(r) = 0; COEF(r)[0] = (Num)n;      DEG(r) = 0; COEF(r)[0] = (Num)n;
         } else {    } else {
                 d = UDEG(n);      d = UDEG(n);
                 up_var = VR(n);      up_var = VR(n);
                 *nr = r = UPALLOC(d); DEG(r) = d;      *nr = r = UPALLOC(d); DEG(r) = d;
                 for ( dc = DC(n); dc; dc = NEXT(dc) ) {      for ( dc = DC(n); dc; dc = NEXT(dc) ) {
                         COEF(r)[QTOS(DEG(dc))] = (Num)COEF(dc);        COEF(r)[QTOS(DEG(dc))] = (Num)COEF(dc);
                 }      }
         }    }
 }  }
   
 void uptop(n,nr)  void uptop(UP n,P *nr)
 UP n;  
 P *nr;  
 {  {
         int i;    int i;
         DCP dc0,dc;    DCP dc0,dc;
   
         if ( !n )    if ( !n )
                 *nr = 0;      *nr = 0;
         else if ( !DEG(n) )    else if ( !DEG(n) )
                 *nr = (P)COEF(n)[0];      *nr = (P)COEF(n)[0];
         else {    else {
                 for ( i = DEG(n), dc0 = 0; i >= 0; i-- )      for ( i = DEG(n), dc0 = 0; i >= 0; i-- )
                         if ( COEF(n)[i] ) {        if ( COEF(n)[i] ) {
                                 NEXTDC(dc0,dc); STOQ(i,DEG(dc)); COEF(dc) = (P)COEF(n)[i];          NEXTDC(dc0,dc); STOQ(i,DEG(dc)); COEF(dc) = (P)COEF(n)[i];
                         }        }
                 if ( !up_var )      if ( !up_var )
                         up_var = CO->v;        up_var = CO->v;
                 MKP(up_var,dc0,*nr);      MKP(up_var,dc0,*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;
   
         if ( !f )    if ( !f )
                 wf->d = -1;      wf->d = -1;
         else {    else {
                 wf->d = d = f->d;      wf->d = d = f->d;
                 c = (LM *)f->c;      c = (LM *)f->c;
                 for ( i = 0, d = f->d; i <= d; i++ )      for ( i = 0, d = f->d; i <= d; i++ )
                         COEF(wf)[i] = rem(c[i]->body,m);        COEF(wf)[i] = rem(c[i]->body,m);
         }    }
 }  }
   
 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;
         else    else
                 switch ( OID(p) ) {      switch ( OID(p) ) {
                         case O_N:        case O_N:
                                 numtobnum(base,(Num)p,(Num *)rp); break;          numtobnum(base,(Num)p,(Num *)rp); break;
                         case O_P:        case O_P:
                                 ptobp(base,(P)p,(P *)rp); break;          ptobp(base,(P)p,(P *)rp); break;
                         case O_LIST:        case O_LIST:
                                 listtoblist(base,(LIST)p,(LIST *)rp); break;          listtoblist(base,(LIST)p,(LIST *)rp); break;
                         case O_VECT:        case O_VECT:
                                 vecttobvect(base,(VECT)p,(VECT *)rp); break;          vecttobvect(base,(VECT)p,(VECT *)rp); break;
                         case O_MAT:        case O_MAT:
                                 mattobmat(base,(MAT)p,(MAT *)rp); break;          mattobmat(base,(MAT)p,(MAT *)rp); break;
                         case O_STR:        case O_STR:
                                 *rp = p; break;          *rp = p; break;
                         case O_COMP: default:        case O_COMP: default:
                                 error("objtobobj : not implemented"); break;          error("objtobobj : not implemented"); break;
                 }      }
 }  }
   
 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;
         else    else
                 switch ( OID(p) ) {      switch ( OID(p) ) {
                         case O_N:        case O_N:
                                 bnumtonum(base,(Num)p,(Num *)rp); break;          bnumtonum(base,(Num)p,(Num *)rp); break;
                         case O_P:        case O_P:
                                 bptop(base,(P)p,(P *)rp); break;          bptop(base,(P)p,(P *)rp); break;
                         case O_LIST:        case O_LIST:
                                 blisttolist(base,(LIST)p,(LIST *)rp); break;          blisttolist(base,(LIST)p,(LIST *)rp); break;
                         case O_VECT:        case O_VECT:
                                 bvecttovect(base,(VECT)p,(VECT *)rp); break;          bvecttovect(base,(VECT)p,(VECT *)rp); break;
                         case O_MAT:        case O_MAT:
                                 bmattomat(base,(MAT)p,(MAT *)rp); break;          bmattomat(base,(MAT)p,(MAT *)rp); break;
                         case O_STR:        case O_STR:
                                 *rp = p; break;          *rp = p; break;
                         case O_COMP: default:        case O_COMP: default:
                                 error("bobjtoobj : not implemented"); break;          error("bobjtoobj : not implemented"); break;
                 }      }
 }  }
   
 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;
         LM l;    LM l;
   
         if ( !p )    if ( !p )
                 *rp = 0;      *rp = 0;
         else    else
                 switch ( NID(p) ) {      switch ( NID(p) ) {
                         case N_Q:        case N_Q:
                                 ntobn(base,NM((Q)p),&nm);          ntobn(base,NM((Q)p),&nm);
                                 if ( DN((Q)p) ) {          if ( DN((Q)p) ) {
                                         ntobn(base,DN((Q)p),&dn);            ntobn(base,DN((Q)p),&dn);
                                         NDTOQ(nm,dn,SGN((Q)p),q);            NDTOQ(nm,dn,SGN((Q)p),q);
                                 } else          } else
                                         NTOQ(nm,SGN((Q)p),q);            NTOQ(nm,SGN((Q)p),q);
                                 *rp = (Num)q;          *rp = (Num)q;
                                 break;          break;
                         case N_R:        case N_R:
                                 *rp = p; break;          *rp = p; break;
                         case N_LM:        case N_LM:
                                 ntobn(base,((LM)p)->body,&body);          ntobn(base,((LM)p)->body,&body);
                                 MKLM(body,l); *rp = (Num)l;          MKLM(body,l); *rp = (Num)l;
                                 break;          break;
                         default:        default:
                                 error("numtobnum : not implemented"); break;          error("numtobnum : not implemented"); break;
                 }      }
 }  }
   
 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;
         LM l;    LM l;
   
         if ( !p )    if ( !p )
                 *rp = 0;      *rp = 0;
         else    else
                 switch ( NID(p) ) {      switch ( NID(p) ) {
                         case N_Q:        case N_Q:
                                 bnton(base,NM((Q)p),&nm);          bnton(base,NM((Q)p),&nm);
                                 if ( DN((Q)p) ) {          if ( DN((Q)p) ) {
                                         bnton(base,DN((Q)p),&dn);            bnton(base,DN((Q)p),&dn);
                                         NDTOQ(nm,dn,SGN((Q)p),q);            NDTOQ(nm,dn,SGN((Q)p),q);
                                 } else          } else
                                         NTOQ(nm,SGN((Q)p),q);            NTOQ(nm,SGN((Q)p),q);
                                 *rp = (Num)q;          *rp = (Num)q;
                                 break;          break;
                         case N_R:        case N_R:
                                 *rp = p; break;          *rp = p; break;
                         case N_LM:        case N_LM:
                                 bnton(base,((LM)p)->body,&body);          bnton(base,((LM)p)->body,&body);
                                 MKLM(body,l); *rp = (Num)l;          MKLM(body,l); *rp = (Num)l;
                                 break;          break;
                         default:        default:
                                 error("bnumtonum : not implemented"); break;          error("bnumtonum : not implemented"); break;
                 }      }
 }  }
   
 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;
   
         if ( !p )    if ( !p )
                 *rp = p;      *rp = p;
         else {    else {
                 for ( dcr0 = 0, dc = DC(p); dc; dc = NEXT(dc) ) {      for ( dcr0 = 0, dc = DC(p); dc; dc = NEXT(dc) ) {
                         NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc);        NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc);
                         objtobobj(base,(Obj)COEF(dc),(Obj *)&COEF(dcr));        objtobobj(base,(Obj)COEF(dc),(Obj *)&COEF(dcr));
                 }      }
                 NEXT(dcr) = 0;      NEXT(dcr) = 0;
                 MKP(VR(p),dcr0,*rp);      MKP(VR(p),dcr0,*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;
   
         if ( !p )    if ( !p )
                 *rp = p;      *rp = p;
         else {    else {
                 for ( dcr0 = 0, dc = DC(p); dc; dc = NEXT(dc) ) {      for ( dcr0 = 0, dc = DC(p); dc; dc = NEXT(dc) ) {
                         NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc);        NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc);
                         bobjtoobj(base,(Obj)COEF(dc),(Obj *)&COEF(dcr));        bobjtoobj(base,(Obj)COEF(dc),(Obj *)&COEF(dcr));
                 }      }
                 NEXT(dcr) = 0;      NEXT(dcr) = 0;
                 MKP(VR(p),dcr0,*rp);      MKP(VR(p),dcr0,*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;
   
         if ( !p )    if ( !p )
                 *rp = p;      *rp = p;
         else {    else {
                 for ( nr0 = 0, n = BDY(p); n; n = NEXT(n) ) {      for ( nr0 = 0, n = BDY(p); n; n = NEXT(n) ) {
                         NEXTNODE(nr0,nr);        NEXTNODE(nr0,nr);
                         objtobobj(base,BDY(n),(Obj *)&BDY(nr));        objtobobj(base,BDY(n),(Obj *)&BDY(nr));
                 }      }
                 NEXT(nr) = 0;      NEXT(nr) = 0;
                 MKLIST(*rp,nr0);      MKLIST(*rp,nr0);
         }    }
 }  }
   
 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;
   
         if ( !p )    if ( !p )
                 *rp = p;      *rp = p;
         else {    else {
                 for ( nr0 = 0, n = BDY(p); n; n = NEXT(n) ) {      for ( nr0 = 0, n = BDY(p); n; n = NEXT(n) ) {
                         NEXTNODE(nr0,nr);        NEXTNODE(nr0,nr);
                         bobjtoobj(base,BDY(n),(Obj *)&BDY(nr));        bobjtoobj(base,BDY(n),(Obj *)&BDY(nr));
                 }      }
                 NEXT(nr) = 0;      NEXT(nr) = 0;
                 MKLIST(*rp,nr0);      MKLIST(*rp,nr0);
         }    }
 }  }
   
 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;
   
         if ( !p )    if ( !p )
                 *rp = p;      *rp = p;
         else {    else {
                 l = p->len;      l = p->len;
                 MKVECT(r,l); *rp = r;      MKVECT(r,l); *rp = r;
                 for ( i = 0; i < l; i++ )      for ( i = 0; i < l; i++ )
                         objtobobj(base,p->body[i],(Obj *)&r->body[i]);        objtobobj(base,p->body[i],(Obj *)&r->body[i]);
         }    }
 }  }
   
 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;
   
         if ( !p )    if ( !p )
                 *rp = p;      *rp = p;
         else {    else {
                 l = p->len;      l = p->len;
                 MKVECT(r,l); *rp = r;      MKVECT(r,l); *rp = r;
                 for ( i = 0; i < l; i++ )      for ( i = 0; i < l; i++ )
                         bobjtoobj(base,p->body[i],(Obj *)&r->body[i]);        bobjtoobj(base,p->body[i],(Obj *)&r->body[i]);
         }    }
 }  }
   
 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;
   
         if ( !p )    if ( !p )
                 *rp = p;      *rp = p;
         else {    else {
                 row = p->row; col = p->col;      row = p->row; col = p->col;
                 MKMAT(r,row,col); *rp = r;      MKMAT(r,row,col); *rp = r;
                 for ( i = 0; i < row; i++ )      for ( i = 0; i < row; i++ )
                         for ( j = 0; i < col; j++ )        for ( j = 0; i < col; j++ )
                         objtobobj(base,p->body[i][j],(Obj *)&r->body[i][j]);        objtobobj(base,p->body[i][j],(Obj *)&r->body[i][j]);
         }    }
 }  }
   
 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;
   
         if ( !p )    if ( !p )
                 *rp = p;      *rp = p;
         else {    else {
                 row = p->row; col = p->col;      row = p->row; col = p->col;
                 MKMAT(r,row,col); *rp = r;      MKMAT(r,row,col); *rp = r;
                 for ( i = 0; i < row; i++ )      for ( i = 0; i < row; i++ )
                         for ( j = 0; i < col; j++ )        for ( j = 0; i < col; j++ )
                         bobjtoobj(base,p->body[i][j],(Obj *)&r->body[i][j]);        bobjtoobj(base,p->body[i][j],(Obj *)&r->body[i][j]);
         }    }
 }  }
   
 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;
         unsigned int *a,*b;    unsigned int *a,*b;
         N z;    N z;
   
         l = PL(g); a = BD(g);    l = PL(g); a = BD(g);
         for ( i = 31, t = a[l-1]; !(t&(1<<i)); i-- );    for ( i = 31, t = a[l-1]; !(t&(1<<i)); i-- );
         bits = (l-1)*32+i+1; words = (bits+26)/27;    bits = (l-1)*32+i+1; words = (bits+26)/27;
         *rp = z = NALLOC(words); PL(z) = words;    *rp = z = NALLOC(words); PL(z) = words;
         bzero((char *)BD(z),words*sizeof(unsigned int));    bzero((char *)BD(z),words*sizeof(unsigned int));
         for ( j = 0, b = BD(z); j < words; j++ ) {    for ( j = 0, b = BD(z); j < words; j++ ) {
                 k = (27*j)/32; r = (27*j)%32;      k = (27*j)/32; r = (27*j)%32;
                 if ( r > 5 )      if ( r > 5 )
                         b[j] = (a[k]>>r)|(k==(l-1)?0:((a[k+1]&((1<<(r-5))-1))<<(32-r)));        b[j] = (a[k]>>r)|(k==(l-1)?0:((a[k+1]&((1<<(r-5))-1))<<(32-r)));
                 else      else
                         b[j] = (a[k]>>r)&((1<<27)-1);        b[j] = (a[k]>>r)&((1<<27)-1);
         }    }
         if ( !(r = bits%27) )    if ( !(r = bits%27) )
                 r = 27;      r = 27;
         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;
         unsigned int *b,*c;    unsigned int *b,*c;
         N z;    N z;
   
         l = PL(a); b = BD(a);    l = PL(a); b = BD(a);
         for ( i = 26, t = b[l-1]; !(t&(1<<i)); i-- );    for ( i = 26, t = b[l-1]; !(t&(1<<i)); i-- );
         bits = (l-1)*27+i+1; words = (bits+31)/32;    bits = (l-1)*27+i+1; words = (bits+31)/32;
         *rp = z = NALLOC(words); PL(z) = words;    *rp = z = NALLOC(words); PL(z) = words;
         bzero((char *)BD(z),words*sizeof(unsigned int));    bzero((char *)BD(z),words*sizeof(unsigned int));
         for ( j = 0, c = BD(z); j < l; j++ ) {    for ( j = 0, c = BD(z); j < l; j++ ) {
                 k = (27*j)/32; r = (27*j)%32;      k = (27*j)/32; r = (27*j)%32;
                 if ( r > 5 ) {      if ( r > 5 ) {
                         c[k] |= (b[j]&((1<<(32-r))-1))<<r;        c[k] |= (b[j]&((1<<(32-r))-1))<<r;
                         if ( k+1 < words )        if ( k+1 < words )
                                 c[k+1] = (b[j]>>(32-r));          c[k+1] = (b[j]>>(32-r));
                 } else      } else
                         c[k] |= (b[j]<<r);        c[k] |= (b[j]<<r);
         }    }
 }  }
   
 void mptoum(p,pr)  void mptoum(P p,UM pr)
 P p;  
 UM pr;  
 {  {
         DCP dc;    DCP dc;
   
         if ( !p )    if ( !p )
                 DEG(pr) = -1;      DEG(pr) = -1;
         else if ( NUM(p) ) {    else if ( NUM(p) ) {
                 DEG(pr) = 0; COEF(pr)[0] = CONT((MQ)p);      DEG(pr) = 0; COEF(pr)[0] = CONT((MQ)p);
         } else {    } else {
                 bzero((char *)pr,(int)((UDEG(p)+2)*sizeof(int)));      bzero((char *)pr,(int)((UDEG(p)+2)*sizeof(int)));
                 for ( dc = DC(p); dc; dc = NEXT(dc) )      for ( dc = DC(p); dc; dc = NEXT(dc) )
                         COEF(pr)[QTOS(DEG(dc))] = CONT((MQ)COEF(dc));        COEF(pr)[QTOS(DEG(dc))] = CONT((MQ)COEF(dc));
                 degum(pr,UDEG(p));      degum(pr,UDEG(p));
         }    }
 }  }
   
 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;
         MQ q;    MQ q;
   
         if ( !p || (DEG(p) < 0) )    if ( !p || (DEG(p) < 0) )
                 *pr = 0;      *pr = 0;
         else if ( !DEG(p) )    else if ( !DEG(p) )
                 STOMQ(COEF(p)[0],q), *pr = (P)q;      STOMQ(COEF(p)[0],q), *pr = (P)q;
         else {    else {
                 for ( dc0 = 0, i = DEG(p); i >= 0; i-- )      for ( dc0 = 0, i = DEG(p); i >= 0; i-- )
                         if ( COEF(p)[i] ) {        if ( COEF(p)[i] ) {
                                 NEXTDC(dc0,dc); STOQ(i,DEG(dc));          NEXTDC(dc0,dc); STOQ(i,DEG(dc));
                                 STOMQ(COEF(p)[i],q), COEF(dc) = (P)q;          STOMQ(COEF(p)[i],q), COEF(dc) = (P)q;
                         }        }
                 NEXT(dc) = 0; MKP(v,dc0,*pr);      NEXT(dc) = 0; MKP(v,dc0,*pr);
         }    }
 }  }
   
 /* f(p) -> f(x) */  /* f(p) -> f(x) */
   
 void enc_to_p(p,a,v,pr)  void enc_to_p(int p,int a,V v,P *pr)
 int p,a;  
 V v;  
 P *pr;  
 {  {
         DCP dc,dct;    DCP dc,dct;
         int i,c;    int i,c;
         Q dq,cq;    Q dq,cq;
   
         dc = 0;    dc = 0;
         for ( i = 0; a; i++, a /= p ) {    for ( i = 0; a; i++, a /= p ) {
                 c = a%p;      c = a%p;
                 if ( c ) {      if ( c ) {
                         STOQ(i,dq); STOQ(c,cq);        STOQ(i,dq); STOQ(c,cq);
                         NEWDC(dct); DEG(dct) = dq; COEF(dct) = (P)cq;        NEWDC(dct); DEG(dct) = dq; COEF(dct) = (P)cq;
                         NEXT(dct) = dc; dc = dct;        NEXT(dct) = dc; dc = dct;
                 }      }
         }    }
         MKP(v,dc,*pr);    MKP(v,dc,*pr);
 }  }
Legend:
Removed from v.1.10  
changed lines
  Added in v.1.15
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>