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

Diff for /OpenXM_contrib2/asir2000/engine/P.c between version 1.11 and 1.12

version 1.11, 2004/08/18 01:10:59 version 1.12, 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/P.c,v 1.10 2004/08/18 00:17:02 noro Exp $   * $OpenXM: OpenXM_contrib2/asir2000/engine/P.c,v 1.11 2004/08/18 01:10:59 noro Exp $
 */  */
 #ifndef FBASE  #ifndef FBASE
 #define FBASE  #define FBASE
Line 62  int sgn;
Line 62  int sgn;
 Q *c;  Q *c;
 P *pr;  P *pr;
 {  {
         N nm,dn;    N nm,dn;
   
         if ( !p ) {    if ( !p ) {
                 *c = 0; *pr = 0;      *c = 0; *pr = 0;
         } else {    } else {
                 lgp(p,&nm,&dn);      lgp(p,&nm,&dn);
                 if ( UNIN(dn) )      if ( UNIN(dn) )
                         NTOQ(nm,sgn,*c);        NTOQ(nm,sgn,*c);
                 else      else
                         NDTOQ(nm,dn,sgn,*c);        NDTOQ(nm,dn,sgn,*c);
                 divcp(p,*c,pr);      divcp(p,*c,pr);
         }    }
 }  }
   
 void lgp(p,g,l)  void lgp(p,g,l)
 P p;  P p;
 N *g,*l;  N *g,*l;
 {  {
         N g1,g2,l1,l2,l3,l4,tmp;    N g1,g2,l1,l2,l3,l4,tmp;
         DCP dc;    DCP dc;
   
         if ( NUM(p) ) {    if ( NUM(p) ) {
                 *g = NM((Q)p);      *g = NM((Q)p);
                 if ( INT((Q)p) )      if ( INT((Q)p) )
                         *l = ONEN;        *l = ONEN;
                 else      else
                         *l = DN((Q)p);        *l = DN((Q)p);
         } else {    } else {
                 dc = DC(p); lgp(COEF(dc),g,l);      dc = DC(p); lgp(COEF(dc),g,l);
                 for ( dc = NEXT(dc); dc; dc = NEXT(dc) ) {      for ( dc = NEXT(dc); dc; dc = NEXT(dc) ) {
                         lgp(COEF(dc),&g1,&l1); gcdn(*g,g1,&g2); *g = g2;        lgp(COEF(dc),&g1,&l1); gcdn(*g,g1,&g2); *g = g2;
                         gcdn(*l,l1,&l2); kmuln(*l,l1,&l3); divn(l3,l2,&l4,&tmp); *l = l4;        gcdn(*l,l1,&l2); kmuln(*l,l1,&l3); divn(l3,l2,&l4,&tmp); *l = l4;
                 }      }
         }    }
 }  }
   
 void divcp(f,q,rp)  void divcp(f,q,rp)
Line 103  P f;
Line 103  P f;
 Q q;  Q q;
 P *rp;  P *rp;
 {  {
         DCP dc,dcr,dcr0;    DCP dc,dcr,dcr0;
   
         if ( !f )    if ( !f )
                 *rp = 0;      *rp = 0;
         else if ( NUM(f) )    else if ( NUM(f) )
                 DIVNUM(f,q,rp);      DIVNUM(f,q,rp);
         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);        NEXTDC(dcr0,dcr); DEG(dcr) = DEG(dc);
                         divcp(COEF(dc),q,&COEF(dcr));        divcp(COEF(dc),q,&COEF(dcr));
                 }      }
                 NEXT(dcr) = 0; MKP(VR(f),dcr0,*rp);      NEXT(dcr) = 0; MKP(VR(f),dcr0,*rp);
         }    }
 }  }
   
 void diffp(vl,p,v,r)  void diffp(vl,p,v,r)
Line 124  P p;
Line 124  P p;
 V v;  V v;
 P *r;  P *r;
 {  {
         P t;    P t;
         DCP dc,dcr,dcr0;    DCP dc,dcr,dcr0;
   
         if ( !p || NUM(p) )    if ( !p || NUM(p) )
                 *r = 0;      *r = 0;
         else {    else {
                 if ( v == VR(p) ) {      if ( v == VR(p) ) {
                         for ( dc = DC(p), dcr0 = 0; dc; dc = NEXT(dc) ) {        for ( dc = DC(p), dcr0 = 0; dc; dc = NEXT(dc) ) {
                                 if ( !DEG(dc) ) continue;          if ( !DEG(dc) ) continue;
                                 MULPQ(COEF(dc),(P)DEG(dc),&t);          MULPQ(COEF(dc),(P)DEG(dc),&t);
                                 if ( t ) {          if ( t ) {
                                         NEXTDC(dcr0,dcr); SUBQ(DEG(dc),ONE,&DEG(dcr));            NEXTDC(dcr0,dcr); SUBQ(DEG(dc),ONE,&DEG(dcr));
                                         COEF(dcr) = t;            COEF(dcr) = t;
                                 }          }
                         }        }
                         if ( !dcr0 )        if ( !dcr0 )
                                 *r = 0;          *r = 0;
                         else {        else {
                                 NEXT(dcr) = 0; MKP(v,dcr0,*r);          NEXT(dcr) = 0; MKP(v,dcr0,*r);
                         }        }
                 } else {      } else {
                         for ( dc = DC(p), dcr0 = 0; dc; dc = NEXT(dc) ) {        for ( dc = DC(p), dcr0 = 0; dc; dc = NEXT(dc) ) {
                                 diffp(vl,COEF(dc),v,&t);          diffp(vl,COEF(dc),v,&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 )
                                 *r = 0;          *r = 0;
                         else {        else {
                                 NEXT(dcr) = 0; MKP(VR(p),dcr0,*r);          NEXT(dcr) = 0; MKP(VR(p),dcr0,*r);
                         }        }
                 }      }
         }    }
 }  }
   
 /* Euler derivation */  /* Euler derivation */
Line 167  P p;
Line 167  P p;
 V v;  V v;
 P *r;  P *r;
 {  {
         P t;    P t;
         DCP dc,dcr,dcr0;    DCP dc,dcr,dcr0;
   
         if ( !p || NUM(p) )    if ( !p || NUM(p) )
                 *r = 0;      *r = 0;
         else {    else {
                 if ( v == VR(p) ) {      if ( v == VR(p) ) {
                         for ( dc = DC(p), dcr0 = 0; dc; dc = NEXT(dc) ) {        for ( dc = DC(p), dcr0 = 0; dc; dc = NEXT(dc) ) {
                                 if ( !DEG(dc) ) continue;          if ( !DEG(dc) ) continue;
                                 MULPQ(COEF(dc),(P)DEG(dc),&t);          MULPQ(COEF(dc),(P)DEG(dc),&t);
                                 if ( t ) {          if ( t ) {
                                         NEXTDC(dcr0,dcr);            NEXTDC(dcr0,dcr);
                                         DEG(dcr) = DEG(dc);            DEG(dcr) = DEG(dc);
                                         COEF(dcr) = t;            COEF(dcr) = t;
                                 }          }
                         }        }
                         if ( !dcr0 )        if ( !dcr0 )
                                 *r = 0;          *r = 0;
                         else {        else {
                                 NEXT(dcr) = 0; MKP(v,dcr0,*r);          NEXT(dcr) = 0; MKP(v,dcr0,*r);
                         }        }
                 } else {      } else {
                         for ( dc = DC(p), dcr0 = 0; dc; dc = NEXT(dc) ) {        for ( dc = DC(p), dcr0 = 0; dc; dc = NEXT(dc) ) {
                                 ediffp(vl,COEF(dc),v,&t);          ediffp(vl,COEF(dc),v,&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 )
                                 *r = 0;          *r = 0;
                         else {        else {
                                 NEXT(dcr) = 0; MKP(VR(p),dcr0,*r);          NEXT(dcr) = 0; MKP(VR(p),dcr0,*r);
                         }        }
                 }      }
         }    }
 }  }
   
 void coefp(p,d,pr)  void coefp(p,d,pr)
Line 209  P p;
Line 209  P p;
 int d;  int d;
 P *pr;  P *pr;
 {  {
         DCP dc;    DCP dc;
         int sgn;    int sgn;
         Q dq;    Q dq;
   
         if ( NUM(p) )    if ( NUM(p) )
                 if ( d == 0 )      if ( d == 0 )
                         *pr = p;        *pr = p;
                 else      else
                         *pr = 0;        *pr = 0;
         else {    else {
                 for ( STOQ(d,dq), dc = DC(p); dc; dc = NEXT(dc) )      for ( STOQ(d,dq), dc = DC(p); dc; dc = NEXT(dc) )
                         if ( (sgn = cmpq(DEG(dc),dq)) > 0 )        if ( (sgn = cmpq(DEG(dc),dq)) > 0 )
                                 continue;          continue;
                         else if ( sgn == 0 ) {        else if ( sgn == 0 ) {
                                 *pr = COEF(dc);          *pr = COEF(dc);
                                 return;          return;
                         } else {        } else {
                                 *pr = 0;          *pr = 0;
                                 break;          break;
                         }        }
                 *pr = 0;      *pr = 0;
         }    }
 }  }
   
 int compp(vl,p1,p2)  int compp(vl,p1,p2)
 VL vl;  VL vl;
 P p1,p2;  P p1,p2;
 {  {
         DCP dc1,dc2;    DCP dc1,dc2;
         V v1,v2;    V v1,v2;
   
         if ( !p1 )    if ( !p1 )
                 return p2 ? -1 : 0;      return p2 ? -1 : 0;
         else if ( !p2 )    else if ( !p2 )
                 return 1;      return 1;
         else if ( NUM(p1) )    else if ( NUM(p1) )
                 return NUM(p2) ? (*cmpnumt[MAX(NID(p1),NID(p2))])(p1,p2) : -1;      return NUM(p2) ? (*cmpnumt[MAX(NID(p1),NID(p2))])(p1,p2) : -1;
         else if ( NUM(p2) )    else if ( NUM(p2) )
                 return 1;      return 1;
         if ( (v1 = VR(p1)) == (v2 = VR(p2)) ) {    if ( (v1 = VR(p1)) == (v2 = VR(p2)) ) {
                 for ( dc1 = DC(p1), dc2 = DC(p2);      for ( dc1 = DC(p1), dc2 = DC(p2);
                         dc1 && dc2; dc1 = NEXT(dc1), dc2 = NEXT(dc2) )        dc1 && dc2; dc1 = NEXT(dc1), dc2 = NEXT(dc2) )
                         switch ( cmpq(DEG(dc1),DEG(dc2)) ) {        switch ( cmpq(DEG(dc1),DEG(dc2)) ) {
                                 case 1:          case 1:
                                         return 1; break;            return 1; break;
                                 case -1:          case -1:
                                         return -1; break;            return -1; break;
                                 default:          default:
                                         switch ( compp(vl,COEF(dc1),COEF(dc2)) ) {            switch ( compp(vl,COEF(dc1),COEF(dc2)) ) {
                                                 case 1:              case 1:
                                                         return 1; break;                return 1; break;
                                                 case -1:              case -1:
                                                         return -1; break;                return -1; break;
                                                 default:              default:
                                                         break;                break;
                                         }            }
                                         break;            break;
                         }        }
                 return dc1 ? 1 : (dc2 ? -1 : 0);      return dc1 ? 1 : (dc2 ? -1 : 0);
         } else {    } else {
                 for ( ; v1 != VR(vl) && v2 != VR(vl); vl = NEXT(vl) );      for ( ; v1 != VR(vl) && v2 != VR(vl); vl = NEXT(vl) );
                 return v1 == VR(vl) ? 1 : -1;      return v1 == VR(vl) ? 1 : -1;
         }    }
 }  }
   
 int equalp(vl,p1,p2)  int equalp(vl,p1,p2)
 VL vl;  VL vl;
 P p1,p2;  P p1,p2;
 {  {
         DCP dc1,dc2;    DCP dc1,dc2;
         V v1,v2;    V v1,v2;
   
         if ( !p1 ) {    if ( !p1 ) {
                 if ( !p2 ) return 1;      if ( !p2 ) return 1;
                 else return 0;      else return 0;
         }    }
         /* p1 != 0 */    /* p1 != 0 */
         if ( !p2 ) return 0;    if ( !p2 ) return 0;
   
         /* p1 != 0, p2 != 0 */    /* p1 != 0, p2 != 0 */
         if ( NUM(p1) ) {    if ( NUM(p1) ) {
                 if ( !NUM(p2) ) return 0;      if ( !NUM(p2) ) return 0;
                 /* p1 and p2 are numbers */      /* p1 and p2 are numbers */
                 if ( NID((Num)p1) != NID((Num)p2) ) return 0;      if ( NID((Num)p1) != NID((Num)p2) ) return 0;
                 if ( !(*cmpnumt[NID(p1),NID(p1)])(p1,p2) ) return 1;      if ( !(*cmpnumt[NID(p1),NID(p1)])(p1,p2) ) return 1;
                 return 0;      return 0;
         }    }
         if ( VR(p1) != VR(p2) ) return 0;    if ( VR(p1) != VR(p2) ) return 0;
         for ( dc1 = DC(p1), dc2 = DC(p2);    for ( dc1 = DC(p1), dc2 = DC(p2);
                 dc1 && dc2; dc1 = NEXT(dc1), dc2 = NEXT(dc2) ) {      dc1 && dc2; dc1 = NEXT(dc1), dc2 = NEXT(dc2) ) {
                 if ( cmpq(DEG(dc1),DEG(dc2)) ) return 0;      if ( cmpq(DEG(dc1),DEG(dc2)) ) return 0;
                 else if ( !equalp(vl,COEF(dc1),COEF(dc2)) ) return 0;      else if ( !equalp(vl,COEF(dc1),COEF(dc2)) ) return 0;
         }    }
         if ( dc1 || dc2 ) return 0;    if ( dc1 || dc2 ) return 0;
         else return 1;    else return 1;
 }  }
   
 void csump(vl,p,c)  void csump(vl,p,c)
Line 311  VL vl;
Line 311  VL vl;
 P p;  P p;
 Q *c;  Q *c;
 {  {
         DCP dc;    DCP dc;
         Q s,s1,s2;    Q s,s1,s2;
   
         if ( !p || NUM(p) )    if ( !p || NUM(p) )
                 *c = (Q)p;      *c = (Q)p;
         else {    else {
                 for ( dc = DC(p), s = 0; dc; dc = NEXT(dc) ) {      for ( dc = DC(p), s = 0; dc; dc = NEXT(dc) ) {
                         csump(vl,COEF(dc),&s1); addq(s,s1,&s2); s = s2;        csump(vl,COEF(dc),&s1); addq(s,s1,&s2); s = s2;
                 }      }
                 *c = s;      *c = s;
         }    }
 }  }
   
 void degp(v,p,d)  void degp(v,p,d)
Line 329  V v;
Line 329  V v;
 P p;  P p;
 Q *d;  Q *d;
 {  {
         DCP dc;    DCP dc;
         Q m,m1;    Q m,m1;
   
         if ( !p || NUM(p) )    if ( !p || NUM(p) )
                 *d = 0;      *d = 0;
         else if ( v == VR(p) )    else if ( v == VR(p) )
                 *d = DEG(DC(p));      *d = DEG(DC(p));
         else {    else {
                 for ( dc = DC(p), m = 0; dc; dc = NEXT(dc) ) {      for ( dc = DC(p), m = 0; dc; dc = NEXT(dc) ) {
                         degp(v,COEF(dc),&m1);        degp(v,COEF(dc),&m1);
                         if ( cmpq(m,m1) < 0 )        if ( cmpq(m,m1) < 0 )
                                 m = m1;          m = m1;
                 }      }
                 *d = m;      *d = m;
         }    }
 }  }
   
 void mulpc_trunc(VL vl,P p,P c,VN vn,P *pr);  void mulpc_trunc(VL vl,P p,P c,VN vn,P *pr);
Line 352  void mulp_trunc(VL vl,P p1,P p2,VN vn,P *pr);
Line 352  void mulp_trunc(VL vl,P p1,P p2,VN vn,P *pr);
   
 void mulp_trunc(VL vl,P p1,P p2,VN vn,P *pr)  void mulp_trunc(VL vl,P p1,P p2,VN vn,P *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,i,d,d1;    int n1,n2,i,d,d1;
   
         if ( !p1 || !p2 ) *pr = 0;    if ( !p1 || !p2 ) *pr = 0;
         else if ( NUM(p1) )    else if ( NUM(p1) )
                 mulpq_trunc(p2,(Q)p1,vn,pr);      mulpq_trunc(p2,(Q)p1,vn,pr);
         else if ( NUM(p2) )    else if ( NUM(p2) )
                 mulpq_trunc(p1,(Q)p2,vn,pr);      mulpq_trunc(p1,(Q)p2,vn,pr);
         else if ( ( v1 = VR(p1) ) ==  ( v2 = VR(p2) ) ) {    else if ( ( v1 = VR(p1) ) ==  ( v2 = VR(p2) ) ) {
                 for ( ; vn->v && vn->v != v1; vn++ )      for ( ; vn->v && vn->v != v1; vn++ )
                         if ( vn->n ) {        if ( vn->n ) {
                                 /* p1,p2 do not contain vn->v */          /* p1,p2 do not contain vn->v */
                                 *pr = 0;          *pr = 0;
                                 return;          return;
                         }        }
                 if ( !vn->v )      if ( !vn->v )
                         error("mulp_trunc : invalid vn");        error("mulp_trunc : invalid vn");
                 d = vn->n;      d = vn->n;
                 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) ) {
                                 d1 = QTOS(DEG(dct))+QTOS(DEG(dc));          d1 = QTOS(DEG(dct))+QTOS(DEG(dc));
                                 if ( d1 >= d ) {          if ( d1 >= d ) {
                                         mulp_trunc(vl,COEF(dct),COEF(dc),vn+1,&t);            mulp_trunc(vl,COEF(dct),COEF(dc),vn+1,&t);
                                         if ( t ) {            if ( t ) {
                                                 NEXTDC(dcr0,dcr);              NEXTDC(dcr0,dcr);
                                                 STOQ(d1,DEG(dcr));              STOQ(d1,DEG(dcr));
                                                 COEF(dcr) = t;              COEF(dcr) = t;
                                         }            }
                                 }          }
                         }        }
                         if ( dcr0 ) {        if ( dcr0 ) {
                                 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_trunc(vl,p1,p2,vn,pr);        mulpc_trunc(vl,p1,p2,vn,pr);
                 else      else
                         mulpc_trunc(vl,p2,p1,vn,pr);        mulpc_trunc(vl,p2,p1,vn,pr);
         }    }
 }  }
   
 void mulpq_trunc(P p,Q q,VN vn,P *pr)  void mulpq_trunc(P p,Q q,VN vn,P *pr)
 {  {
         DCP dc,dcr,dcr0;    DCP dc,dcr,dcr0;
         P t;    P t;
         int i,d;    int i,d;
         V v;    V v;
   
         if (!p || !q)    if (!p || !q)
                 *pr = 0;      *pr = 0;
         else if ( NUM(p) ) {    else if ( NUM(p) ) {
                 for ( ; vn->v; vn++ )      for ( ; vn->v; vn++ )
                         if ( vn->n ) {        if ( vn->n ) {
                                 *pr = 0;          *pr = 0;
                                 return;          return;
                         }        }
                 MULNUM(p,q,pr);      MULNUM(p,q,pr);
         } else {    } else {
                 v = VR(p);      v = VR(p);
                 for ( ; vn->v && vn->v != v; vn++ ) {      for ( ; vn->v && vn->v != v; vn++ ) {
                         if ( vn->n ) {        if ( vn->n ) {
                                 /* p does not contain vn->v */          /* p does not contain vn->v */
                                 *pr = 0;          *pr = 0;
                                 return;          return;
                         }        }
                 }      }
                 if ( !vn->v )      if ( !vn->v )
                         error("mulpq_trunc : invalid vn");        error("mulpq_trunc : invalid vn");
                 d = vn->n;      d = vn->n;
                 for ( dcr0 = 0, dc = DC(p); dc && QTOS(DEG(dc)) >= d; dc = NEXT(dc) ) {      for ( dcr0 = 0, dc = DC(p); dc && QTOS(DEG(dc)) >= d; dc = NEXT(dc) ) {
                         mulpq_trunc(COEF(dc),q,vn+1,&t);        mulpq_trunc(COEF(dc),q,vn+1,&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 mulpc_trunc(VL vl,P p,P c,VN vn,P *pr)  void mulpc_trunc(VL vl,P p,P c,VN vn,P *pr)
 {  {
         DCP dc,dcr,dcr0;    DCP dc,dcr,dcr0;
         P t;    P t;
         V v;    V v;
         int i,d;    int i,d;
   
         if ( NUM(c) )    if ( NUM(c) )
                 mulpq_trunc(p,(Q)c,vn,pr);      mulpq_trunc(p,(Q)c,vn,pr);
         else {    else {
                 v = VR(p);      v = VR(p);
                 for ( ; vn->v && vn->v != v; vn++ )      for ( ; vn->v && vn->v != v; vn++ )
                         if ( vn->n ) {        if ( vn->n ) {
                                 /* p,c do not contain vn->v */          /* p,c do not contain vn->v */
                                 *pr = 0;          *pr = 0;
                                 return;          return;
                         }        }
                 if ( !vn->v )      if ( !vn->v )
                         error("mulpc_trunc : invalid vn");        error("mulpc_trunc : invalid vn");
                 d = vn->n;      d = vn->n;
                 for ( dcr0 = 0, dc = DC(p); dc && QTOS(DEG(dc)) >= d; dc = NEXT(dc) ) {      for ( dcr0 = 0, dc = DC(p); dc && QTOS(DEG(dc)) >= d; dc = NEXT(dc) ) {
                         mulp_trunc(vl,COEF(dc),c,vn+1,&t);        mulp_trunc(vl,COEF(dc),c,vn+1,&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 quop_trunc(VL vl,P p1,P p2,VN vn,P *pr)  void quop_trunc(VL vl,P p1,P p2,VN vn,P *pr)
 {  {
         DCP dc,dcq0,dcq;    DCP dc,dcq0,dcq;
         P t,s,m,lc2,qt;    P t,s,m,lc2,qt;
         V v1,v2;    V v1,v2;
         Q d2;    Q d2;
         VN vn1;    VN vn1;
   
         if ( !p1 )    if ( !p1 )
                 *pr = 0;      *pr = 0;
         else if ( NUM(p2) )    else if ( NUM(p2) )
                 divsp(vl,p1,p2,pr);      divsp(vl,p1,p2,pr);
         else if ( (v1 = VR(p1)) != (v2 = VR(p2)) ) {    else if ( (v1 = VR(p1)) != (v2 = VR(p2)) ) {
                 for ( dcq0 = 0, dc = DC(p1); dc; dc = NEXT(dc) ) {      for ( dcq0 = 0, dc = DC(p1); dc; dc = NEXT(dc) ) {
                         NEXTDC(dcq0,dcq);        NEXTDC(dcq0,dcq);
                         DEG(dcq) = DEG(dc);        DEG(dcq) = DEG(dc);
                         quop_trunc(vl,COEF(dc),p2,vn,&COEF(dcq));        quop_trunc(vl,COEF(dc),p2,vn,&COEF(dcq));
                 }      }
                 NEXT(dcq) = 0;      NEXT(dcq) = 0;
                 MKP(v1,dcq0,*pr);      MKP(v1,dcq0,*pr);
         } else {    } else {
                 d2 = DEG(DC(p2));      d2 = DEG(DC(p2));
                 lc2 = COEF(DC(p2));      lc2 = COEF(DC(p2));
                 t = p1;      t = p1;
                 dcq0 = 0;      dcq0 = 0;
                 /* vn1 = degree list of LC(p2) */      /* vn1 = degree list of LC(p2) */
                 for ( vn1 = vn; vn1->v != v1; vn1++ );      for ( vn1 = vn; vn1->v != v1; vn1++ );
                 vn1++;      vn1++;
                 while ( t ) {      while ( t ) {
                         dc = DC(t);        dc = DC(t);
                         NEXTDC(dcq0,dcq);        NEXTDC(dcq0,dcq);
                         subq(DEG(dc),d2,&DEG(dcq));        subq(DEG(dc),d2,&DEG(dcq));
                         quop_trunc(vl,COEF(dc),lc2,vn1,&COEF(dcq));        quop_trunc(vl,COEF(dc),lc2,vn1,&COEF(dcq));
                         NEXT(dcq) = 0;        NEXT(dcq) = 0;
                         MKP(v1,dcq,qt);        MKP(v1,dcq,qt);
                         mulp_trunc(vl,p2,qt,vn,&m);        mulp_trunc(vl,p2,qt,vn,&m);
                         subp(vl,t,m,&s); t = s;        subp(vl,t,m,&s); t = s;
                 }      }
                 NEXT(dcq) = 0;      NEXT(dcq) = 0;
                 MKP(v1,dcq0,*pr);      MKP(v1,dcq0,*pr);
         }    }
 }  }
Legend:
Removed from v.1.11  
changed lines
  Added in v.1.12
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>