[BACK]Return to dp-supp.c CVS log [TXT][DIR] Up to [local] / OpenXM_contrib2 / asir2018 / builtin

Diff for /OpenXM_contrib2/asir2018/builtin/dp-supp.c between version 1.7 and 1.18

version 1.7, 2019/10/11 03:45:56 version 1.18, 2022/09/10 04:04:50
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/asir2018/builtin/dp-supp.c,v 1.6 2019/09/19 06:29:47 noro Exp $   * $OpenXM: OpenXM_contrib2/asir2018/builtin/dp-supp.c,v 1.17 2020/12/15 07:40:09 noro Exp $
 */  */
 #include "ca.h"  #include "ca.h"
 #include "base.h"  #include "base.h"
Line 96  LIST get_denomlist()
Line 96  LIST get_denomlist()
   return l;    return l;
 }  }
   
   int dp_iszp(DP p)
   {
     MP m;
   
     if ( !p ) return 1;
     for ( m = BDY(p); m; m = NEXT(m))
       if ( !INT(m->c) ) return 0;
     return 1;
   }
   
 void dp_ptozp(DP p,DP *rp)  void dp_ptozp(DP p,DP *rp)
 {  {
   MP m,mr,mr0;    MP m,mr,mr0;
Line 147  void dp_ptozp2(DP p0,DP p1,DP *hp,DP *rp)
Line 157  void dp_ptozp2(DP p0,DP p1,DP *hp,DP *rp)
   *hp = h; *rp = r;    *hp = h; *rp = r;
 }  }
   
   int dpm_iszp(DPM p)
   {
     DMM m;
   
     if ( !p ) return 1;
     for ( m = BDY(p); m; m = NEXT(m))
       if ( !INT(m->c) ) return 0;
     return 1;
   }
   
 void dpm_ptozp(DPM p,Z *cont,DPM *rp)  void dpm_ptozp(DPM p,Z *cont,DPM *rp)
 {  {
   DMM m,mr,mr0;    DMM m,mr,mr0;
Line 315  int _dl_redble(DL d1,DL d2,int nvar)
Line 335  int _dl_redble(DL d1,DL d2,int nvar)
     return 1;      return 1;
 }  }
   
   int _dl_redble_ext(DL d1,DL d2,DL quo,int nvar)
   {
     int i;
   
     if ( (quo->td = d2->td-d1->td) < 0 )
       return 0;
     for ( i = 0; i < nvar; i++ )
       if ( (quo->d[i] = d2->d[i]-d1->d[i]) < 0 )
         break;
     if ( i < nvar )
       return 0;
     else
       return 1;
   }
   
 void insert_to_node(DL d,NODE *n,int nvar)  void insert_to_node(DL d,NODE *n,int nvar)
 {  {
   DL d1;    DL d1;
Line 1244  void dp_removecont2(DP p1,DP p2,DP *r1p,DP *r2p,Z *con
Line 1279  void dp_removecont2(DP p1,DP p2,DP *r1p,DP *r2p,Z *con
     *r2p = 0;      *r2p = 0;
 }  }
   
   void dpm_removecont2(DPM p1,DPM p2,DPM *r1p,DPM *r2p,Z *contp)
   {
     struct oVECT v;
     int i,n1,n2,n;
     DMM m,m0,t;
     Z *w;
     Z h;
   
     if ( p1 ) {
       for ( i = 0, m = BDY(p1); m; m = NEXT(m), i++ );
       n1 = i;
     } else
       n1 = 0;
     if ( p2 ) {
       for ( i = 0, m = BDY(p2); m; m = NEXT(m), i++ );
       n2 = i;
     } else
       n2 = 0;
     n = n1+n2;
     if ( !n ) {
       *r1p = 0; *r2p = 0; *contp = ONE; return;
     }
     w = (Z *)ALLOCA(n*sizeof(Q));
     v.len = n;
     v.body = (pointer *)w;
     i = 0;
     if ( p1 )
       for ( m = BDY(p1); i < n1; m = NEXT(m), i++ ) w[i] = (Z)m->c;
     if ( p2 )
       for ( m = BDY(p2); i < n; m = NEXT(m), i++ ) w[i] = (Z)m->c;
     h = w[0]; removecont_array((P *)w,n,1); divsz(h,w[0],contp);
     i = 0;
     if ( p1 ) {
       for ( m0 = 0, t = BDY(p1); i < n1; i++, t = NEXT(t) ) {
         NEXTDMM(m0,m); m->c = (Obj)w[i]; m->dl = t->dl; m->pos = t->pos;
       }
       NEXT(m) = 0;
       MKDPM(p1->nv,m0,*r1p); (*r1p)->sugar = p1->sugar;
     } else
       *r1p = 0;
     if ( p2 ) {
       for ( m0 = 0, t = BDY(p2); i < n; i++, t = NEXT(t) ) {
         NEXTDMM(m0,m); m->c = (Obj)w[i]; m->dl = t->dl; m->pos = t->pos;
       }
       NEXT(m) = 0;
       MKDPM(p2->nv,m0,*r2p); (*r2p)->sugar = p2->sugar;
     } else
       *r2p = 0;
   }
   
 /* true nf by a marked GB */  /* true nf by a marked GB */
   
 void dp_true_nf_marked(NODE b,DP g,DP *ps,DP *hps,DP *rp,P *nmp,P *dnp)  void dp_true_nf_marked(NODE b,DP g,DP *ps,DP *hps,DP *rp,P *nmp,P *dnp)
Line 1516  last:
Line 1601  last:
   return q;    return q;
 }  }
   
   DPM dpm_nf_and_quotient2(NODE b,DPM g,VECT psv,DPM *rp,P *dnp)
   {
     DPM u,p,s,t,d,q;
     DP dmy,mult,zzz;
     DPM *ps;
     NODE l;
     DMM mr0,mq0,mr,mq,m;
     MP mp;
     int i,n,j,len,nv;
     int *wb;
     int sugar,psugar,multiple;
     P nm,tnm1,dn,tdn,tdn1;
     Q cont;
     Obj c1;
     struct oEGT eg0,eg1;
   
     dn = (P)ONE;
     if ( !g ) {
       *rp = 0; *dnp = dn; return 0;
     }
     nv = NV(g);
     ps = (DPM *)BDY(psv);
     len = psv->len;
     if ( b ) {
       for ( n = 0, l = b; l; l = NEXT(l), n++ )
         ;
       wb = (int *)ALLOCA(n*sizeof(int));
       for ( i = 0, l = b; i < n; l = NEXT(l), i++ )
         wb[i] = ZTOS((Q)BDY(l));
     } else {
       wb = (int *)ALLOCA(len*sizeof(int));
       for ( i = j = 0; i < len; i++ )
         if ( ps[i] ) wb[j++] = i;
       n = j;
     }
     sugar = g->sugar;
     mq0 = 0;
     mr0 = 0;
     for ( ; g; ) {
       for ( u = 0, i = 0; i < n; i++ ) {
         if ( dpm_redble(g,p = ps[wb[i]]) ) {
           dpm_red2(g,p,&u,&tdn,&mult);
           psugar = (BDY(g)->dl->td - BDY(p)->dl->td) + p->sugar;
           sugar = MAX(sugar,psugar);
           for ( m = mq0; m; m = NEXT(m) ) {
             arf_mul(CO,(Obj)tdn,m->c,&c1); m->c = c1;
           }
           for ( m = mr0; m; m = NEXT(m) ) {
             arf_mul(CO,(Obj)tdn,m->c,&c1); m->c = c1;
           }
           NEXTDMM(mq0,mq);
           mq->c = BDY(mult)->c; mq->dl = BDY(mult)->dl; mq->pos = wb[i]+1;
           mulp(CO,dn,tdn,&tdn1); dn = tdn1;
           if ( !u ) goto last;
           break;
         }
       }
       if ( u ) {
         g = u;
       } else {
         m = BDY(g);
         NEXTDMM(mr0,mr);
         mr->dl = m->dl; mr->c = m->c; mr->pos = m->pos;
         dpm_rest(g,&t); g = t;
       }
     }
   last:
     if ( mr0 ) {
       NEXT(mr) = 0;
       MKDPM(nv,mr0,d); d->sugar = sugar;
     } else
       d = 0;
     if ( mq0 ) {
       NEXT(mq) = 0;
       MKDPM(nv,mq0,q); q->sugar = sugar;
     } else
       q = 0;
     *rp = d; *dnp = dn;
     return q;
   }
   
   DPM dpm_nf_and_quotient3(DPM g,VECT psv,DPM *rp,P *dnp)
   {
     DPM u,p,s,t,d,q;
     DP dmy,mult,zzz;
     DPM *ps;
     NODE2 nd;
     DMM mr0,mq0,mr,mq,m;
     MP mp;
     int i,n,j,len,nv,pos,max;
     int *wb;
     int sugar,psugar,multiple;
     P nm,tnm1,dn,tdn,tdn1;
     Q cont;
     Obj c1;
     struct oEGT eg0,eg1;
   
     dn = (P)ONE;
     if ( !g ) {
       *rp = 0; *dnp = dn; return 0;
     }
     nv = NV(g);
     sugar = g->sugar;
     mq0 = 0;
     mr0 = 0;
     max = psv->len;
     for ( ; g; ) {
       pos = BDY(g)->pos;
       u = 0;
       if ( pos < max ) {
         nd = (NODE2)BDY(psv)[pos];
         for ( u = 0; nd; nd = NEXT(nd) ) {
           if ( dpm_redble(g,p = (DPM)(nd->body1)) ) {
             dpm_red2(g,p,&u,&tdn,&mult);
             psugar = (BDY(g)->dl->td - BDY(p)->dl->td) + p->sugar;
             sugar = MAX(sugar,psugar);
             if ( !UNIZ(tdn) ) {
               for ( m = mq0; m; m = NEXT(m) ) {
                 arf_mul(CO,(Obj)tdn,m->c,&c1); m->c = c1;
               }
               for ( m = mr0; m; m = NEXT(m) ) {
                 arf_mul(CO,(Obj)tdn,m->c,&c1); m->c = c1;
               }
             }
             NEXTDMM(mq0,mq);
             mq->c = BDY(mult)->c; mq->dl = BDY(mult)->dl; mq->pos = (long)nd->body2;
             mulp(CO,dn,tdn,&tdn1); dn = tdn1;
             if ( !u ) goto last;
             break;
           }
         }
       }
       if ( u ) {
         g = u;
       } else {
         m = BDY(g);
         NEXTDMM(mr0,mr);
         mr->dl = m->dl; mr->c = m->c; mr->pos = m->pos;
         dpm_rest(g,&t); g = t;
       }
     }
   last:
     if ( mr0 ) {
       NEXT(mr) = 0;
       MKDPM(nv,mr0,d); d->sugar = sugar;
     } else
       d = 0;
     if ( mq0 ) {
       NEXT(mq) = 0;
       MKDPM(nv,mq0,q); q->sugar = sugar;
     } else
       q = 0;
     *rp = d; *dnp = dn;
     return q;
   }
   
   DPM dpm_nf_and_quotient4(DPM g,DPM *ps,VECT psiv,DPM head,DPM *rp,P *dnp)
   {
     DPM u,p,s,t,d,q;
     DP dmy,mult,zzz;
     NODE nd;
     DMM mr0,mq0,mr,mq,m;
     MP mp;
     int i,n,j,len,nv,pos,max;
     int *wb;
     int sugar,psugar,multiple;
     P nm,tnm1,dn,tdn,tdn1,c;
     Q cont;
     Obj c1;
     struct oEGT eg0,eg1;
   
     dn = (P)ONE;
     if ( !g ) {
       *rp = 0; *dnp = dn; return 0;
     }
     nv = NV(g);
     sugar = g->sugar;
     mq0 = 0;
     if ( head ) {
       for ( m = BDY(head); m; m = NEXT(m) ) {
         NEXTDMM(mq0,mq);
         mq->c = m->c; mq->dl = m->dl; mq->pos = m->pos;
       }
     }
     mr0 = 0;
     max = psiv->len;
     for ( ; g; ) {
       pos = BDY(g)->pos;
       u = 0;
       if ( pos < max ) {
         nd = (NODE)BDY(psiv)[pos];
         for ( u = 0; nd; nd = NEXT(nd) ) {
           if ( dpm_redble(g,p = ps[(long)(BDY(nd))-1]) ) {
             dpm_red2(g,p,&u,&tdn,&mult);
             psugar = (BDY(g)->dl->td - BDY(p)->dl->td) + p->sugar;
             sugar = MAX(sugar,psugar);
             if ( !UNIZ(tdn) ) {
               for ( m = mq0; m; m = NEXT(m) ) {
                 arf_mul(CO,(Obj)tdn,m->c,&c1); m->c = c1;
               }
               for ( m = mr0; m; m = NEXT(m) ) {
                 arf_mul(CO,(Obj)tdn,m->c,&c1); m->c = c1;
               }
             }
             NEXTDMM(mq0,mq);
             mq->c = BDY(mult)->c;
             mq->dl = BDY(mult)->dl; mq->pos = (long)BDY(nd);
             mulp(CO,dn,tdn,&tdn1); dn = tdn1;
             if ( !u ) goto last;
             break;
           }
         }
       }
       if ( u ) {
         g = u;
       } else {
         m = BDY(g);
         NEXTDMM(mr0,mr);
         mr->dl = m->dl; mr->c = m->c; mr->pos = m->pos;
         dpm_rest(g,&t); g = t;
       }
     }
   last:
     if ( mr0 ) {
       NEXT(mr) = 0;
       MKDPM(nv,mr0,d); d->sugar = sugar;
     } else
       d = 0;
     if ( mq0 ) {
       NEXT(mq) = 0;
       MKDPM(nv,mq0,q); q->sugar = sugar;
     } else
       q = 0;
     *rp = d; *dnp = dn;
     return q;
   }
   
   /* an intermediate version for calling from the user language */
   /* XXX : i, j must be positive */
   
   DPM dpm_sp_nf_asir(VECT psv,int i,int j,DPM *nf)
   {
     DPM *ps;
     int n,k,nv,s1,s2,sugar,max,pos,psugar;
     DPM g,u,p,d,q,t;
     DMM mq0,mq,mr0,mr,m;
     DP mult,t1,t2;
     P dn,tdn,tdn1;
     NODE nd;
     Obj c1;
   
     ps = (DPM *)BDY(psv);
     n = psv->len;
     nv = ps[1]->nv;
     dpm_sp(ps[i],ps[j],&g,&t1,&t2);
     mq0 = 0;
     NEXTDMM(mq0,mq); mq->c = BDY(t1)->c; mq->pos = i; mq->dl = BDY(t1)->dl;
     NEXTDMM(mq0,mq); chsgnp((P)BDY(t2)->c,(P *)&mq->c); mq->pos = j; mq->dl = BDY(t2)->dl;
   
     if ( !g ) {
       NEXT(mq) = 0;
       MKDPM(nv,mq0,d);
       s1 = BDY(t1)->dl->td + ps[i]->sugar;
       s2 = BDY(t2)->dl->td + ps[j]->sugar;
       d->sugar = MAX(s1,s2);
       *nf = 0;
       return d;
     }
   
     dn = (P)ONE;
     sugar = g->sugar;
     mr0 = 0;
     while ( g ) {
       pos = BDY(g)->pos;
       for ( u = 0, k = 1; k < n; k++ ) {
         if ( (p=ps[k])!=0 && pos == BDY(p)->pos && dpm_redble(g,p) ) {
           dpm_red2(g,p,&u,&tdn,&mult);
           psugar = (BDY(g)->dl->td - BDY(p)->dl->td) + p->sugar;
           sugar = MAX(sugar,psugar);
           if ( !UNIZ(tdn) ) {
             for ( m = mq0; m; m = NEXT(m) ) {
               arf_mul(CO,(Obj)tdn,m->c,&c1); m->c = c1;
             }
             for ( m = mr0; m; m = NEXT(m) ) {
               arf_mul(CO,(Obj)tdn,m->c,&c1); m->c = c1;
             }
           }
           NEXTDMM(mq0,mq);
           chsgnp((P)BDY(mult)->c,(P *)&mq->c);
           mq->dl = BDY(mult)->dl; mq->pos = k;
           mulp(CO,dn,tdn,&tdn1); dn = tdn1;
           if ( !u ) goto last;
           break;
         }
       }
       if ( u ) {
         g = u;
       } else {
         m = BDY(g);
         NEXTDMM(mr0,mr);
         mr->dl = m->dl; mr->c = m->c; mr->pos = m->pos;
         dpm_rest(g,&t); g = t;
       }
     }
   last:
     if ( mr0 ) {
       NEXT(mr) = 0; MKDPM(nv,mr0,d); d->sugar = sugar;
     } else
       d = 0;
     NEXT(mq) = 0; MKDPM(nv,mq0,q); q->sugar = sugar;
     *nf = d;
     return q;
   }
   
   DPM dpm_sp_nf(VECT psv,VECT psiv,int i,int j,DPM *nf)
   {
     DPM *ps;
     int n,nv,s1,s2,sugar,max,pos,psugar;
     DPM g,u,p,d,q,t;
     DMM mq0,mq,mr0,mr,m;
     DP mult,t1,t2;
     P dn,tdn,tdn1;
     NODE nd;
     Obj c1;
   
     ps = (DPM *)BDY(psv);
     n = psv->len;
     nv = ps[i]->nv;
     dpm_sp(ps[i],ps[j],&g,&t1,&t2);
     mq0 = 0;
     NEXTDMM(mq0,mq); mq->c = BDY(t1)->c; mq->pos = i; mq->dl = BDY(t1)->dl;
     NEXTDMM(mq0,mq); chsgnp((P)BDY(t2)->c,(P *)&mq->c); mq->pos = j; mq->dl = BDY(t2)->dl;
   
     if ( !g ) {
       NEXT(mq) = 0;
       MKDPM(nv,mq0,d);
       s1 = BDY(t1)->dl->td + ps[i]->sugar;
       s2 = BDY(t2)->dl->td + ps[j]->sugar;
       d->sugar = MAX(s1,s2);
       *nf = 0;
       return d;
     }
   
     dn = (P)ONE;
     sugar = g->sugar;
     mr0 = 0;
     max = psiv->len;
     while ( g ) {
       pos = BDY(g)->pos;
       u = 0;
       if ( pos < max ) {
         nd = (NODE)BDY(psiv)[pos];
         for ( u = 0; nd; nd = NEXT(nd) ) {
           if ( dpm_redble(g,p = ps[(long)(BDY(nd))]) ) {
             dpm_red2(g,p,&u,&tdn,&mult);
             psugar = (BDY(g)->dl->td - BDY(p)->dl->td) + p->sugar;
             sugar = MAX(sugar,psugar);
             if ( !UNIZ(tdn) ) {
               for ( m = mq0; m; m = NEXT(m) ) {
                 arf_mul(CO,(Obj)tdn,m->c,&c1); m->c = c1;
               }
               for ( m = mr0; m; m = NEXT(m) ) {
                 arf_mul(CO,(Obj)tdn,m->c,&c1); m->c = c1;
               }
             }
             NEXTDMM(mq0,mq);
             chsgnp((P)BDY(mult)->c,(P *)&mq->c);
             mq->dl = BDY(mult)->dl; mq->pos = (long)BDY(nd);
             mulp(CO,dn,tdn,&tdn1); dn = tdn1;
             if ( !u ) goto last;
             break;
           }
         }
       }
       if ( u ) {
         g = u;
       } else {
         m = BDY(g);
         NEXTDMM(mr0,mr);
         mr->dl = m->dl; mr->c = m->c; mr->pos = m->pos;
         dpm_rest(g,&t); g = t;
       }
     }
   last:
     if ( mr0 ) {
       NEXT(mr) = 0; MKDPM(nv,mr0,d); d->sugar = sugar;
     } else
       d = 0;
     NEXT(mq) = 0; MKDPM(nv,mq0,q); q->sugar = sugar;
     *nf = d;
     return q;
   }
   
   /* psiv is a vector of lists of Z */
   
   DPM dpm_sp_nf_zlist(VECT psv,VECT psiv,int i,int j,int top,DPM *nf)
   {
     DPM *ps;
     int n,nv,s1,s2,sugar,max,pos,psugar;
     DPM g,u,p,d,q,t;
     DMM mq0,mq,mr0,mr,m;
     DP mult,t1,t2;
     P dn,tdn,tdn1;
     NODE nd;
     Obj c1;
   
     ps = (DPM *)BDY(psv);
     n = psv->len;
     nv = ps[i]->nv;
     dpm_sp(ps[i],ps[j],&g,&t1,&t2);
     mq0 = 0;
     NEXTDMM(mq0,mq); mq->c = BDY(t1)->c; mq->pos = i; mq->dl = BDY(t1)->dl;
     NEXTDMM(mq0,mq); chsgnp((P)BDY(t2)->c,(P *)&mq->c); mq->pos = j; mq->dl = BDY(t2)->dl;
   
     if ( !g ) {
       NEXT(mq) = 0;
       MKDPM(nv,mq0,d);
       s1 = BDY(t1)->dl->td + ps[i]->sugar;
       s2 = BDY(t2)->dl->td + ps[j]->sugar;
       d->sugar = MAX(s1,s2);
       *nf = 0;
       return d;
     }
   
     dn = (P)ONE;
     sugar = g->sugar;
     mr0 = 0;
     max = psiv->len;
     while ( g ) {
       pos = BDY(g)->pos;
       u = 0;
       if ( pos < max ) {
         nd = BDY((LIST)BDY(psiv)[pos]);
         for ( u = 0; nd; nd = NEXT(nd) ) {
           if ( dpm_redble(g,p = ps[ZTOS((Q)BDY(nd))]) ) {
             dpm_red2(g,p,&u,&tdn,&mult);
             psugar = (BDY(g)->dl->td - BDY(p)->dl->td) + p->sugar;
             sugar = MAX(sugar,psugar);
             if ( !UNIZ(tdn) ) {
               for ( m = mq0; m; m = NEXT(m) ) {
                 arf_mul(CO,(Obj)tdn,m->c,&c1); m->c = c1;
               }
               for ( m = mr0; m; m = NEXT(m) ) {
                 arf_mul(CO,(Obj)tdn,m->c,&c1); m->c = c1;
               }
             }
             NEXTDMM(mq0,mq);
             chsgnp((P)BDY(mult)->c,(P *)&mq->c);
             mq->dl = BDY(mult)->dl; mq->pos = ZTOS((Q)BDY(nd));
             mulp(CO,dn,tdn,&tdn1); dn = tdn1;
             if ( !u ) goto last;
             break;
           }
         }
       }
       if ( u ) {
         g = u;
       } else if ( !top ) {
         m = BDY(g);
         NEXTDMM(mr0,mr);
         mr->dl = m->dl; mr->c = m->c; mr->pos = m->pos;
         dpm_rest(g,&t); g = t;
       } else {
         *nf = g;
         if ( mq0 ) {
           NEXT(mq) = 0; MKDPM(nv,mq0,q); q->sugar = sugar;
         } else
           q = 0;
         return q;
       }
     }
   last:
     if ( mr0 ) {
       NEXT(mr) = 0; MKDPM(nv,mr0,d); d->sugar = sugar;
     } else
       d = 0;
     NEXT(mq) = 0; MKDPM(nv,mq0,q); q->sugar = sugar;
     *nf = d;
     return q;
   }
   
 DP *dp_true_nf_and_quotient_marked_mod(NODE b,DP g,DP *ps,DP *hps,int mod,DP *rp,P *dnp)  DP *dp_true_nf_and_quotient_marked_mod(NODE b,DP g,DP *ps,DP *hps,int mod,DP *rp,P *dnp)
 {  {
   DP u,p,d,s,t,dmy,hp,mult;    DP u,p,d,s,t,dmy,hp,mult;
Line 1772  void dpm_split(DPM p,int s,DPM *up,DPM *lo)
Line 2338  void dpm_split(DPM p,int s,DPM *up,DPM *lo)
   }    }
 }  }
   
   /* extract the component in DP of position s */
   void dpm_extract(DPM p,int s,DP *r)
   {
     DMM m;
     MP mu0,mu;
     DP t;
   
     if ( !p ) {
       *r = 0; return;
     }
     for ( m = BDY(p), mu0 = 0; m; m = NEXT(m) ) {
       if ( m->pos == s ) {
         NEXTMP(mu0,mu);
         mu->dl = m->dl; mu->c = m->c;
       }
     }
     if ( mu0 ) {
       NEXT(mu) = 0; MKDP(p->nv,mu0,t); t->sugar = p->sugar;
       *r = t;
     } else
       *r = 0;
   }
   
 /* nf computation over a field */  /* nf computation over a field */
   
 void dp_nf_f(NODE b,DP g,DP *ps,int full,DP *rp)  void dp_nf_f(NODE b,DP g,DP *ps,int full,DP *rp)
Line 2193  int create_order_spec(VL vl,Obj obj,struct order_spec 
Line 2782  int create_order_spec(VL vl,Obj obj,struct order_spec 
             spec->pot_nelim = 0;              spec->pot_nelim = 0;
         break;          break;
   
       case 3: /* [n,[wv,wm],ord] */        case 3: /* [n,[mlist1,mlist2,...],ord] or [n,[wv,wm],ord] */
         spec->module_ordtype = ZTOS((Z)BDY(node));          spec->module_ordtype = ZTOS((Z)BDY(node));
         if ( spec->module_ordtype < 0  ) {          if ( spec->module_ordtype < 0  ) {
             spec->pot_nelim = -spec->module_ordtype;              spec->pot_nelim = -spec->module_ordtype;
Line 2227  int create_order_spec(VL vl,Obj obj,struct order_spec 
Line 2816  int create_order_spec(VL vl,Obj obj,struct order_spec 
           create_order_spec(0,baseobj,&basespec);            create_order_spec(0,baseobj,&basespec);
           basespec->obj = baseobj;            basespec->obj = baseobj;
           spec->base = basespec;            spec->base = basespec;
         } else {  /* weighted order */          } else if ( spec->module_ordtype == 4 ) {  /* POT with base order [n,bord,ord] */
             NODE base_ord;
             int rank;
   
             create_order_spec(0,(Obj)BDY(NEXT(NEXT(node))),&spec);
             spec->id += 256; spec->obj = obj;
             spec->top_weight = 0;
             spec->module_rank = 0;
             spec->module_top_weight = 0;
             spec->pot_nelim = 0;
             spec->module_ordtype = 4;
             node = NEXT(node);
             if ( !BDY(node) || OID(BDY(node)) != O_LIST )
               error("create_order_spec : a permitation list must be specified");
             base_ord = BDY((LIST)BDY(node));
             spec->module_rank = rank = length(base_ord);
             spec->module_base_ord = (int *)MALLOC_ATOMIC((rank+1)*sizeof(int));
             for ( i = 1, t = base_ord; i <= rank; i++, t = NEXT(t) )
               spec->module_base_ord[ZTOS((Q)BDY(t))] = i;
             break;
           } else {  /* weighted order * [n,[wv,wm],ord] */
           int ordtype;            int ordtype;
   
           ordtype = spec->module_ordtype;            ordtype = spec->module_ordtype;
Line 2749  void dp_mod(DP p,int mod,NODE subst,DP *rp)
Line 3358  void dp_mod(DP p,int mod,NODE subst,DP *rp)
   }    }
 }  }
   
   void dpm_mod(DPM p,int mod,DPM *rp)
   {
     DMM m,mr,mr0;
     P t;
     V v;
     NODE tn;
   
     if ( !p )
       *rp = 0;
     else {
       for ( mr0 = 0, m = BDY(p); m; m = NEXT(m) ) {
         ptomp(mod,(P)m->c,&t);
         if ( t ) {
           NEXTDMM(mr0,mr); mr->c = (Obj)t; mr->dl = m->dl;
         }
       }
       if ( mr0 ) {
         NEXT(mr) = 0; MKDPM(p->nv,mr0,*rp); (*rp)->sugar = p->sugar;
       } else
         *rp = 0;
     }
   }
   
 void dp_rat(DP p,DP *rp)  void dp_rat(DP p,DP *rp)
 {  {
   MP m,mr,mr0;    MP m,mr,mr0;
Line 3048  void dpm_rest(DPM p,DPM *rp)
Line 3680  void dpm_rest(DPM p,DPM *rp)
     if ( *rp )      if ( *rp )
       (*rp)->sugar = p->sugar;        (*rp)->sugar = p->sugar;
   }    }
   }
   
   int dp_getdeg(DP p)
   {
     int max,n,i;
     MP m;
     int *d;
   
     if ( !p ) return 0;
     n = p->nv;
     max = 0;
     for ( m = BDY(p); m; m = NEXT(m) ) {
       d = m->dl->d;
       for ( i = 0; i < n; i++ )
         if ( d[i] > max ) max = d[i];
     }
     return max;
 }  }
   
 int dpm_getdeg(DPM p,int *r)  int dpm_getdeg(DPM p,int *r)
Legend:
Removed from v.1.7  
changed lines
  Added in v.1.18
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>