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

Diff for /OpenXM_contrib2/asir2000/engine/poly.c between version 1.2 and 1.3

version 1.2, 2005/07/03 10:19:22 version 1.3, 2018/03/29 01:32:52
Line 2  void D_ADDP(vl,p1,p2,pr)
Line 2  void D_ADDP(vl,p1,p2,pr)
 VL vl;  VL vl;
 P p1,p2,*pr;  P p1,p2,*pr;
 {  {
         register DCP dc1,dc2,dcr0,dcr;    register DCP dc1,dc2,dcr0,dcr;
         V v1,v2;    V v1,v2;
         P t;    P t;
   
         if ( !p1 )    if ( !p1 )
                 *pr = p2;      *pr = p2;
         else if ( !p2 )    else if ( !p2 )
                 *pr = p1;      *pr = p1;
         else if ( NUM(p1) )    else if ( NUM(p1) )
                 if ( NUM(p2) )      if ( NUM(p2) )
                         ADDNUM(p1,p2,pr);        ADDNUM(p1,p2,pr);
                 else      else
                         ADDPQ(p2,p1,pr);        ADDPQ(p2,p1,pr);
         else if ( NUM(p2) )    else if ( NUM(p2) )
                 ADDPQ(p1,p2,pr);      ADDPQ(p1,p2,pr);
         else if ( ( v1 = VR(p1) ) ==  ( v2 = VR(p2) ) ) {    else if ( ( v1 = VR(p1) ) ==  ( v2 = VR(p2) ) ) {
                 for ( dc1 = DC(p1), dc2 = DC(p2), dcr0 = 0; dc1 && dc2; )      for ( dc1 = DC(p1), dc2 = DC(p2), dcr0 = 0; dc1 && dc2; )
                         switch ( cmpq(DEG(dc1),DEG(dc2)) ) {        switch ( cmpq(DEG(dc1),DEG(dc2)) ) {
                                 case 0:          case 0:
                                         ADDP(vl,COEF(dc1),COEF(dc2),&t);            ADDP(vl,COEF(dc1),COEF(dc2),&t);
                                         if ( t )  {            if ( t )  {
                                                 NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc1); COEF(dcr) = t;              NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc1); COEF(dcr) = t;
                                         }            }
                                         dc1 = NEXT(dc1); dc2 = NEXT(dc2); break;            dc1 = NEXT(dc1); dc2 = NEXT(dc2); break;
                                 case 1:          case 1:
                                         NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc1); COEF(dcr) = COEF(dc1);            NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc1); COEF(dcr) = COEF(dc1);
                                         dc1 = NEXT(dc1); break;            dc1 = NEXT(dc1); break;
                                 case -1:          case -1:
                                         NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc2); COEF(dcr) = COEF(dc2);            NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc2); COEF(dcr) = COEF(dc2);
                                         dc2 = NEXT(dc2); break;            dc2 = NEXT(dc2); break;
                         }        }
                 if ( !dcr0 )      if ( !dcr0 )
                         if ( dc1 )        if ( dc1 )
                                 dcr0 = dc1;          dcr0 = dc1;
                         else if ( dc2 )        else if ( dc2 )
                                 dcr0 = dc2;          dcr0 = dc2;
                         else {        else {
                                 *pr = 0;          *pr = 0;
                                 return;          return;
                         }        }
                 else      else
                         if ( dc1 )        if ( dc1 )
                                 NEXT(dcr) = dc1;          NEXT(dcr) = dc1;
                         else if ( dc2 )        else if ( dc2 )
                                 NEXT(dcr) = dc2;          NEXT(dcr) = dc2;
                         else        else
                                 NEXT(dcr) = 0;          NEXT(dcr) = 0;
                 MKP(v1,dcr0,*pr);      MKP(v1,dcr0,*pr);
         } else {    } else {
                 while ( v1 != VR(vl) && v2 != VR(vl) )      while ( v1 != VR(vl) && v2 != VR(vl) )
                         vl = NEXT(vl);        vl = NEXT(vl);
                 if ( v1 == VR(vl) )      if ( v1 == VR(vl) )
                         ADDPTOC(vl,p1,p2,pr);        ADDPTOC(vl,p1,p2,pr);
                 else      else
                         ADDPTOC(vl,p2,p1,pr);        ADDPTOC(vl,p2,p1,pr);
         }    }
 }  }
   
 void D_ADDPQ(p,q,pr)  void D_ADDPQ(p,q,pr)
 P p,q,*pr;  P p,q,*pr;
 {  {
         DCP dc,dcr,dcr0;    DCP dc,dcr,dcr0;
         P t;    P t;
   
         if ( NUM(p) )    if ( NUM(p) )
                 ADDNUM(p,q,pr);      ADDNUM(p,q,pr);
         else {    else {
                 dc = DC(p);      dc = DC(p);
                 for ( dcr0 = 0; dc && cmpq(DEG(dc),0) > 0; dc = NEXT(dc) ) {      for ( dcr0 = 0; dc && cmpq(DEG(dc),0) > 0; dc = NEXT(dc) ) {
                         NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc); COEF(dcr) = COEF(dc);        NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc); COEF(dcr) = COEF(dc);
                 }      }
                 if ( !dc ) {      if ( !dc ) {
                         NEXTDC(dcr0,dcr);        NEXTDC(dcr0,dcr);
                         DEG(dcr) = 0; COEF(dcr) = q; NEXT(dcr) = 0;        DEG(dcr) = 0; COEF(dcr) = q; NEXT(dcr) = 0;
                 } else if ( !DEG(dc) ) {      } else if ( !DEG(dc) ) {
                         ADDPQ(COEF(dc),q,&t);        ADDPQ(COEF(dc),q,&t);
                         if ( t ) {        if ( t ) {
                                 NEXTDC(dcr0,dcr);          NEXTDC(dcr0,dcr);
                                 DEG(dcr) = 0; COEF(dcr) = t;          DEG(dcr) = 0; COEF(dcr) = t;
                         }        }
                         NEXT(dcr) = NEXT(dc);        NEXT(dcr) = NEXT(dc);
                 } else {      } else {
                         NEXTDC(dcr0,dcr);        NEXTDC(dcr0,dcr);
                         DEG(dcr) = 0; COEF(dcr) = q; NEXT(dcr) = dc;        DEG(dcr) = 0; COEF(dcr) = q; NEXT(dcr) = dc;
                 }      }
                 MKP(VR(p),dcr0,*pr);      MKP(VR(p),dcr0,*pr);
         }    }
 }  }
   
 void D_ADDPTOC(vl,p,c,pr)  void D_ADDPTOC(vl,p,c,pr)
 VL vl;  VL vl;
 P p,c,*pr;  P p,c,*pr;
 {  {
         DCP dc,dcr,dcr0;    DCP dc,dcr,dcr0;
         P t;    P t;
   
         for ( dcr0 = 0, dc = DC(p); dc && cmpq(DEG(dc),0) > 0; dc = NEXT(dc) ) {    for ( dcr0 = 0, dc = DC(p); dc && cmpq(DEG(dc),0) > 0; dc = NEXT(dc) ) {
                 NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc); COEF(dcr) = COEF(dc);      NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc); COEF(dcr) = COEF(dc);
         }    }
         if ( !dc ) {    if ( !dc ) {
                 NEXTDC(dcr0,dcr);      NEXTDC(dcr0,dcr);
                 DEG(dcr) = 0; COEF(dcr) = c; NEXT(dcr) = 0;      DEG(dcr) = 0; COEF(dcr) = c; NEXT(dcr) = 0;
         } else if ( !DEG(dc) ) {    } else if ( !DEG(dc) ) {
                 ADDP(vl,COEF(dc),c,&t);      ADDP(vl,COEF(dc),c,&t);
                 if ( t ) {      if ( t ) {
                         NEXTDC(dcr0,dcr);        NEXTDC(dcr0,dcr);
                         DEG(dcr) = 0; COEF(dcr) = t;        DEG(dcr) = 0; COEF(dcr) = t;
                 }      }
                 NEXT(dcr) = NEXT(dc);      NEXT(dcr) = NEXT(dc);
         } else {    } else {
                 NEXTDC(dcr0,dcr);      NEXTDC(dcr0,dcr);
                 DEG(dcr) = 0; COEF(dcr) = c; NEXT(dcr) = dc;      DEG(dcr) = 0; COEF(dcr) = c; NEXT(dcr) = dc;
         }    }
         MKP(VR(p),dcr0,*pr);    MKP(VR(p),dcr0,*pr);
 }  }
   
 void D_SUBP(vl,p1,p2,pr)  void D_SUBP(vl,p1,p2,pr)
 VL vl;  VL vl;
 P p1,p2,*pr;  P p1,p2,*pr;
 {  {
         P t;    P t;
   
         if ( !p2 )    if ( !p2 )
                 *pr = p1;      *pr = p1;
         else {    else {
                 CHSGNP(p2,&t); ADDP(vl,p1,t,pr);      CHSGNP(p2,&t); ADDP(vl,p1,t,pr);
         }    }
 }  }
   
 void D_MULP(vl,p1,p2,pr)  void D_MULP(vl,p1,p2,pr)
 VL vl;  VL vl;
 P p1,p2,*pr;  P p1,p2,*pr;
 {  {
         register DCP dc,dct,dcr,dcr0;    register DCP dc,dct,dcr,dcr0;
         V v1,v2;    V v1,v2;
         P t,s,u;    P t,s,u;
         int n1,n2;    int n1,n2;
   
         if ( !p1 || !p2 ) *pr = 0;    if ( !p1 || !p2 ) *pr = 0;
         else if ( NUM(p1) )    else if ( NUM(p1) )
                 MULPQ(p2,p1,pr);      MULPQ(p2,p1,pr);
         else if ( NUM(p2) )    else if ( NUM(p2) )
                 MULPQ(p1,p2,pr);      MULPQ(p1,p2,pr);
         else if ( ( v1 = VR(p1) ) ==  ( v2 = VR(p2) ) ) {    else if ( ( v1 = VR(p1) ) ==  ( v2 = VR(p2) ) ) {
                 for ( dc = DC(p1), n1 = 0; dc; dc = NEXT(dc), n1++ );      for ( dc = DC(p1), n1 = 0; dc; dc = NEXT(dc), n1++ );
                 for ( dc = DC(p2), n2 = 0; dc; dc = NEXT(dc), n2++ );      for ( dc = DC(p2), n2 = 0; dc; dc = NEXT(dc), n2++ );
                 if ( n1 > n2 )      if ( n1 > n2 )
                         for ( dc = DC(p2), s = 0; dc; dc = NEXT(dc) ) {        for ( dc = DC(p2), s = 0; dc; dc = NEXT(dc) ) {
                                 for ( dcr0 = 0, dct = DC(p1); dct; dct = NEXT(dct) ) {          for ( dcr0 = 0, dct = DC(p1); dct; dct = NEXT(dct) ) {
                                         NEXTDC(dcr0,dcr); MULP(vl,COEF(dct),COEF(dc),&COEF(dcr));            NEXTDC(dcr0,dcr); MULP(vl,COEF(dct),COEF(dc),&COEF(dcr));
                                         addq(DEG(dct),DEG(dc),&DEG(dcr));            addq(DEG(dct),DEG(dc),&DEG(dcr));
                                 }          }
                                 NEXT(dcr) = 0; MKP(v1,dcr0,t);          NEXT(dcr) = 0; MKP(v1,dcr0,t);
                                 ADDP(vl,s,t,&u); s = u; t = u = 0;          ADDP(vl,s,t,&u); s = u; t = u = 0;
                         }        }
                 else      else
                         for ( dc = DC(p1), s = 0; dc; dc = NEXT(dc) ) {        for ( dc = DC(p1), s = 0; dc; dc = NEXT(dc) ) {
                                 for ( dcr0 = 0, dct = DC(p2); dct; dct = NEXT(dct) ) {          for ( dcr0 = 0, dct = DC(p2); dct; dct = NEXT(dct) ) {
                                         NEXTDC(dcr0,dcr); MULP(vl,COEF(dct),COEF(dc),&COEF(dcr));            NEXTDC(dcr0,dcr); MULP(vl,COEF(dct),COEF(dc),&COEF(dcr));
                                         addq(DEG(dct),DEG(dc),&DEG(dcr));            addq(DEG(dct),DEG(dc),&DEG(dcr));
                                 }          }
                                 NEXT(dcr) = 0; MKP(v1,dcr0,t);          NEXT(dcr) = 0; MKP(v1,dcr0,t);
                                 ADDP(vl,s,t,&u); s = u; t = u = 0;          ADDP(vl,s,t,&u); s = u; t = u = 0;
                         }        }
                 *pr = s;      *pr = s;
         } else {    } else {
                 while ( v1 != VR(vl) && v2 != VR(vl) )      while ( v1 != VR(vl) && v2 != VR(vl) )
                         vl = NEXT(vl);        vl = NEXT(vl);
                 if ( v1 == VR(vl) )      if ( v1 == VR(vl) )
                         MULPC(vl,p1,p2,pr);        MULPC(vl,p1,p2,pr);
                 else      else
                         MULPC(vl,p2,p1,pr);        MULPC(vl,p2,p1,pr);
         }    }
 }  }
   
 void D_MULPQ(p,q,pr)  void D_MULPQ(p,q,pr)
 P p,q,*pr;  P p,q,*pr;
 {  {
         DCP dc,dcr,dcr0;    DCP dc,dcr,dcr0;
         P t;    P t;
   
         if (!p || !q)    if (!p || !q)
                 *pr = 0;      *pr = 0;
         else if ( Uniq(q) )    else if ( Uniq(q) )
                 *pr = p;      *pr = p;
         else if ( NUM(p) )    else if ( NUM(p) )
                 MULNUM(p,q,pr);      MULNUM(p,q,pr);
         else {    else {
                 for ( dcr0 = 0, dc = DC(p); dc; dc = NEXT(dc) ) {      for ( dcr0 = 0, dc = DC(p); dc; dc = NEXT(dc) ) {
                         MULPQ(COEF(dc),q,&t);        MULPQ(COEF(dc),q,&t);
                         if ( t ) {        if ( t ) {
                                 NEXTDC(dcr0,dcr); COEF(dcr) = t; DEG(dcr) = DEG(dc);          NEXTDC(dcr0,dcr); COEF(dcr) = t; DEG(dcr) = DEG(dc);
                         }        }
                 }      }
                 if ( dcr0 ) {      if ( dcr0 ) {
                         NEXT(dcr) = 0; MKP(VR(p),dcr0,*pr);        NEXT(dcr) = 0; MKP(VR(p),dcr0,*pr);
                 } else      } else
                         *pr = 0;        *pr = 0;
         }    }
 }  }
   
 void D_MULPC(vl,p,c,pr)  void D_MULPC(vl,p,c,pr)
 VL vl;  VL vl;
 P p,c,*pr;  P p,c,*pr;
 {  {
         DCP dc,dcr,dcr0;    DCP dc,dcr,dcr0;
         P t;    P t;
   
         if ( NUM(c) )    if ( NUM(c) )
                 MULPQ(p,c,pr);      MULPQ(p,c,pr);
         else {    else {
                 for ( dcr0 = 0, dc = DC(p); dc; dc = NEXT(dc) ) {      for ( dcr0 = 0, dc = DC(p); dc; dc = NEXT(dc) ) {
                         MULP(vl,COEF(dc),c,&t);        MULP(vl,COEF(dc),c,&t);
                         if ( t ) {        if ( t ) {
                                 NEXTDC(dcr0,dcr); COEF(dcr) = t; DEG(dcr) = DEG(dc);          NEXTDC(dcr0,dcr); COEF(dcr) = t; DEG(dcr) = DEG(dc);
                         }        }
                 }      }
                 if ( dcr0 ) {      if ( dcr0 ) {
                         NEXT(dcr) = 0; MKP(VR(p),dcr0,*pr);        NEXT(dcr) = 0; MKP(VR(p),dcr0,*pr);
                 } else      } else
                         *pr = 0;        *pr = 0;
         }    }
 }  }
   
 void D_PWRP(vl,p,q,pr)  void D_PWRP(vl,p,q,pr)
Line 231  VL vl;
Line 231  VL vl;
 P p,*pr;  P p,*pr;
 Q q;  Q q;
 {  {
         DCP dc,dcr;    DCP dc,dcr;
         int n,i;    int n,i;
         P *x,*y;    P *x,*y;
         P t,s,u;    P t,s,u;
         DCP dct;    DCP dct;
         P *pt;    P *pt;
   
         if ( !q ) {    if ( !q ) {
                 *pr = (P)One;      *pr = (P)One;
         } else if ( !p )    } else if ( !p )
                 *pr = 0;      *pr = 0;
         else if ( UNIQ(q) )    else if ( UNIQ(q) )
                 *pr = p;      *pr = p;
         else if ( NUM(p) )    else if ( NUM(p) )
                 PWRNUM(p,q,pr);      PWRNUM(p,q,pr);
         else {    else {
                 dc = DC(p);      dc = DC(p);
                 if ( !NEXT(dc) ) {      if ( !NEXT(dc) ) {
                         NEWDC(dcr);        NEWDC(dcr);
                         PWRP(vl,COEF(dc),q,&COEF(dcr)); mulq(DEG(dc),q,&DEG(dcr));        PWRP(vl,COEF(dc),q,&COEF(dcr)); mulq(DEG(dc),q,&DEG(dcr));
                         NEXT(dcr) = 0; MKP(VR(p),dcr,*pr);        NEXT(dcr) = 0; MKP(VR(p),dcr,*pr);
                 } else if ( !INT(q) ) {      } else if ( !INT(q) ) {
                         error("pwrp: can't calculate fractional power."); *pr = 0;        error("pwrp: can't calculate fractional power."); *pr = 0;
                 } else if ( PL(NM(q)) == 1 ) {      } else if ( PL(NM(q)) == 1 ) {
                         n = QTOS(q); x = (P *)ALLOCA((n+1)*sizeof(pointer));        n = QTOS(q); x = (P *)ALLOCA((n+1)*sizeof(pointer));
                         NEWDC(dct); DEG(dct) = DEG(dc); COEF(dct) = COEF(dc);        NEWDC(dct); DEG(dct) = DEG(dc); COEF(dct) = COEF(dc);
                         NEXT(dct) = 0; MKP(VR(p),dct,t);        NEXT(dct) = 0; MKP(VR(p),dct,t);
                         for ( i = 0, u = (P)One; i < n; i++ ) {        for ( i = 0, u = (P)One; i < n; i++ ) {
                                 x[i] = u; MULP(vl,u,t,&s); u = s;          x[i] = u; MULP(vl,u,t,&s); u = s;
                         }        }
                         x[n] = u; y = (P *)ALLOCA((n+1)*sizeof(pointer));        x[n] = u; y = (P *)ALLOCA((n+1)*sizeof(pointer));
   
                         MKP(VR(p),NEXT(dc),t);        MKP(VR(p),NEXT(dc),t);
                         for ( i = 0, u = (P)One; i < n; i++ ) {        for ( i = 0, u = (P)One; i < n; i++ ) {
                                 y[i] = u; MULP(vl,u,t,&s); u = s;          y[i] = u; MULP(vl,u,t,&s); u = s;
                         }        }
                         y[n] = u;        y[n] = u;
                         pt = (P *)ALLOCA((n+1)*sizeof(pointer)); MKBC(n,pt);        pt = (P *)ALLOCA((n+1)*sizeof(pointer)); MKBC(n,pt);
                         for ( i = 0, u = 0; i <= n; i++ ) {        for ( i = 0, u = 0; i <= n; i++ ) {
                                 MULP(vl,x[i],y[n-i],&t); MULP(vl,t,pt[i],&s);          MULP(vl,x[i],y[n-i],&t); MULP(vl,t,pt[i],&s);
                                 ADDP(vl,u,s,&t); u = t;          ADDP(vl,u,s,&t); u = t;
                         }        }
                         *pr = u;        *pr = u;
                 } else {      } else {
                         error("exponent too big");        error("exponent too big");
                         *pr = 0;        *pr = 0;
                 }      }
         }    }
 }  }
   
 void D_CHSGNP(p,pr)  void D_CHSGNP(p,pr)
 P p,*pr;  P p,*pr;
 {  {
         register DCP dc,dcr,dcr0;    register DCP dc,dcr,dcr0;
   
         if ( !p )    if ( !p )
                 *pr = NULL;      *pr = NULL;
         else if ( NUM(p) ) {    else if ( NUM(p) ) {
 #if defined(_PA_RISC1_1) || defined(__alpha) || defined(mips) || defined(_IBMR2)  #if defined(_PA_RISC1_1) || defined(__alpha) || defined(mips) || defined(_IBMR2)
 #ifdef FBASE  #ifdef FBASE
                 chsgnnum((Num)p,(Num *)pr);      chsgnnum((Num)p,(Num *)pr);
 #else  #else
                 MQ mq;      MQ mq;
   
                 NEWMQ(mq); CONT(mq)=mod-CONT((MQ)p); *pr = (P)mq;      NEWMQ(mq); CONT(mq)=mod-CONT((MQ)p); *pr = (P)mq;
 #endif  #endif
 #else  #else
                 CHSGNNUM(p,*pr);      CHSGNNUM(p,*pr);
 #endif  #endif
         } 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); CHSGNP(COEF(dc),&COEF(dcr)); DEG(dcr) = DEG(dc);        NEXTDC(dcr0,dcr); CHSGNP(COEF(dc),&COEF(dcr)); DEG(dcr) = DEG(dc);
                 }      }
                 NEXT(dcr) = 0; MKP(VR(p),dcr0,*pr);      NEXT(dcr) = 0; MKP(VR(p),dcr0,*pr);
         }    }
 }  }
   
Legend:
Removed from v.1.2  
changed lines
  Added in v.1.3
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>