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

Diff for /OpenXM_contrib2/asir2000/builtin/dp.c between version 1.7 and 1.8

version 1.7, 2000/12/05 01:24:50 version 1.8, 2000/12/05 06:59:15
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/builtin/dp.c,v 1.6 2000/08/22 05:03:57 noro Exp $   * $OpenXM: OpenXM_contrib2/asir2000/builtin/dp.c,v 1.7 2000/12/05 01:24:50 noro Exp $
 */  */
 #include "ca.h"  #include "ca.h"
 #include "base.h"  #include "base.h"
 #include "parse.h"  #include "parse.h"
   
 extern int dp_fcoeffs;  extern int dp_fcoeffs;
   extern int dp_nelim;
   extern int dp_order_pair_length;
   extern struct order_pair *dp_order_pair;
   extern struct order_spec dp_current_spec;
   
   
 void Pdp_ord(), Pdp_ptod(), Pdp_dtop();  void Pdp_ord(), Pdp_ptod(), Pdp_dtop();
 void Pdp_ptozp(), Pdp_ptozp2(), Pdp_red(), Pdp_red2(), Pdp_lcm(), Pdp_redble();  void Pdp_ptozp(), Pdp_ptozp2(), Pdp_red(), Pdp_red2(), Pdp_lcm(), Pdp_redble();
 void Pdp_sp(), Pdp_hm(), Pdp_ht(), Pdp_hc(), Pdp_rest(), Pdp_td(), Pdp_sugar();  void Pdp_sp(), Pdp_hm(), Pdp_ht(), Pdp_hc(), Pdp_rest(), Pdp_td(), Pdp_sugar();
Line 67  void Pdp_gr_mod_main();
Line 72  void Pdp_gr_mod_main();
 void Pdp_gr_main(),Pdp_gr_hm_main(),Pdp_gr_d_main(),Pdp_gr_flags();  void Pdp_gr_main(),Pdp_gr_hm_main(),Pdp_gr_d_main(),Pdp_gr_flags();
 void Pdp_f4_main(),Pdp_f4_mod_main();  void Pdp_f4_main(),Pdp_f4_mod_main();
 void Pdp_gr_print();  void Pdp_gr_print();
   void Pdp_mbase(),Pdp_lnf_mod(),Pdp_nf_tab_mod(),Pdp_mdtod();
   void Pdp_vtoe(), Pdp_etov(), Pdp_dtov(), Pdp_idiv(), Pdp_sep();
   void Pdp_cont();
   
 struct ftab dp_tab[] = {  struct ftab dp_tab[] = {
         {"dp_ord",Pdp_ord,-1},          /* content reduction */
         {"dp_ptod",Pdp_ptod,2},  
         {"dp_dtop",Pdp_dtop,2},  
         {"dp_ptozp",Pdp_ptozp,1},          {"dp_ptozp",Pdp_ptozp,1},
         {"dp_ptozp2",Pdp_ptozp2,2},          {"dp_ptozp2",Pdp_ptozp2,2},
         {"dp_prim",Pdp_prim,1},          {"dp_prim",Pdp_prim,1},
         {"dp_redble",Pdp_redble,2},          {"dp_red_coef",Pdp_red_coef,2},
         {"dp_subd",Pdp_subd,2},          {"dp_cont",Pdp_cont,1},
         {"dp_red",Pdp_red,3},  
         {"dp_red_mod",Pdp_red_mod,4},          /* s-poly */
         {"dp_sp",Pdp_sp,2},          {"dp_sp",Pdp_sp,2},
         {"dp_sp_mod",Pdp_sp_mod,3},          {"dp_sp_mod",Pdp_sp_mod,3},
         {"dp_lcm",Pdp_lcm,2},  
         {"dp_hm",Pdp_hm,1},          /* m-reduction */
         {"dp_ht",Pdp_ht,1},          {"dp_red",Pdp_red,3},
         {"dp_hc",Pdp_hc,1},          {"dp_red_mod",Pdp_red_mod,4},
         {"dp_rest",Pdp_rest,1},  
         {"dp_td",Pdp_td,1},          /* normal form */
         {"dp_sugar",Pdp_sugar,1},  
         {"dp_cri1",Pdp_cri1,2},  
         {"dp_cri2",Pdp_cri2,2},  
         {"dp_criB",Pdp_criB,3},  
         {"dp_minp",Pdp_minp,2},  
         {"dp_mod",Pdp_mod,3},  
         {"dp_rat",Pdp_rat,1},  
         {"dp_tdiv",Pdp_tdiv,2},  
         {"dp_red_coef",Pdp_red_coef,2},  
         {"dp_nelim",Pdp_nelim,-1},  
         {"dp_mag",Pdp_mag,1},  
         {"dp_set_kara",Pdp_set_kara,-1},  
         {"dp_nf",Pdp_nf,4},          {"dp_nf",Pdp_nf,4},
         {"dp_true_nf",Pdp_true_nf,4},          {"dp_true_nf",Pdp_true_nf,4},
         {"dp_nf_ptozp",Pdp_nf_ptozp,5},          {"dp_nf_ptozp",Pdp_nf_ptozp,5},
         {"dp_nf_demand",Pdp_nf_demand,5},          {"dp_nf_demand",Pdp_nf_demand,5},
         {"dp_nf_mod",Pdp_nf_mod,5},          {"dp_nf_mod",Pdp_nf_mod,5},
         {"dp_true_nf_mod",Pdp_true_nf_mod,5},          {"dp_true_nf_mod",Pdp_true_nf_mod,5},
         {"dp_homo",Pdp_homo,1},          {"dp_lnf_mod",Pdp_lnf_mod,3},
         {"dp_dehomo",Pdp_dehomo,1},          {"dp_nf_tab_mod",Pdp_nf_tab_mod,3},
   
           /* Buchberger algorithm */
         {"dp_gr_main",Pdp_gr_main,5},          {"dp_gr_main",Pdp_gr_main,5},
 /*      {"dp_gr_hm_main",Pdp_gr_hm_main,5}, */  
 /*      {"dp_gr_d_main",Pdp_gr_d_main,6}, */  
         {"dp_gr_mod_main",Pdp_gr_mod_main,5},          {"dp_gr_mod_main",Pdp_gr_mod_main,5},
   
           /* F4 algorithm */
         {"dp_f4_main",Pdp_f4_main,3},          {"dp_f4_main",Pdp_f4_main,3},
         {"dp_f4_mod_main",Pdp_f4_mod_main,4},          {"dp_f4_mod_main",Pdp_f4_mod_main,4},
         {"dp_gr_flags",Pdp_gr_flags,-1},  
         {"dp_gr_print",Pdp_gr_print,-1},  
         {0,0,0},          {0,0,0},
 };  };
   
 extern int dp_nelim;  struct ftab dp_supp_tab[] = {
 extern int dp_order_pair_length;          /* setting flags */
 extern struct order_pair *dp_order_pair;          {"dp_ord",Pdp_ord,-1},
 extern struct order_spec dp_current_spec;          {"dp_set_kara",Pdp_set_kara,-1},
           {"dp_nelim",Pdp_nelim,-1},
           {"dp_gr_flags",Pdp_gr_flags,-1},
           {"dp_gr_print",Pdp_gr_print,-1},
   
 void Pdp_ord(arg,rp)          /* converters */
           {"dp_ptod",Pdp_ptod,2},
           {"dp_dtop",Pdp_dtop,2},
           {"dp_homo",Pdp_homo,1},
           {"dp_dehomo",Pdp_dehomo,1},
           {"dp_etov",Pdp_etov,1},
           {"dp_vtoe",Pdp_vtoe,1},
           {"dp_dtov",Pdp_dtov,1},
           {"dp_mdtod",Pdp_mdtod,1},
           {"dp_mod",Pdp_mod,3},
           {"dp_rat",Pdp_rat,1},
   
           /* criteria */
           {"dp_cri1",Pdp_cri1,2},
           {"dp_cri2",Pdp_cri2,2},
           {"dp_criB",Pdp_criB,3},
   
           /* simple operation */
           {"dp_subd",Pdp_subd,2},
           {"dp_lcm",Pdp_lcm,2},
           {"dp_hm",Pdp_hm,1},
           {"dp_ht",Pdp_ht,1},
           {"dp_hc",Pdp_hc,1},
           {"dp_rest",Pdp_rest,1},
   
           /* degree and size */
           {"dp_td",Pdp_td,1},
           {"dp_mag",Pdp_mag,1},
           {"dp_sugar",Pdp_sugar,1},
   
           /* misc */
           {"dp_mbase",Pdp_mbase,1},
           {"dp_redble",Pdp_redble,2},
           {"dp_sep",Pdp_sep,2},
           {"dp_idiv",Pdp_idiv,2},
           {"dp_tdiv",Pdp_tdiv,2},
           {"dp_minp",Pdp_minp,2},
   
           {0,0,0}
   };
   
   void Pdp_mdtod(arg,rp)
 NODE arg;  NODE arg;
 Obj *rp;  DP *rp;
 {  {
         struct order_spec spec;          MP m,mr,mr0;
           DP p;
           P t;
   
         if ( !arg )          p = (DP)ARG0(arg);
                 *rp = dp_current_spec.obj;          if ( !p )
         else if ( !create_order_spec((Obj)ARG0(arg),&spec) )                  *rp = 0;
                 error("dp_ord : invalid order specification");  
         else {          else {
                 initd(&spec); *rp = spec.obj;                  for ( mr0 = 0, m = BDY(p); m; m = NEXT(m) ) {
                           mptop(m->c,&t); NEXTMP(mr0,mr); mr->c = t; mr->dl = m->dl;
                   }
                   NEXT(mr) = 0; MKDP(p->nv,mr0,*rp); (*rp)->sugar = p->sugar;
         }          }
 }  }
   
 int create_order_spec(obj,spec)  void Pdp_sep(arg,rp)
 Obj obj;  NODE arg;
 struct order_spec *spec;  VECT *rp;
 {  {
         int i,j,n,s,row,col;          DP p,r;
         struct order_pair *l;          MP m,t;
         NODE node,t,tn;          MP *w0,*w;
         MAT m;          int i,n,d,nv,sugar;
         pointer **b;          VECT v;
         int **w;          pointer *pv;
   
         if ( !obj || NUM(obj) ) {          p = (DP)ARG0(arg); m = BDY(p);
                 spec->id = 0; spec->obj = obj;          d = QTOS((Q)ARG1(arg));
                 spec->ord.simple = QTOS((Q)obj);          for ( t = m, n = 0; t; t = NEXT(t), n++ );
                 return 1;          if ( d > n )
         } else if ( OID(obj) == O_LIST ) {                  d = n;
                 node = BDY((LIST)obj);          MKVECT(v,d); *rp = v;
                 for ( n = 0, t = node; t; t = NEXT(t), n++ );          pv = BDY(v); nv = p->nv; sugar = p->sugar;
                 l = (struct order_pair *)MALLOC_ATOMIC(n*sizeof(struct order_pair));          w0 = (MP *)MALLOC(d*sizeof(MP)); bzero(w0,d*sizeof(MP));
                 for ( i = 0, t = node, s = 0; i < n; t = NEXT(t), i++ ) {          w = (MP *)MALLOC(d*sizeof(MP)); bzero(w,d*sizeof(MP));
                         tn = BDY((LIST)BDY(t)); l[i].order = QTOS((Q)BDY(tn));          for ( t = BDY(p), i = 0; t; t = NEXT(t), i++, i %= d  ) {
                         tn = NEXT(tn); l[i].length = QTOS((Q)BDY(tn));                  NEXTMP(w0[i],w[i]); w[i]->c = t->c; w[i]->dl = t->dl;
                         s += l[i].length;          }
                 }          for ( i = 0; i < d; i++ ) {
                 spec->id = 1; spec->obj = obj;                  NEXT(w[i]) = 0; MKDP(nv,w0[i],r); r->sugar = sugar;
                 spec->ord.block.order_pair = l;                  pv[i] = (pointer)r;
                 spec->ord.block.length = n; spec->nv = s;          }
                 return 1;  
         } else if ( OID(obj) == O_MAT ) {  
                 m = (MAT)obj; row = m->row; col = m->col; b = BDY(m);  
                 w = almat(row,col);  
                 for ( i = 0; i < row; i++ )  
                         for ( j = 0; j < col; j++ )  
                                 w[i][j] = QTOS((Q)b[i][j]);  
                 spec->id = 2; spec->obj = obj;  
                 spec->nv = col; spec->ord.matrix.row = row;  
                 spec->ord.matrix.matrix = w;  
                 return 1;  
         } else  
                 return 0;  
 }  }
   
 void homogenize_order(old,n,new)  void Pdp_idiv(arg,rp)
 struct order_spec *old,*new;  NODE arg;
 int n;  DP *rp;
 {  {
         struct order_pair *l;          dp_idiv((DP)ARG0(arg),(Q)ARG1(arg),rp);
         int length,nv,row,i,j;  }
         int **newm,**oldm;  
   
         switch ( old->id ) {  void Pdp_cont(arg,rp)
                 case 0:  NODE arg;
                         switch ( old->ord.simple ) {  Q *rp;
                                 case 0:  {
                                         new->id = 0; new->ord.simple = 0; break;          dp_cont((DP)ARG0(arg),rp);
                                 case 1:  }
                                         l = (struct order_pair *)  
                                                 MALLOC_ATOMIC(2*sizeof(struct order_pair));  void Pdp_dtov(arg,rp)
                                         l[0].length = n; l[0].order = 1;  NODE arg;
                                         l[1].length = 1; l[1].order = 2;  VECT *rp;
                                         new->id = 1;  {
                                         new->ord.block.order_pair = l;          dp_dtov((DP)ARG0(arg),rp);
                                         new->ord.block.length = 2; new->nv = n+1;  }
                                         break;  
                                 case 2:  void Pdp_mbase(arg,rp)
                                         new->id = 0; new->ord.simple = 1; break;  NODE arg;
                                 case 3: case 4: case 5:  LIST *rp;
                                         new->id = 0; new->ord.simple = old->ord.simple+3;  {
                                         dp_nelim = n-1; break;          NODE mb;
                                 case 6: case 7: case 8: case 9:  
                                         new->id = 0; new->ord.simple = old->ord.simple; break;          asir_assert(ARG0(arg),O_LIST,"dp_mbase");
                                 default:          dp_mbase(BDY((LIST)ARG0(arg)),&mb);
                                         error("homogenize_order : invalid input");          MKLIST(*rp,mb);
                         }  }
                         break;  
                 case 1:  void Pdp_etov(arg,rp)
                         length = old->ord.block.length;  NODE arg;
                         l = (struct order_pair *)  VECT *rp;
                                 MALLOC_ATOMIC((length+1)*sizeof(struct order_pair));  {
                         bcopy((char *)old->ord.block.order_pair,(char *)l,length*sizeof(struct order_pair));          DP dp;
                         l[length].order = 2; l[length].length = 1;          int n,i;
                         new->id = 1; new->nv = n+1;          int *d;
                         new->ord.block.order_pair = l;          VECT v;
                         new->ord.block.length = length+1;          Q t;
                         break;  
                 case 2:          dp = (DP)ARG0(arg);
                         nv = old->nv; row = old->ord.matrix.row;          asir_assert(dp,O_DP,"dp_etov");
                         oldm = old->ord.matrix.matrix; newm = almat(row+1,nv+1);          n = dp->nv; d = BDY(dp)->dl->d;
                         for ( i = 0; i <= nv; i++ )          MKVECT(v,n);
                                 newm[0][i] = 1;          for ( i = 0; i < n; i++ ) {
                         for ( i = 0; i < row; i++ ) {                  STOQ(d[i],t); v->body[i] = (pointer)t;
                                 for ( j = 0; j < nv; j++ )  
                                         newm[i+1][j] = oldm[i][j];  
                                 newm[i+1][j] = 0;  
                         }  
                         new->id = 2; new->nv = nv+1;  
                         new->ord.matrix.row = row+1; new->ord.matrix.matrix = newm;  
                         break;  
                 default:  
                         error("homogenize_order : invalid input");  
         }          }
           *rp = v;
 }  }
   
   void Pdp_vtoe(arg,rp)
   NODE arg;
   DP *rp;
   {
           DP dp;
           DL dl;
           MP m;
           int n,i,td;
           int *d;
           VECT v;
   
           v = (VECT)ARG0(arg);
           asir_assert(v,O_VECT,"dp_vtoe");
           n = v->len;
           NEWDL(dl,n); d = dl->d;
           for ( i = 0, td = 0; i < n; i++ ) {
                   d[i] = QTOS((Q)(v->body[i])); td += d[i];
           }
           dl->td = td;
           NEWMP(m); m->dl = dl; m->c = (P)ONE; NEXT(m) = 0;
           MKDP(n,m,dp); dp->sugar = td;
           *rp = dp;
   }
   
   void Pdp_lnf_mod(arg,rp)
   NODE arg;
   LIST *rp;
   {
           DP r1,r2;
           NODE b,g,n;
           int mod;
   
           asir_assert(ARG0(arg),O_LIST,"dp_lnf_mod");
           asir_assert(ARG1(arg),O_LIST,"dp_lnf_mod");
           asir_assert(ARG2(arg),O_N,"dp_lnf_mod");
           b = BDY((LIST)ARG0(arg)); g = BDY((LIST)ARG1(arg));
           mod = QTOS((Q)ARG2(arg));
           dp_lnf_mod((DP)BDY(b),(DP)BDY(NEXT(b)),g,mod,&r1,&r2);
           NEWNODE(n); BDY(n) = (pointer)r1;
           NEWNODE(NEXT(n)); BDY(NEXT(n)) = (pointer)r2;
           NEXT(NEXT(n)) = 0; MKLIST(*rp,n);
   }
   
   void Pdp_nf_tab_mod(arg,rp)
   NODE arg;
   DP *rp;
   {
           asir_assert(ARG0(arg),O_DP,"dp_nf_tab_mod");
           asir_assert(ARG1(arg),O_VECT,"dp_nf_tab_mod");
           asir_assert(ARG2(arg),O_N,"dp_nf_tab_mod");
           dp_nf_tab_mod((DP)ARG0(arg),(LIST *)BDY((VECT)ARG1(arg)),
                   QTOS((Q)ARG2(arg)),rp);
   }
   
   void Pdp_ord(arg,rp)
   NODE arg;
   Obj *rp;
   {
           struct order_spec spec;
   
           if ( !arg )
                   *rp = dp_current_spec.obj;
           else if ( !create_order_spec((Obj)ARG0(arg),&spec) )
                   error("dp_ord : invalid order specification");
           else {
                   initd(&spec); *rp = spec.obj;
           }
   }
   
 void Pdp_ptod(arg,rp)  void Pdp_ptod(arg,rp)
 NODE arg;  NODE arg;
 DP *rp;  DP *rp;
Line 328  DP *rp;
Line 418  DP *rp;
         dp_prim((DP)ARG0(arg),&t); dp_ptozp(t,rp);          dp_prim((DP)ARG0(arg),&t); dp_ptozp(t,rp);
 }  }
   
 extern int NoGCD;  
   
 void dp_prim(p,rp)  
 DP p,*rp;  
 {  
         P t,g;  
         DP p1;  
         MP m,mr,mr0;  
         int i,n;  
         P *w;  
         Q *c;  
         Q dvr;  
   
         if ( !p )  
                 *rp = 0;  
         else if ( dp_fcoeffs )  
                 *rp = p;  
         else if ( NoGCD )  
                 dp_ptozp(p,rp);  
         else {  
                 dp_ptozp(p,&p1); p = p1;  
                 for ( m = BDY(p), n = 0; m; m = NEXT(m), n++ );  
                 if ( n == 1 ) {  
                         m = BDY(p);  
                         NEWMP(mr); mr->dl = m->dl; mr->c = (P)ONE; NEXT(mr) = 0;  
                         MKDP(p->nv,mr,*rp); (*rp)->sugar = p->sugar;  
                         return;  
                 }  
                 w = (P *)ALLOCA(n*sizeof(P));  
                 c = (Q *)ALLOCA(n*sizeof(Q));  
                 for ( m =BDY(p), i = 0; i < n; m = NEXT(m), i++ )  
                         if ( NUM(m->c) ) {  
                                 c[i] = (Q)m->c; w[i] = (P)ONE;  
                         } else  
                                 ptozp(m->c,1,&c[i],&w[i]);  
                 qltozl(c,n,&dvr); heu_nezgcdnpz(CO,w,n,&t); mulp(CO,t,(P)dvr,&g);  
                 if ( NUM(g) )  
                         *rp = p;  
                 else {  
                         for ( mr0 = 0, m = BDY(p); m; m = NEXT(m) ) {  
                                 NEXTMP(mr0,mr); divsp(CO,m->c,g,&mr->c); mr->dl = m->dl;  
                         }  
                         NEXT(mr) = 0; MKDP(p->nv,mr0,*rp); (*rp)->sugar = p->sugar;  
                 }  
         }  
 }  
   
 void heu_nezgcdnpz(vl,pl,m,pr)  
 VL vl;  
 P *pl,*pr;  
 int m;  
 {  
         int i,r;  
         P gcd,t,s1,s2,u;  
         Q rq;  
   
         while ( 1 ) {  
                 for ( i = 0, s1 = 0; i < m; i++ ) {  
                         r = random(); UTOQ(r,rq);  
                         mulp(vl,pl[i],(P)rq,&t); addp(vl,s1,t,&u); s1 = u;  
                 }  
                 for ( i = 0, s2 = 0; i < m; i++ ) {  
                         r = random(); UTOQ(r,rq);  
                         mulp(vl,pl[i],(P)rq,&t); addp(vl,s2,t,&u); s2 = u;  
                 }  
                 ezgcdp(vl,s1,s2,&gcd);  
                 for ( i = 0; i < m; i++ ) {  
                         if ( !divtpz(vl,pl[i],gcd,&t) )  
                                 break;  
                 }  
                 if ( i == m )  
                         break;  
         }  
         *pr = gcd;  
 }  
   
 void dp_prim_mod(p,mod,rp)  
 int mod;  
 DP p,*rp;  
 {  
         P t,g;  
         MP m,mr,mr0;  
   
         if ( !p )  
                 *rp = 0;  
         else if ( NoGCD )  
                 *rp = p;  
         else {  
                 for ( m = BDY(p), g = m->c, m = NEXT(m); m; m = NEXT(m) ) {  
                         gcdprsmp(CO,mod,g,m->c,&t); g = t;  
                 }  
                 for ( mr0 = 0, m = BDY(p); m; m = NEXT(m) ) {  
                         NEXTMP(mr0,mr); divsmp(CO,mod,m->c,g,&mr->c); mr->dl = m->dl;  
                 }  
                 NEXT(mr) = 0; MKDP(p->nv,mr0,*rp); (*rp)->sugar = p->sugar;  
         }  
 }  
   
 void Pdp_mod(arg,rp)  void Pdp_mod(arg,rp)
 NODE arg;  NODE arg;
 DP *rp;  DP *rp;
Line 450  DP *rp;
Line 442  DP *rp;
         dp_rat((DP)ARG0(arg),rp);          dp_rat((DP)ARG0(arg),rp);
 }  }
   
 void dp_mod(p,mod,subst,rp)  
 DP p;  
 int mod;  
 NODE subst;  
 DP *rp;  
 {  
         MP m,mr,mr0;  
         P t,s,s1;  
         V v;  
         NODE tn;  
   
         if ( !p )  
                 *rp = 0;  
         else {  
                 for ( mr0 = 0, m = BDY(p); m; m = NEXT(m) ) {  
                         for ( tn = subst, s = m->c; tn; tn = NEXT(tn) ) {  
                                 v = VR((P)BDY(tn)); tn = NEXT(tn);  
                                 substp(CO,s,v,(P)BDY(tn),&s1); s = s1;  
                         }  
                         ptomp(mod,s,&t);  
                         if ( t ) {  
                                 NEXTMP(mr0,mr); mr->c = t; mr->dl = m->dl;  
                         }  
                 }  
                 if ( mr0 ) {  
                         NEXT(mr) = 0; MKDP(p->nv,mr0,*rp); (*rp)->sugar = p->sugar;  
                 } else  
                         *rp = 0;  
         }  
 }  
   
 void dp_rat(p,rp)  
 DP p;  
 DP *rp;  
 {  
         MP m,mr,mr0;  
   
         if ( !p )  
                 *rp = 0;  
         else {  
                 for ( mr0 = 0, m = BDY(p); m; m = NEXT(m) ) {  
                         NEXTMP(mr0,mr); mptop(m->c,&mr->c); mr->dl = m->dl;  
                 }  
                 if ( mr0 ) {  
                         NEXT(mr) = 0; MKDP(p->nv,mr0,*rp); (*rp)->sugar = p->sugar;  
                 } else  
                         *rp = 0;  
         }  
 }  
   
 void Pdp_nf(arg,rp)  void Pdp_nf(arg,rp)
 NODE arg;  NODE arg;
 DP *rp;  DP *rp;
Line 548  LIST *rp;
Line 490  LIST *rp;
         NEXT(NEXT(n)) = 0; MKLIST(*rp,n);          NEXT(NEXT(n)) = 0; MKLIST(*rp,n);
 }  }
   
 void dp_nf(b,g,ps,full,rp)  
 NODE b;  
 DP g;  
 DP *ps;  
 int full;  
 DP *rp;  
 {  
         DP u,p,d,s,t,dmy1;  
         P dmy;  
         NODE l;  
         MP m,mr;  
         int i,n;  
         int *wb;  
         int sugar,psugar;  
   
         if ( !g ) {  
                 *rp = 0; return;  
         }  
         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] = QTOS((Q)BDY(l));  
         sugar = g->sugar;  
         for ( d = 0; g; ) {  
                 for ( u = 0, i = 0; i < n; i++ ) {  
                         if ( dp_redble(g,p = ps[wb[i]]) ) {  
                                 dp_red(d,g,p,&t,&u,&dmy,&dmy1);  
                                 psugar = (BDY(g)->dl->td - BDY(p)->dl->td) + p->sugar;  
                                 sugar = MAX(sugar,psugar);  
                                 if ( !u ) {  
                                         if ( d )  
                                                 d->sugar = sugar;  
                                         *rp = d; return;  
                                 }  
                                 d = t;  
                                 break;  
                         }  
                 }  
                 if ( u )  
                         g = u;  
                 else if ( !full ) {  
                         if ( g ) {  
                                 MKDP(g->nv,BDY(g),t); t->sugar = sugar; g = t;  
                         }  
                         *rp = g; return;  
                 } else {  
                         m = BDY(g); NEWMP(mr); mr->dl = m->dl; mr->c = m->c;  
                         NEXT(mr) = 0; MKDP(g->nv,mr,t); t->sugar = mr->dl->td;  
                         addd(CO,d,t,&s); d = s;  
                         dp_rest(g,&t); g = t;  
                 }  
         }  
         if ( d )  
                 d->sugar = sugar;  
         *rp = d;  
 }  
   
 void dp_true_nf(b,g,ps,full,rp,dnp)  
 NODE b;  
 DP g;  
 DP *ps;  
 int full;  
 DP *rp;  
 P *dnp;  
 {  
         DP u,p,d,s,t,dmy;  
         NODE l;  
         MP m,mr;  
         int i,n;  
         int *wb;  
         int sugar,psugar;  
         P dn,tdn,tdn1;  
   
         dn = (P)ONE;  
         if ( !g ) {  
                 *rp = 0; *dnp = dn; return;  
         }  
         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] = QTOS((Q)BDY(l));  
         sugar = g->sugar;  
         for ( d = 0; g; ) {  
                 for ( u = 0, i = 0; i < n; i++ ) {  
                         if ( dp_redble(g,p = ps[wb[i]]) ) {  
                                 dp_red(d,g,p,&t,&u,&tdn,&dmy);  
                                 psugar = (BDY(g)->dl->td - BDY(p)->dl->td) + p->sugar;  
                                 sugar = MAX(sugar,psugar);  
                                 if ( !u ) {  
                                         if ( d )  
                                                 d->sugar = sugar;  
                                         *rp = d; *dnp = dn; return;  
                                 } else {  
                                         d = t;  
                                         mulp(CO,dn,tdn,&tdn1); dn = tdn1;  
                                 }  
                                 break;  
                         }  
                 }  
                 if ( u )  
                         g = u;  
                 else if ( !full ) {  
                         if ( g ) {  
                                 MKDP(g->nv,BDY(g),t); t->sugar = sugar; g = t;  
                         }  
                         *rp = g; *dnp = dn; return;  
                 } else {  
                         m = BDY(g); NEWMP(mr); mr->dl = m->dl; mr->c = m->c;  
                         NEXT(mr) = 0; MKDP(g->nv,mr,t); t->sugar = mr->dl->td;  
                         addd(CO,d,t,&s); d = s;  
                         dp_rest(g,&t); g = t;  
                 }  
         }  
         if ( d )  
                 d->sugar = sugar;  
         *rp = d; *dnp = dn;  
 }  
   
 #define HMAG(p) (p_mag(BDY(p)->c))  
   
 void Pdp_nf_ptozp(arg,rp)  void Pdp_nf_ptozp(arg,rp)
 NODE arg;  NODE arg;
 DP *rp;  DP *rp;
Line 691  DP *rp;
Line 513  DP *rp;
         dp_nf_ptozp(b,g,ps,full,multiple,rp);          dp_nf_ptozp(b,g,ps,full,multiple,rp);
 }  }
   
 void dp_nf_ptozp(b,g,ps,full,multiple,rp)  
 NODE b;  
 DP g;  
 DP *ps;  
 int full,multiple;  
 DP *rp;  
 {  
         DP u,p,d,s,t,dmy1;  
         P dmy;  
         NODE l;  
         MP m,mr;  
         int i,n;  
         int *wb;  
         int hmag;  
         int sugar,psugar;  
   
         if ( !g ) {  
                 *rp = 0; return;  
         }  
         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] = QTOS((Q)BDY(l));  
         hmag = multiple*HMAG(g);  
         sugar = g->sugar;  
         for ( d = 0; g; ) {  
                 for ( u = 0, i = 0; i < n; i++ ) {  
                         if ( dp_redble(g,p = ps[wb[i]]) ) {  
                                 dp_red(d,g,p,&t,&u,&dmy,&dmy1);  
                                 psugar = (BDY(g)->dl->td - BDY(p)->dl->td) + p->sugar;  
                                 sugar = MAX(sugar,psugar);  
                                 if ( !u ) {  
                                         if ( d )  
                                                 d->sugar = sugar;  
                                         *rp = d; return;  
                                 }  
                                 d = t;  
                                 break;  
                         }  
                 }  
                 if ( u ) {  
                         g = u;  
                         if ( d ) {  
                                 if ( HMAG(d) > hmag ) {  
                                         dp_ptozp2(d,g,&t,&u); d = t; g = u;  
                                         hmag = multiple*HMAG(d);  
                                 }  
                         } else {  
                                 if ( HMAG(g) > hmag ) {  
                                         dp_ptozp(g,&t); g = t;  
                                         hmag = multiple*HMAG(g);  
                                 }  
                         }  
                 }  
                 else if ( !full ) {  
                         if ( g ) {  
                                 MKDP(g->nv,BDY(g),t); t->sugar = sugar; g = t;  
                         }  
                         *rp = g; return;  
                 } else {  
                         m = BDY(g); NEWMP(mr); mr->dl = m->dl; mr->c = m->c;  
                         NEXT(mr) = 0; MKDP(g->nv,mr,t); t->sugar = mr->dl->td;  
                         addd(CO,d,t,&s); d = s;  
                         dp_rest(g,&t); g = t;  
   
                 }  
         }  
         if ( d )  
                 d->sugar = sugar;  
         *rp = d;  
 }  
   
 void Pdp_nf_demand(arg,rp)  void Pdp_nf_demand(arg,rp)
 NODE arg;  NODE arg;
 DP *rp;  DP *rp;
Line 886  LIST *rp;
Line 636  LIST *rp;
         NEXT(NEXT(n)) = 0; MKLIST(*rp,n);          NEXT(NEXT(n)) = 0; MKLIST(*rp,n);
 }  }
   
 void dp_nf_mod_qindex(b,g,ps,mod,full,rp)  
 NODE b;  
 DP g;  
 DP *ps;  
 int mod,full;  
 DP *rp;  
 {  
         DP u,p,d,s,t;  
         P dmy;  
         NODE l;  
         MP m,mr;  
         int sugar,psugar;  
   
         if ( !g ) {  
                 *rp = 0; return;  
         }  
         sugar = g->sugar;  
         for ( d = 0; g; ) {  
                 for ( u = 0, l = b; l; l = NEXT(l) ) {  
                         if ( dp_redble(g,p = ps[QTOS((Q)BDY(l))]) ) {  
                                 dp_red_mod(d,g,p,mod,&t,&u,&dmy);  
                                 psugar = (BDY(g)->dl->td - BDY(p)->dl->td) + p->sugar;  
                                 sugar = MAX(sugar,psugar);  
                                 if ( !u ) {  
                                         if ( d )  
                                                 d->sugar = sugar;  
                                         *rp = d; return;  
                                 }  
                                 d = t;  
                                 break;  
                         }  
                 }  
                 if ( u )  
                         g = u;  
                 else if ( !full ) {  
                         if ( g ) {  
                                 MKDP(g->nv,BDY(g),t); t->sugar = sugar; g = t;  
                         }  
                         *rp = g; return;  
                 } else {  
                         m = BDY(g); NEWMP(mr); mr->dl = m->dl; mr->c = m->c;  
                         NEXT(mr) = 0; MKDP(g->nv,mr,t); t->sugar = mr->dl->td;  
                         addmd(CO,mod,d,t,&s); d = s;  
                         dp_rest(g,&t); g = t;  
                 }  
         }  
         if ( d )  
                 d->sugar = sugar;  
         *rp = d;  
 }  
   
 void dp_nf_mod(b,g,ps,mod,full,rp)  
 NODE b;  
 DP g;  
 DP *ps;  
 int mod,full;  
 DP *rp;  
 {  
         DP u,p,d,s,t;  
         P dmy;  
         NODE l;  
         MP m,mr;  
         int sugar,psugar;  
   
         if ( !g ) {  
                 *rp = 0; return;  
         }  
         sugar = g->sugar;  
         for ( d = 0; g; ) {  
                 for ( u = 0, l = b; l; l = NEXT(l) ) {  
                         if ( dp_redble(g,p = ps[(int)BDY(l)]) ) {  
                                 dp_red_mod(d,g,p,mod,&t,&u,&dmy);  
                                 psugar = (BDY(g)->dl->td - BDY(p)->dl->td) + p->sugar;  
                                 sugar = MAX(sugar,psugar);  
                                 if ( !u ) {  
                                         if ( d )  
                                                 d->sugar = sugar;  
                                         *rp = d; return;  
                                 }  
                                 d = t;  
                                 break;  
                         }  
                 }  
                 if ( u )  
                         g = u;  
                 else if ( !full ) {  
                         if ( g ) {  
                                 MKDP(g->nv,BDY(g),t); t->sugar = sugar; g = t;  
                         }  
                         *rp = g; return;  
                 } else {  
                         m = BDY(g); NEWMP(mr); mr->dl = m->dl; mr->c = m->c;  
                         NEXT(mr) = 0; MKDP(g->nv,mr,t); t->sugar = mr->dl->td;  
                         addmd(CO,mod,d,t,&s); d = s;  
                         dp_rest(g,&t); g = t;  
                 }  
         }  
         if ( d )  
                 d->sugar = sugar;  
         *rp = d;  
 }  
   
 void dp_true_nf_mod(b,g,ps,mod,full,rp,dnp)  
 NODE b;  
 DP g;  
 DP *ps;  
 int mod,full;  
 DP *rp;  
 P *dnp;  
 {  
         DP u,p,d,s,t;  
         NODE l;  
         MP m,mr;  
         int i,n;  
         int *wb;  
         int sugar,psugar;  
         P dn,tdn,tdn1;  
   
         dn = (P)ONEM;  
         if ( !g ) {  
                 *rp = 0; *dnp = dn; return;  
         }  
         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] = QTOS((Q)BDY(l));  
         sugar = g->sugar;  
         for ( d = 0; g; ) {  
                 for ( u = 0, i = 0; i < n; i++ ) {  
                         if ( dp_redble(g,p = ps[wb[i]]) ) {  
                                 dp_red_mod(d,g,p,mod,&t,&u,&tdn);  
                                 psugar = (BDY(g)->dl->td - BDY(p)->dl->td) + p->sugar;  
                                 sugar = MAX(sugar,psugar);  
                                 if ( !u ) {  
                                         if ( d )  
                                                 d->sugar = sugar;  
                                         *rp = d; *dnp = dn; return;  
                                 } else {  
                                         d = t;  
                                         mulmp(CO,mod,dn,tdn,&tdn1); dn = tdn1;  
                                 }  
                                 break;  
                         }  
                 }  
                 if ( u )  
                         g = u;  
                 else if ( !full ) {  
                         if ( g ) {  
                                 MKDP(g->nv,BDY(g),t); t->sugar = sugar; g = t;  
                         }  
                         *rp = g; *dnp = dn; return;  
                 } else {  
                         m = BDY(g); NEWMP(mr); mr->dl = m->dl; mr->c = m->c;  
                         NEXT(mr) = 0; MKDP(g->nv,mr,t); t->sugar = mr->dl->td;  
                         addmd(CO,mod,d,t,&s); d = s;  
                         dp_rest(g,&t); g = t;  
                 }  
         }  
         if ( d )  
                 d->sugar = sugar;  
         *rp = d; *dnp = dn;  
 }  
   
 void Pdp_tdiv(arg,rp)  void Pdp_tdiv(arg,rp)
 NODE arg;  NODE arg;
 DP *rp;  DP *rp;
Line 1106  DP *rp;
Line 693  DP *rp;
         }          }
 }  }
   
 void qltozl(w,n,dvr)  
 Q *w,*dvr;  
 int n;  
 {  
         N nm,dn;  
         N g,l1,l2,l3;  
         Q c,d;  
         int i;  
         struct oVECT v;  
   
         for ( i = 0; i < n; i++ )  
                 if ( w[i] && !INT(w[i]) )  
                         break;  
         if ( i == n ) {  
                 v.id = O_VECT; v.len = n; v.body = (pointer *)w;  
                 igcdv(&v,dvr); return;  
         }  
         c = w[0]; nm = NM(c); dn = INT(c) ? ONEN : DN(c);  
         for ( i = 1; i < n; i++ ) {  
                 c = w[i]; l1 = INT(c) ? ONEN : DN(c);  
                 gcdn(nm,NM(c),&g); nm = g;  
                 gcdn(dn,l1,&l2); muln(dn,l1,&l3); divsn(l3,l2,&dn);  
         }  
         if ( UNIN(dn) )  
                 NTOQ(nm,1,d);  
         else  
                 NDTOQ(nm,dn,1,d);  
         *dvr = d;  
 }  
   
 int comp_nm(a,b)  
 Q *a,*b;  
 {  
         return cmpn((*a)?NM(*a):0,(*b)?NM(*b):0);  
 }  
   
 void sortbynm(w,n)  
 Q *w;  
 int n;  
 {  
         qsort(w,n,sizeof(Q),(int (*)(const void *,const void *))comp_nm);  
 }  
   
 void Pdp_redble(arg,rp)  void Pdp_redble(arg,rp)
 NODE arg;  NODE arg;
 Q *rp;  Q *rp;
Line 1179  LIST *rp;
Line 723  LIST *rp;
         NEWNODE(NEXT(n)); BDY(NEXT(n)) = (pointer)r;          NEWNODE(NEXT(n)); BDY(NEXT(n)) = (pointer)r;
         NEXT(NEXT(n)) = 0; MKLIST(*rp,n);          NEXT(NEXT(n)) = 0; MKLIST(*rp,n);
 }  }
   
 int dp_redble(p1,p2)  
 DP p1,p2;  
 {  
         int i,n;  
         DL d1,d2;  
   
         d1 = BDY(p1)->dl; d2 = BDY(p2)->dl;  
         if ( d1->td < d2->td )  
                 return 0;  
         else {  
                 for ( i = 0, n = p1->nv; i < n; i++ )  
                         if ( d1->d[i] < d2->d[i] )  
                                 return 0;  
                 return 1;  
         }  
 }  
   
 void dp_red_mod(p0,p1,p2,mod,head,rest,dnp)  
 DP p0,p1,p2;  
 int mod;  
 DP *head,*rest;  
 P *dnp;  
 {  
         int i,n;  
         DL d1,d2,d;  
         MP m;  
         DP t,s,r,h;  
         P c1,c2,g,u;  
   
         n = p1->nv; d1 = BDY(p1)->dl; d2 = BDY(p2)->dl;  
         NEWDL(d,n); d->td = d1->td - d2->td;  
         for ( i = 0; i < n; i++ )  
                 d->d[i] = d1->d[i]-d2->d[i];  
         c1 = (P)BDY(p1)->c; c2 = (P)BDY(p2)->c;  
         gcdprsmp(CO,mod,c1,c2,&g);  
         divsmp(CO,mod,c1,g,&u); c1 = u; divsmp(CO,mod,c2,g,&u); c2 = u;  
         if ( NUM(c2) ) {  
                 divsmp(CO,mod,c1,c2,&u); c1 = u; c2 = (P)ONEM;  
         }  
         NEWMP(m); m->dl = d; chsgnmp(mod,(P)c1,&m->c); NEXT(m) = 0;  
         MKDP(n,m,s); s->sugar = d->td; mulmd(CO,mod,p2,s,&t);  
         if ( NUM(c2) ) {  
                 addmd(CO,mod,p1,t,&r); h = p0;  
         } else {  
                 mulmdc(CO,mod,p1,c2,&s); addmd(CO,mod,s,t,&r); mulmdc(CO,mod,p0,c2,&h);  
         }  
         *head = h; *rest = r; *dnp = c2;  
 }  
   
 void Pdp_subd(arg,rp)  void Pdp_subd(arg,rp)
 NODE arg;  NODE arg;
 DP *rp;  DP *rp;
Line 1241  DP *rp;
Line 735  DP *rp;
         dp_subd(p1,p2,rp);          dp_subd(p1,p2,rp);
 }  }
   
 void dp_subd(p1,p2,rp)  
 DP p1,p2;  
 DP *rp;  
 {  
         int i,n;  
         DL d1,d2,d;  
         MP m;  
         DP s;  
   
         n = p1->nv; d1 = BDY(p1)->dl; d2 = BDY(p2)->dl;  
         NEWDL(d,n); d->td = d1->td - d2->td;  
         for ( i = 0; i < n; i++ )  
                 d->d[i] = d1->d[i]-d2->d[i];  
         NEWMP(m); m->dl = d; m->c = (P)ONE; NEXT(m) = 0;  
         MKDP(n,m,s); s->sugar = d->td;  
         *rp = s;  
 }  
   
 void dltod(d,n,rp)  
 DL d;  
 int n;  
 DP *rp;  
 {  
         MP m;  
         DP s;  
   
         NEWMP(m); m->dl = d; m->c = (P)ONE; NEXT(m) = 0;  
         MKDP(n,m,s); s->sugar = d->td;  
         *rp = s;  
 }  
   
 void Pdp_red(arg,rp)  void Pdp_red(arg,rp)
 NODE arg;  NODE arg;
 LIST *rp;  LIST *rp;
Line 1289  LIST *rp;
Line 752  LIST *rp;
         NEXT(NEXT(n)) = 0; MKLIST(*rp,n);          NEXT(NEXT(n)) = 0; MKLIST(*rp,n);
 }  }
   
 void dp_red(p0,p1,p2,head,rest,dnp,multp)  
 DP p0,p1,p2;  
 DP *head,*rest;  
 P *dnp;  
 DP *multp;  
 {  
         int i,n;  
         DL d1,d2,d;  
         MP m;  
         DP t,s,r,h;  
         Q c,c1,c2;  
         N gn,tn;  
         P g,a;  
   
         n = p1->nv; d1 = BDY(p1)->dl; d2 = BDY(p2)->dl;  
         NEWDL(d,n); d->td = d1->td - d2->td;  
         for ( i = 0; i < n; i++ )  
                 d->d[i] = d1->d[i]-d2->d[i];  
         c1 = (Q)BDY(p1)->c; c2 = (Q)BDY(p2)->c;  
         if ( dp_fcoeffs ) {  
                 /* do nothing */  
         } else if ( INT(c1) && INT(c2) ) {  
                 gcdn(NM(c1),NM(c2),&gn);  
                 if ( !UNIN(gn) ) {  
                         divsn(NM(c1),gn,&tn); NTOQ(tn,SGN(c1),c); c1 = c;  
                         divsn(NM(c2),gn,&tn); NTOQ(tn,SGN(c2),c); c2 = c;  
                 }  
         } else {  
                 ezgcdpz(CO,(P)c1,(P)c2,&g);  
                 divsp(CO,(P)c1,g,&a); c1 = (Q)a; divsp(CO,(P)c2,g,&a); c2 = (Q)a;  
         }  
         NEWMP(m); m->dl = d; chsgnp((P)c1,&m->c); NEXT(m) = 0; MKDP(n,m,s); s->sugar = d->td;  
         *multp = s;  
         muld(CO,s,p2,&t); muldc(CO,p1,(P)c2,&s); addd(CO,s,t,&r);  
         muldc(CO,p0,(P)c2,&h);  
         *head = h; *rest = r; *dnp = (P)c2;  
 }  
   
 void Pdp_sp(arg,rp)  void Pdp_sp(arg,rp)
 NODE arg;  NODE arg;
 DP *rp;  DP *rp;
Line 1338  DP *rp;
Line 763  DP *rp;
         dp_sp(p1,p2,rp);          dp_sp(p1,p2,rp);
 }  }
   
 extern int GenTrace;  
 extern NODE TraceList;  
   
 void dp_sp(p1,p2,rp)  
 DP p1,p2;  
 DP *rp;  
 {  
         int i,n,td;  
         int *w;  
         DL d1,d2,d;  
         MP m;  
         DP t,s1,s2,u;  
         Q c,c1,c2;  
         N gn,tn;  
   
         n = p1->nv; d1 = BDY(p1)->dl; d2 = BDY(p2)->dl;  
         w = (int *)ALLOCA(n*sizeof(int));  
         for ( i = 0, td = 0; i < n; i++ ) {  
                 w[i] = MAX(d1->d[i],d2->d[i]); td += w[i];  
         }  
   
         NEWDL(d,n); d->td = td - d1->td;  
         for ( i = 0; i < n; i++ )  
                 d->d[i] = w[i] - d1->d[i];  
         c1 = (Q)BDY(p1)->c; c2 = (Q)BDY(p2)->c;  
         if ( INT(c1) && INT(c2) ) {  
                 gcdn(NM(c1),NM(c2),&gn);  
                 if ( !UNIN(gn) ) {  
                         divsn(NM(c1),gn,&tn); NTOQ(tn,SGN(c1),c); c1 = c;  
                         divsn(NM(c2),gn,&tn); NTOQ(tn,SGN(c2),c); c2 = c;  
                 }  
         }  
   
         NEWMP(m); m->dl = d; m->c = (P)c2; NEXT(m) = 0;  
         MKDP(n,m,s1); s1->sugar = d->td; muld(CO,s1,p1,&t);  
   
         NEWDL(d,n); d->td = td - d2->td;  
         for ( i = 0; i < n; i++ )  
                 d->d[i] = w[i] - d2->d[i];  
         NEWMP(m); m->dl = d; m->c = (P)c1; NEXT(m) = 0;  
         MKDP(n,m,s2); s2->sugar = d->td; muld(CO,s2,p2,&u);  
   
         subd(CO,t,u,rp);  
         if ( GenTrace ) {  
                 LIST hist;  
                 NODE node;  
   
                 node = mknode(4,ONE,0,s1,ONE);  
                 MKLIST(hist,node);  
                 MKNODE(TraceList,hist,0);  
   
                 node = mknode(4,ONE,0,0,ONE);  
                 chsgnd(s2,(DP *)&ARG2(node));  
                 MKLIST(hist,node);  
                 MKNODE(node,hist,TraceList); TraceList = node;  
         }  
 }  
   
 void Pdp_sp_mod(arg,rp)  void Pdp_sp_mod(arg,rp)
 NODE arg;  NODE arg;
 DP *rp;  DP *rp;
Line 1410  DP *rp;
Line 777  DP *rp;
         dp_sp_mod(p1,p2,mod,rp);          dp_sp_mod(p1,p2,mod,rp);
 }  }
   
 void dp_sp_mod(p1,p2,mod,rp)  
 DP p1,p2;  
 int mod;  
 DP *rp;  
 {  
         int i,n,td;  
         int *w;  
         DL d1,d2,d;  
         MP m;  
         DP t,s,u;  
   
         n = p1->nv; d1 = BDY(p1)->dl; d2 = BDY(p2)->dl;  
         w = (int *)ALLOCA(n*sizeof(int));  
         for ( i = 0, td = 0; i < n; i++ ) {  
                 w[i] = MAX(d1->d[i],d2->d[i]); td += w[i];  
         }  
         NEWDL(d,n); d->td = td - d1->td;  
         for ( i = 0; i < n; i++ )  
                 d->d[i] = w[i] - d1->d[i];  
         NEWMP(m); m->dl = d; m->c = (P)BDY(p2)->c; NEXT(m) = 0;  
         MKDP(n,m,s); s->sugar = d->td; mulmd(CO,mod,p1,s,&t);  
         NEWDL(d,n); d->td = td - d2->td;  
         for ( i = 0; i < n; i++ )  
                 d->d[i] = w[i] - d2->d[i];  
         NEWMP(m); m->dl = d; m->c = (P)BDY(p1)->c; NEXT(m) = 0;  
         MKDP(n,m,s); s->sugar = d->td; mulmd(CO,mod,p2,s,&u);  
         submd(CO,mod,t,u,rp);  
 }  
   
 void Pdp_lcm(arg,rp)  void Pdp_lcm(arg,rp)
 NODE arg;  NODE arg;
 DP *rp;  DP *rp;
Line 1470  DP *rp;
Line 808  DP *rp;
         dp_hm(p,rp);          dp_hm(p,rp);
 }  }
   
 void dp_hm(p,rp)  
 DP p;  
 DP *rp;  
 {  
         MP m,mr;  
   
         if ( !p )  
                 *rp = 0;  
         else {  
                 m = BDY(p);  
                 NEWMP(mr); mr->dl = m->dl; mr->c = m->c; NEXT(mr) = 0;  
                 MKDP(p->nv,mr,*rp); (*rp)->sugar = mr->dl->td;  /* XXX */  
         }  
 }  
   
 void Pdp_ht(arg,rp)  void Pdp_ht(arg,rp)
 NODE arg;  NODE arg;
 DP *rp;  DP *rp;
Line 1524  DP *rp;
Line 847  DP *rp;
                 dp_rest((DP)ARG0(arg),rp);                  dp_rest((DP)ARG0(arg),rp);
 }  }
   
 void dp_rest(p,rp)  
 DP p,*rp;  
 {  
         MP m;  
   
         m = BDY(p);  
         if ( !NEXT(m) )  
                 *rp = 0;  
         else {  
                 MKDP(p->nv,NEXT(m),*rp);  
                 if ( *rp )  
                         (*rp)->sugar = p->sugar;  
         }  
 }  
   
 void Pdp_td(arg,rp)  void Pdp_td(arg,rp)
 NODE arg;  NODE arg;
 Q *rp;  Q *rp;
Line 1684  LIST *rp;
Line 992  LIST *rp;
         }          }
 }  }
   
 DL lcm_of_DL(nv,dl1,dl2,dl)  
 int nv;  
 DL dl1,dl2;  
 register DL dl;  
 {  
         register int n, *d1, *d2, *d, td;  
   
         if ( !dl ) NEWDL(dl,nv);  
         d = dl->d,  d1 = dl1->d,  d2 = dl2->d;  
         for ( td = 0, n = nv; --n >= 0; d1++, d2++, d++ )  
                 td += (*d = *d1 > *d2 ? *d1 : *d2 );  
         dl->td = td;  
         return dl;  
 }  
   
 int dl_equal(nv,dl1,dl2)  
 int nv;  
 DL dl1, dl2;  
 {  
     register int *d1, *d2, n;  
   
     if ( dl1->td != dl2->td ) return 0;  
     for ( d1 = dl1->d, d2 = dl2->d, n = nv; --n >= 0; d1++, d2++ )  
         if ( *d1 != *d2 ) return 0;  
     return 1;  
 }  
   
 void Pdp_nelim(arg,rp)  void Pdp_nelim(arg,rp)
 NODE arg;  NODE arg;
 Q *rp;  Q *rp;
Line 1762  DP *rp;
Line 1043  DP *rp;
         dp_homo((DP)ARG0(arg),rp);          dp_homo((DP)ARG0(arg),rp);
 }  }
   
 void dp_homo(p,rp)  void Pdp_dehomo(arg,rp)
 DP p;  NODE arg;
 DP *rp;  DP *rp;
 {  {
         MP m,mr,mr0;          asir_assert(ARG0(arg),O_DP,"dp_dehomo");
         int i,n,nv,td;          dp_dehomo((DP)ARG0(arg),rp);
         DL dl,dlh;  }
   
         if ( !p )  void Pdp_gr_flags(arg,rp)
                 *rp = 0;  NODE arg;
         else {  LIST *rp;
                 n = p->nv; nv = n + 1;  {
                 m = BDY(p); td = sugard(m);          Obj name,value;
                 for ( mr0 = 0; m; m = NEXT(m) ) {          NODE n;
                         NEXTMP(mr0,mr); mr->c = m->c;  
                         dl = m->dl;          if ( arg ) {
                         mr->dl = dlh = (DL)MALLOC_ATOMIC((nv+1)*sizeof(int));                  asir_assert(ARG0(arg),O_LIST,"dp_gr_flags");
                         dlh->td = td;                  n = BDY((LIST)ARG0(arg));
                         for ( i = 0; i < n; i++ )                  while ( n ) {
                                 dlh->d[i] = dl->d[i];                          name = (Obj)BDY(n); n = NEXT(n);
                         dlh->d[n] = td - dl->td;                          if ( !n )
                                   break;
                           else {
                                   value = (Obj)BDY(n); n = NEXT(n);
                           }
                           dp_set_flag(name,value);
                 }                  }
                 NEXT(mr) = 0; MKDP(nv,mr0,*rp); (*rp)->sugar = p->sugar;  
         }          }
           dp_make_flaglist(rp);
 }  }
   
 void Pdp_dehomo(arg,rp)  extern int DP_Print;
   
   void Pdp_gr_print(arg,rp)
 NODE arg;  NODE arg;
 DP *rp;  Q *rp;
 {  {
         asir_assert(ARG0(arg),O_DP,"dp_dehomo");          Q q;
         dp_dehomo((DP)ARG0(arg),rp);  
           if ( arg ) {
                   asir_assert(ARG0(arg),O_N,"dp_gr_print");
                   q = (Q)ARG0(arg); DP_Print = QTOS(q);
           } else
                   STOQ(DP_Print,q);
           *rp = q;
 }  }
   
 void dp_dehomo(p,rp)  void Pdp_gr_main(arg,rp)
 DP p;  NODE arg;
 DP *rp;  LIST *rp;
 {  {
         MP m,mr,mr0;          LIST f,v;
         int i,n,nv;          Num homo;
         DL dl,dlh;          Q m;
           int modular;
           struct order_spec ord;
   
         if ( !p )          asir_assert(ARG0(arg),O_LIST,"dp_gr_main");
                 *rp = 0;          asir_assert(ARG1(arg),O_LIST,"dp_gr_main");
         else {          asir_assert(ARG2(arg),O_N,"dp_gr_main");
                 n = p->nv; nv = n - 1;          asir_assert(ARG3(arg),O_N,"dp_gr_main");
                 m = BDY(p);          f = (LIST)ARG0(arg); v = (LIST)ARG1(arg);
                 for ( mr0 = 0; m; m = NEXT(m) ) {          homo = (Num)ARG2(arg);
                         NEXTMP(mr0,mr); mr->c = m->c;          m = (Q)ARG3(arg);
                         dlh = m->dl;          if ( !m )
                         mr->dl = dl = (DL)MALLOC_ATOMIC((nv+1)*sizeof(int));                  modular = 0;
                         dl->td = dlh->td - dlh->d[nv];          else if ( PL(NM(m))>1 || (PL(NM(m)) == 1 && BD(NM(m))[0] >= 0x80000000) )
                         for ( i = 0; i < nv; i++ )                  error("dp_gr_main : too large modulus");
                                 dl->d[i] = dlh->d[i];          else
                 }                  modular = QTOS(m);
                 NEXT(mr) = 0; MKDP(nv,mr0,*rp); (*rp)->sugar = p->sugar;          create_order_spec(ARG4(arg),&ord);
         }          dp_gr_main(f,v,homo,modular,&ord,rp);
 }  }
   
 int dp_nt(p)  void Pdp_f4_main(arg,rp)
 DP p;  NODE arg;
   LIST *rp;
 {  {
         int i;          LIST f,v;
         MP m;          struct order_spec ord;
   
         if ( !p )          asir_assert(ARG0(arg),O_LIST,"dp_f4_main");
                 return 0;          asir_assert(ARG1(arg),O_LIST,"dp_f4_main");
         else {          f = (LIST)ARG0(arg); v = (LIST)ARG1(arg);
                 for ( i = 0, m = BDY(p); m; m = NEXT(m), i++ );          create_order_spec(ARG2(arg),&ord);
                 return i;          dp_f4_main(f,v,&ord,rp);
         }  
 }  }
   
   void Pdp_f4_mod_main(arg,rp)
   NODE arg;
   LIST *rp;
   {
           LIST f,v;
           int m;
           struct order_spec ord;
   
           asir_assert(ARG0(arg),O_LIST,"dp_f4_main");
           asir_assert(ARG1(arg),O_LIST,"dp_f4_main");
           asir_assert(ARG2(arg),O_N,"dp_f4_main");
           f = (LIST)ARG0(arg); v = (LIST)ARG1(arg); m = QTOS((Q)ARG2(arg));
           create_order_spec(ARG3(arg),&ord);
           dp_f4_mod_main(f,v,m,&ord,rp);
   }
   
   void Pdp_gr_mod_main(arg,rp)
   NODE arg;
   LIST *rp;
   {
           LIST f,v;
           Num homo;
           int m;
           struct order_spec ord;
   
           asir_assert(ARG0(arg),O_LIST,"dp_gr_mod_main");
           asir_assert(ARG1(arg),O_LIST,"dp_gr_mod_main");
           asir_assert(ARG2(arg),O_N,"dp_gr_mod_main");
           asir_assert(ARG3(arg),O_N,"dp_gr_mod_main");
           f = (LIST)ARG0(arg); v = (LIST)ARG1(arg);
           homo = (Num)ARG2(arg); m = QTOS((Q)ARG3(arg));
           create_order_spec(ARG4(arg),&ord);
           dp_gr_mod_main(f,v,homo,m,&ord,rp);
   }
   
Legend:
Removed from v.1.7  
changed lines
  Added in v.1.8
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>