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

Diff for /OpenXM_contrib2/asir2018/engine/dist.c between version 1.8 and 1.20

version 1.8, 2019/09/13 02:04:42 version 1.20, 2020/02/03 05:51:52
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/engine/dist.c,v 1.7 2019/09/06 00:11:59 noro Exp $   * $OpenXM: OpenXM_contrib2/asir2018/engine/dist.c,v 1.19 2019/12/27 08:13:59 noro Exp $
 */  */
 #include "ca.h"  #include "ca.h"
   
Line 333  void nodetod(NODE node,DP *dp)
Line 333  void nodetod(NODE node,DP *dp)
 void nodetodpm(NODE node,Obj pos,DPM *dp)  void nodetodpm(NODE node,Obj pos,DPM *dp)
 {  {
   NODE t;    NODE t;
   int len,i,td;    int len,i,td,p;
   Q e;    Q e;
   DL d;    DL d;
   DMM m;    DMM m;
Line 352  void nodetodpm(NODE node,Obj pos,DPM *dp)
Line 352  void nodetodpm(NODE node,Obj pos,DPM *dp)
     }      }
   }    }
   d->td = td;    d->td = td;
   NEWDMM(m); m->dl = d; m->pos = ZTOS((Q)pos); C(m) = (Obj)ONE; NEXT(m) = 0;    p = ZTOS((Q)pos);
     if ( dp_current_spec->module_top_weight ) {
       if ( p > dp_current_spec->module_rank )
         error("nodetodpm : inconsistent order spec");
       d->td += dp_current_spec->module_top_weight[p-1];
     }
     NEWDMM(m); m->dl = d; m->pos = p; C(m) = (Obj)ONE; NEXT(m) = 0;
   MKDPM(len,m,u); u->sugar = td; *dp = u;    MKDPM(len,m,u); u->sugar = td; *dp = u;
 }  }
   
Line 360  void dtodpm(DP d,int pos,DPM *dp)
Line 366  void dtodpm(DP d,int pos,DPM *dp)
 {  {
   DMM mr0,mr;    DMM mr0,mr;
   MP m;    MP m;
     int shift;
   
   if ( !d ) *dp = 0;    if ( !d ) *dp = 0;
   else {    else {
       shift = 0;
       if ( dp_current_spec->module_top_weight ) {
         if ( pos > dp_current_spec->module_rank )
           error("nodetodpm : inconsistent order spec");
         shift = dp_current_spec->module_top_weight[pos-1];
       }
     for ( m = BDY(d), mr0 = 0; m; m = NEXT(m) ) {      for ( m = BDY(d), mr0 = 0; m; m = NEXT(m) ) {
       NEXTDMM(mr0,mr);        NEXTDMM(mr0,mr);
       mr->dl = m->dl;        mr->dl = m->dl;
         mr->dl->td += shift;
       mr->pos = pos;        mr->pos = pos;
       C(mr) = C(m);        C(mr) = C(m);
     }      }
Line 2635  NBP harmonic_mul_nbm(NBM a,NBM b)
Line 2649  NBP harmonic_mul_nbm(NBM a,NBM b)
 /* DPM functions */  /* DPM functions */
   
 DMMstack dmm_stack;  DMMstack dmm_stack;
 extern LIST schreyer_obj;  int dpm_base_ordtype;;
   
 void push_schreyer_order(LIST data)  DMMstack push_schreyer_order(LIST data,DMMstack stack)
 {  {
   DMMstack t;    DMMstack t;
   int len,i;    DP dp;
     MP mp;
     DMM m0,m1;
     DPM dpm0,dpm1;
     int len,i,nv;
   NODE in,t1;    NODE in,t1;
     LIST l;
   
   /* data = [DPM,...,DPM] */    /* data = [DPM,...,DPM] */
     if ( !dmm_stack && ( !dp_current_spec || dp_current_spec->id < 256 ) )
         error("push_schreyer_order : base module order is not set");
   in = BDY(data);    in = BDY(data);
   len = length(in);    len = length(in);
   NEWDMMstack(t);    NEWDMMstack(t);
   t->rank = len;    t->rank = len;
   t->in = (DMM *)MALLOC((len+1)*sizeof(DMM));    t->in = (DMM *)MALLOC((len+1)*sizeof(DMM));
   t->ordtype = 0;    t->sum = (DMM *)MALLOC((len+1)*sizeof(DMM));
   for ( i = 1; i <= len; i++, in = NEXT(in) ) {    if ( stack ) {
     t->in[i] = BDY((DPM)BDY(in));      MKNODE(t1,data,BDY(stack->obj)); MKLIST(l,t1); t->obj = l;
       for ( i = 1; i <= len; i++, in = NEXT(in) ) {
          m1 = t->in[i] = BDY((DPM)BDY(in));
          NEWMP(mp); mp->dl = m1->dl; mp->c = m1->c; NEXT(mp) = 0;
          nv = ((DPM)BDY(in))->nv;
          MKDP(nv,mp,dp); dp->sugar = mp->dl->td;
          m0 = stack->sum[m1->pos]; MKDPM(nv,m0,dpm0);
          mulobjdpm(CO,(Obj)dp,dpm0,&dpm1);
          t->sum[i] = BDY(dpm1);
       }
     } else {
       MKNODE(t1,data,0); MKLIST(l,t1); t->obj = l;
       for ( i = 1; i <= len; i++, in = NEXT(in) ) {
         t->sum[i] = t->in[i] = BDY((DPM)BDY(in));
       }
   }    }
   t->next = dmm_stack;    t->next = stack;;
   dmm_stack = t;    dpm_ordtype = 3;
   dpm_ordtype = 2;    return t;
   MKNODE(t1,data,schreyer_obj?BDY(schreyer_obj):0);  
   MKLIST(schreyer_obj,t1);  
 }  }
   
 // data=[Ink,...,In0]  // data=[Ink,...,In0]
Line 2672  void set_schreyer_order(LIST data)
Line 2705  void set_schreyer_order(LIST data)
   if ( !data ) {    if ( !data ) {
     dmm_stack = 0;      dmm_stack = 0;
     if ( dp_current_spec && dp_current_spec->id >= 256 )      if ( dp_current_spec && dp_current_spec->id >= 256 )
       dpm_ordtype = dp_current_spec->ispot;        dpm_ordtype = dp_current_spec->module_ordtype;
     else      else
       dpm_ordtype = 0;        dpm_ordtype = 0;
     return;      return;
   } else {    } else {
       if ( !dp_current_spec || dp_current_spec->id < 256 )
         error("set_schreyer_order : base module order is not set");
     dmm_stack = 0;      dmm_stack = 0;
       dpm_base_ordtype = dp_current_spec->module_ordtype;
     in = BDY(data);      in = BDY(data);
     len = length(in);      len = length(in);
     w = (LIST *)MALLOC(len*sizeof(LIST));      w = (LIST *)MALLOC(len*sizeof(LIST));
     for ( i = 0; i < len; i++, in = NEXT(in) ) w[i] = (LIST)BDY(in);      for ( i = 0; i < len; i++, in = NEXT(in) ) w[i] = (LIST)BDY(in);
     for ( i = len-1; i >= 0; i-- ) push_schreyer_order(w[i]);      for ( i = len-1; i >= 0; i-- ) dmm_stack = push_schreyer_order(w[i],dmm_stack);
     dpm_ordtype = 2;  
   }    }
 }  }
   
   void set_schreyer_level(DMMstack_array array,int level)
   {
     if ( !level ) {
       dmm_stack = 0;
       if ( dp_current_spec && dp_current_spec->id >= 256 )
         dpm_ordtype = dp_current_spec->module_ordtype;
       else
         dpm_ordtype = 0;
       return;
     } else {
       if ( !dp_current_spec || dp_current_spec->id < 256 )
         error("set_schreyer_level : base module order is not set");
       if ( level > array->len )
         error("set_schreyer_level : invalid level");
       dmm_stack = array->body[level-1];
       dpm_base_ordtype = dp_current_spec->module_ordtype;
       dpm_ordtype = 3;
     }
   }
   
 // construct a base of syz(g)  // construct a base of syz(g)
 // assuming the schrerer order is properly set  // assuming the schrerer order is properly set
   
 DP dpm_sp_hm(DPM p1,DPM p2);  DP dpm_sp_hm(DPM p1,DPM p2);
 void dpm_sp(DPM p1,DPM p2,DPM *sp,DP *t1,DP *t2);  void dpm_sp(DPM p1,DPM p2,DPM *sp,DP *t1,DP *t2);
 DP *dpm_nf_and_quotient(NODE b,DPM sp,VECT psv,DPM *nf,P *dn);  DPM dpm_nf_and_quotient3(DPM sp,VECT psv,DPM *nf,P *dn);
   DPM dpm_nf_and_quotient4(DPM sp,DPM *ps,VECT psiv,DPM head,DPM *nf,P *dn);
   DPM dpm_sp_nf(VECT psv,VECT psiv,int i,int j,DPM *nf);
   DPM dpm_sp_nf_zlist(VECT psv,VECT psiv,int i,int j,int top,DPM *nf);
   DPM dpm_sp_nf_asir(VECT psv,int i,int j,DPM *nf);
 void dpm_sort(DPM p,DPM *r);  void dpm_sort(DPM p,DPM *r);
   
 extern int DP_Multiple;  extern int DP_Multiple;
Line 2729  NODE dpm_reduceall(NODE in)
Line 2788  NODE dpm_reduceall(NODE in)
   
 struct oEGT egra;  struct oEGT egra;
   
   void dpm_ht(DPM d,DPM *r);
   NODE reverse_node(NODE b);
   
 void dpm_schreyer_base(LIST g,LIST *s)  void dpm_schreyer_base(LIST g,LIST *s)
 {  {
   NODE nd,t,b0,b;    NODE nd,t0,t,b0,b;
   int n,i,j,k,nv;    int n,i,j,k,nv,max,pos;
   Z cont;    LIST l;
   P dn,c;  
   DP h,t1,t2;    DP h,t1,t2;
   MP d;    MP d;
   DMM r0,r;    DMM r0,r,r1;
   DPM sp,nf,dpm;    DPM sp,nf,dpm;
   DPM *ps;    DPM *ps;
   VECT psv;    VECT psv,psiv;
   DP **m,*quo;    DPM quo;
   struct oEGT eg0,eg1;    DP *mm;
     NODE *psi;
     NODE n1,n2,n3;
     int p1,p2,p3;
     struct oEGT eg0,eg1,egsp,egnf;
   extern struct oEGT egred;    extern struct oEGT egred;
     extern int sch_count,schrec_count,schlast_count;
   
     sch_count = schlast_count= 0;
   init_eg(&egra);    init_eg(&egra);
     init_eg(&egsp);
     init_eg(&egnf);
   nd = BDY(g);    nd = BDY(g);
   n = length(nd);    n = length(nd);
   MKVECT(psv,n);    MKVECT(psv,n+1);
   ps = (DPM *)BDY(psv);    ps = (DPM *)BDY(psv);
   for ( i = 0, t = nd; i < n; i++, t = NEXT(t) ) ps[i] = (DPM)BDY(t);    for ( i = 1, t = nd; i <= n; i++, t = NEXT(t) ) ps[i] = (DPM)BDY(t);
   nv = ps[0]->nv;    for ( i = 1, max = 0; i <= n; i++ )
   m = (DP **)almat_pointer(n,n);      if ( (pos=BDY(ps[i])->pos) > max ) max = pos;
     MKVECT(psiv,max+1);
     psi = (NODE *)BDY(psiv);
     for ( i = n; i >= 1; i-- ) {
       pos = BDY(ps[i])->pos;
       MKNODE(nd,(long)i,psi[pos]); psi[pos] = nd;
     }
     nv = ps[1]->nv;
     mm = (DP *)MALLOC((n+1)*sizeof(DP));
   b0 = 0;    b0 = 0;
   for ( i = 0; i < n; i++ ) {    get_eg(&eg0);
     // sp(ps[i],ps[j]) = ti*ps[i]-tj*ps[j] => m[i][j] = ti    for ( i = 1; i <= max; i++ ) {
     for ( j = i+1; j < n; j++ ) m[i][j] = dpm_sp_hm(ps[i],ps[j]);      memset(mm,0,(n+1)*sizeof(DP));
     for ( j = i+1; j < n; j++ ) {      for ( n1 = psi[i]; n1; n1 = NEXT(n1) ) {
       if ( !m[i][j] ) continue;        p1 = (long)BDY(n1);
       for ( h = m[i][j], k = i+1; k < n; k++ )        for ( n2 = NEXT(n1); n2; n2 = NEXT(n2) ) {
         if ( k != j && m[i][k] && dp_redble(m[i][k],h) ) m[i][k] = 0;          p2 = (long)BDY(n2);
           mm[p2] = dpm_sp_hm(ps[p1],ps[p2]);
         }
         for ( n2 = NEXT(n1); n2; n2 = NEXT(n2) ) {
           p2 = (long)BDY(n2);
           if ( !mm[p2] ) continue;
           for ( h = mm[p2], n3 = NEXT(n1); n3; n3 = NEXT(n3) ) {
             p3 = (long)BDY(n3);
             if ( n3 != n2 && mm[p3] && dp_redble(mm[p3],h) ) mm[p3] = 0;
           }
         }
         for ( j = p1+1; j <= n; j++ ) {
           if ( mm[j] ) {
             quo = dpm_sp_nf(psv,psiv,p1,j,&nf);
             if ( nf )
               error("dpm_schreyer_base : cannot happen");
             NEXTNODE(b0,b); BDY(b) = (pointer)quo;
           }
         }
     }      }
     for ( j = i+1; j < n; j++ ) {    }
       if ( m[i][j] ) {    get_eg(&eg1); add_eg(&egsp,&eg0,&eg1); print_eg("SP",&egsp);
         dpm_sp(ps[i],ps[j],&sp,&t1,&t2);    get_eg(&eg0);
         quo = dpm_nf_and_quotient(0,sp,psv,&nf,&dn);    get_eg(&eg1); add_eg(&egnf,&eg0,&eg1); print_eg("NF",&egnf); printf("\n");
         if ( nf )    if ( b0 ) NEXT(b) = 0;
           error("dpm_schreyer_base : cannot happen");    for ( t0 = 0, nd = BDY(g); nd; nd = NEXT(nd) ) {
         NEWDMM(r0); r = r0;      dpm_ht((DPM)BDY(nd),&dpm); NEXTNODE(t0,t); BDY(t) = (pointer)dpm;
         mulp(CO,(P)BDY(t1)->c,dn,(P *)&r->c); r->pos = i+1; r->dl = BDY(t1)->dl;    }
         NEWDMM(NEXT(r)); r=NEXT(r);    if ( t0 ) NEXT(t) = 0;
         mulp(CO,(P)BDY(t2)->c,dn,&c); chsgnp(c,(P *)&r->c); r->pos = j+1; r->dl = BDY(t2)->dl;    MKLIST(l,t0);
         if ( quo ) {    dmm_stack = push_schreyer_order(l,dmm_stack);
           for ( k = 0; k < n; k++ ) {  //  b0 = dpm_sort_list(b0);
             if ( !quo[k] ) continue;  //  get_eg(&eg0);
             for ( d = BDY(quo[k]); d; d = NEXT(d) ) {  //  b0 = dpm_reduceall(b0);
               NEXTDMM(r0,r); chsgnp((P)d->c,(P *)&r->c); r->pos = k+1; r->dl = d->dl;  //  get_eg(&eg1); add_eg(&egra,&eg0,&eg1); print_eg("RA",&egra);
             }    MKLIST(*s,b0);
           }  //  print_eg("red",&egred); printf("\n");
     printf("sch_count=%d, schlast_count=%d\n",sch_count,schlast_count);
   }
   
   void dpm_list_to_array(LIST g,VECT *psvect,VECT *psindvect)
   {
     NODE nd,t;
     int n;
     VECT psv,psiv;
     DPM *ps;
     int i,max,pos;
     LIST *psi;
     LIST l;
     Z iz;
   
     nd = BDY(g);
     n = length(nd);
     MKVECT(psv,n+1);
     ps = (DPM *)BDY(psv);
     for ( i = 1, t = nd; i <= n; i++, t = NEXT(t) ) ps[i] = (DPM)BDY(t);
     for ( i = 1, max = 0; i <= n; i++ )
       if ( (pos=BDY(ps[i])->pos) > max ) max = pos;
     MKVECT(psiv,max+1);
     psi = (LIST *)BDY(psiv);
     for ( i = 0; i <= max; i++ ) {
       MKLIST(l,0); psi[i] = l;
     }
     for ( i = n; i >= 1; i-- ) {
       pos = BDY(ps[i])->pos;
       STOZ(i,iz); MKNODE(nd,iz,BDY(psi[pos])); BDY(psi[pos]) = nd;
     }
     *psvect = psv; *psindvect = psiv;
   }
   
   #if 0
   void dpm_insert_to_zlist(VECT psiv,int pos,int i)
   {
     LIST l;
     NODE prev,cur,nd;
     int curi;
     Z iz;
   
     l = (LIST)BDY(psiv)[pos];
     for ( prev = 0, cur = BDY(l); cur; cur = NEXT(cur) ) {
       curi = ZTOS((Q)BDY(cur));
       if ( curi == i )
         error("dpm_insert_to_list : invalid index");
       if ( i < curi ) break;
       prev = cur;
     }
     STOZ(i,iz); MKNODE(nd,iz,cur);
     if ( prev == 0 ) BDY(l) = nd;
     else NEXT(prev) = nd;
   }
   #else
   void dpm_insert_to_zlist(VECT psiv,int pos,int i)
   {
     LIST l;
     NODE prev,cur,nd;
     int curi;
     Z iz;
   
     l = (LIST)BDY(psiv)[pos];
     for ( prev = 0, cur = BDY(l); cur; cur = NEXT(cur) ) {
       curi = ZTOS((Q)BDY(cur));
       if ( curi == i )
         error("dpm_insert_to_list : invalid index");
       prev = cur;
     }
     STOZ(i,iz); MKNODE(nd,iz,cur);
     if ( prev == 0 ) BDY(l) = nd;
     else NEXT(prev) = nd;
   }
   #endif
   
   void dpm_schreyer_base_zlist(LIST g,LIST *s)
   {
     NODE nd,t0,t,b0,b;
     int n,i,j,k,nv,max,pos;
     LIST l;
     DP h,t1,t2;
     MP d;
     DMM r0,r,r1;
     DPM sp,nf,dpm;
     DPM *ps;
     VECT psv,psiv;
     DPM quo;
     DP *mm;
     LIST *psi;
     NODE n1,n2,n3;
     int p1,p2,p3;
     Z iz;
     struct oEGT eg0,eg1,egsp,egnf;
     extern struct oEGT egred;
     extern int sch_count,schrec_count,schlast_count;
   
     sch_count = schlast_count= 0;
     init_eg(&egra);
     init_eg(&egsp);
     init_eg(&egnf);
     dpm_list_to_array(g,&psv,&psiv);
     ps = (DPM *)BDY(psv);
     psi = (LIST *)BDY(psiv);
     nv = ps[1]->nv;
     n = psv->len-1;
     max = psiv->len-1;
     mm = (DP *)MALLOC((n+1)*sizeof(DP));
     b0 = 0;
     get_eg(&eg0);
     for ( i = 1; i <= max; i++ ) {
       memset(mm,0,(n+1)*sizeof(DP));
       for ( n1 = BDY((LIST)psi[i]); n1; n1 = NEXT(n1) ) {
         p1 = ZTOS((Q)BDY(n1));
         for ( n2 = NEXT(n1); n2; n2 = NEXT(n2) ) {
           p2 = ZTOS((Q)BDY(n2));
           mm[p2] = dpm_sp_hm(ps[p1],ps[p2]);
         }
         for ( n2 = NEXT(n1); n2; n2 = NEXT(n2) ) {
           p2 = ZTOS((Q)BDY(n2));
           if ( !mm[p2] ) continue;
           for ( h = mm[p2], n3 = NEXT(n1); n3; n3 = NEXT(n3) ) {
             p3 = ZTOS((Q)BDY(n3));
             if ( n3 != n2 && mm[p3] && dp_redble(mm[p3],h) ) mm[p3] = 0;
         }          }
         NEXT(r) = 0;  
         MKDPM(nv,r0,dpm); // XXX : sugar is not set  
         NEXTNODE(b0,b);  
         BDY(b) = (pointer)dpm;  
       }        }
         for ( j = p1+1; j <= n; j++ ) {
           if ( mm[j] ) {
             quo = dpm_sp_nf_zlist(psv,psiv,p1,j,0,&nf);
             if ( nf )
               error("dpm_schreyer_base : cannot happen");
             NEXTNODE(b0,b); BDY(b) = (pointer)quo;
           }
         }
     }      }
     if ( b0 ) NEXT(b) = 0;  
   }    }
   push_schreyer_order(g);    get_eg(&eg1); add_eg(&egsp,&eg0,&eg1); print_eg("SP",&egsp);
   for ( t = b0; t; t = NEXT(t) ) {    get_eg(&eg0);
     dpm_sort((DPM)BDY(t),&dpm);    get_eg(&eg1); add_eg(&egnf,&eg0,&eg1); print_eg("NF",&egnf); printf("\n");
     BDY(t) = (pointer)dpm;    if ( b0 ) NEXT(b) = 0;
     for ( t0 = 0, nd = BDY(g); nd; nd = NEXT(nd) ) {
       dpm_ht((DPM)BDY(nd),&dpm); NEXTNODE(t0,t); BDY(t) = (pointer)dpm;
   }    }
   b0 = dpm_sort_list(b0);    if ( t0 ) NEXT(t) = 0;
 // get_eg(&eg0);    MKLIST(l,t0);
   b0 = dpm_reduceall(b0);    dmm_stack = push_schreyer_order(l,dmm_stack);
 // get_eg(&eg1); add_eg(&egra,&eg0,&eg1); print_eg("RA",&egra);  //  b0 = dpm_sort_list(b0);
   //  get_eg(&eg0);
   //  b0 = dpm_reduceall(b0);
   //  get_eg(&eg1); add_eg(&egra,&eg0,&eg1); print_eg("RA",&egra);
   MKLIST(*s,b0);    MKLIST(*s,b0);
 //  print_eg("red",&egred); printf("\n");  //  print_eg("red",&egred); printf("\n");
     printf("sch_count=%d, schlast_count=%d\n",sch_count,schlast_count);
 }  }
   
   static int compdp_nv;
   
   int compdp_revgradlex(DP *a,DP *b)
   {
     return -cmpdl_revgradlex(compdp_nv,BDY(*a)->dl,BDY(*b)->dl);
   }
   
   int compdp_lex(DP *a,DP *b)
   {
     return -cmpdl_lex(compdp_nv,BDY(*a)->dl,BDY(*b)->dl);
   }
   
   DMMstack_array dpm_schreyer_frame(NODE g)
   {
     LIST l;
     NODE nd,in,b0,b,n1,n2,n3,t;
     NODE *psi;
     long p1,p2,p3;
     int nv,n,i,j,k,max,pos,level;
     DMMstack s,s1;
     DMM m1,m0,dmm;
     MP mp;
     DP dp,h;
     DP *m,*m2;
     DPM dpm,dpm0,dpm1;
     VECT psv,psiv;
     DPM *ps;
     DMMstack_array dmmstack_array;
   
     nd = g;
     compdp_nv = nv = ((DPM)BDY(nd))->nv;
     s = 0;
     level = 0;
     while ( 1 ) {
       /* store the current nd to a DMMstack */
       n = length(nd);
       NEWDMMstack(s1);
       MKLIST(l,nd); s1->obj = l;
       s1->rank = n;
       s1->in = (DMM *)MALLOC((n+1)*sizeof(DMM));
       s1->sum = (DMM *)MALLOC((n+1)*sizeof(DMM));
       NEXT(s1) = s;
       if ( s ) {
         for ( i = 1, in = nd; i <= n; i++, in = NEXT(in) ) {
           m1 = s1->in[i] = BDY((DPM)BDY(in));
           NEWMP(mp); mp->dl = m1->dl; mp->c = m1->c; NEXT(mp) = 0;
           MKDP(nv,mp,dp); dp->sugar = mp->dl->td;
           m0 = s->sum[m1->pos]; MKDPM(nv,m0,dpm0);
           mulobjdpm(CO,(Obj)dp,dpm0,&dpm1);
           s1->sum[i] = BDY(dpm1);
         }
       } else {
         for ( i = 1, in = nd; i <= n; i++, in = NEXT(in) )  {
           m0 = BDY((DPM)BDY(in));
           NEWDMM(m1); *m1 = *m0; m1->c = (Obj)ONE; NEXT(m1) = 0;
           s1->sum[i] = s1->in[i] = m1;
         }
       }
       s = s1;
       level++;
   
   
       /* create new list */
       MKVECT(psv,n+1);
       ps = (DPM *)BDY(psv);
       for ( i = 1, t = nd; i <= n; i++, t = NEXT(t) ) ps[i] = (DPM)BDY(t);
       for ( i = 1, max = 0; i <= n; i++ )
         if ( (pos=BDY(ps[i])->pos) > max ) max = pos;
       MKVECT(psiv,max+1);
       psi = (NODE *)BDY(psiv);
       for ( i = n; i >= 1; i-- ) {
         pos = BDY(ps[i])->pos;
         MKNODE(nd,(long)i,psi[pos]); psi[pos] = nd;
       }
       m = (DP *)MALLOC((n+1)*sizeof(DP));
       m2 = (DP *)MALLOC((n+1)*sizeof(DP));
       b0 = 0;
       for ( i = 1; i <= max; i++ ) {
         for ( n1 = psi[i]; n1; n1 = NEXT(n1) ) {
           bzero(m,(n+1)*sizeof(DP));
           p1 = (long)BDY(n1);
           for ( n2 = NEXT(n1); n2; n2 = NEXT(n2) ) {
             p2 = (long)BDY(n2);
             h = dpm_sp_hm(ps[p1],ps[p2]);
             for ( n3 = NEXT(n1); n3 != n2; n3 = NEXT(n3) ) {
               p3 = (long)BDY(n3);
               if ( m[p3] ) {
                 if ( dp_redble(h,m[p3]) ) {
                   h = 0; break;
                 }
                 if ( dp_redble(m[p3],h) ) m[p3] = 0;
               }
             }
             if ( h ) m[p2] = h;
           }
   #if 0
           // compress m to m2
           for ( j = 0, n2 = NEXT(n1); n2; n2 = NEXT(n2) ) {
             p2 = (long)BDY(n2);
             if ( m[p2] ) m2[j++] = m[p2];
           }
           qsort(m2,j,sizeof(DP),(int (*)(const void *,const void *))compdp_lex);
           for ( k = 0; k < j; k++ ) {
             NEWDMM(dmm); dmm->dl = BDY(m2[k])->dl; dmm->pos = p1; dmm->c = (Obj)ONE;
             MKDPM(nv,dmm,dpm);
             NEXTNODE(b0,b); BDY(b) = (pointer)dpm;
           }
   #else
           for ( n2 = NEXT(n1); n2; n2 = NEXT(n2) ) {
             p2 = (long)BDY(n2);
             if ( m[p2] ) {
               NEWDMM(dmm); dmm->dl = BDY(m[p2])->dl; dmm->pos = p1; dmm->c = (Obj)ONE;
               MKDPM(nv,dmm,dpm);
               NEXTNODE(b0,b); BDY(b) = (pointer)dpm;
             }
           }
   #endif
         }
       }
       if ( !b0 ) {
         NEWDMMstack_array(dmmstack_array);
         dmmstack_array->len = level;
         dmmstack_array->body = (DMMstack *)MALLOC(level*sizeof(DMMstack));
         for ( i = level-1, s1 = s; i >= 0; i--, s1 = NEXT(s1) )
           dmmstack_array->body[i] = s1;
         return dmmstack_array;
       } else {
         NEXT(b) = 0;
         nd = b0;
       }
     }
   }
   
   int sch_count,schlast_count;
   
 int compdmm_schreyer(int n,DMM m1,DMM m2)  int compdmm_schreyer(int n,DMM m1,DMM m2)
 {  {
    int pos1,pos2,t;    int pos1,pos2,t,npos1,npos2;
    DMM *in;    DMM *in,*sum;
    DMMstack s;    DMMstack s;
    static DL d1=0,d2=0;    static DL d1=0,d2=0;
    static int dlen=0;    static int dlen=0;
   
    pos1 = m1->pos; pos2 = m2->pos;    sch_count++;
    if ( pos1 == pos2 ) return (*cmpdl)(n,m1->dl,m2->dl);    pos1 = m1->pos; pos2 = m2->pos;
    if ( n > dlen ) {    if ( pos1 == pos2 ) return (*cmpdl)(n,m1->dl,m2->dl);
      NEWDL(d1,n); NEWDL(d2,n); dlen = n;    if ( n > dlen ) {
    }      NEWDL(d1,n); NEWDL(d2,n); dlen = n;
    _copydl(n,m1->dl,d1);    }
    _copydl(n,m2->dl,d2);    sum = dmm_stack->sum;
    for ( s = dmm_stack; s; s = NEXT(s) ) {    _adddl(n,m1->dl,sum[pos1]->dl,d1);
      in = s->in;    _adddl(n,m2->dl,sum[pos2]->dl,d2);
      _addtodl(n,in[pos1]->dl,d1);    t = (*cmpdl)(n,d1,d2);
      _addtodl(n,in[pos2]->dl,d2);    if ( sum[pos1]->pos == sum[pos2]->pos && t == 0 ) {
      if ( in[pos1]->pos == in[pos2]->pos && _eqdl(n,d1,d2)) {      for ( s = dmm_stack; s; s = NEXT(s) ) {
        if ( pos1 < pos2 ) return 1;        in = s->in;
        else if ( pos1 > pos2 ) return -1;        npos1 = in[pos1]->pos;
        else return 0;        npos2 = in[pos2]->pos;
      }        if ( npos1 == npos2 ) break;
      pos1 = in[pos1]->pos;        else {
      pos2 = in[pos2]->pos;          pos1 = npos1;
      if ( pos1 == pos2 ) return (*cmpdl)(n,d1,d2);          pos2 = npos2;
    }        }
    // comparison by the bottom order      }
 LAST:      // (pos1,pos2) = the last pair s.t. pos1 != pos2
   if ( dpm_ordtype == 1 ) {      // simply compare pos1 and pos2
     if ( pos1 < pos2 ) return 1;      if ( pos1 < pos2 ) return 1;
     else if ( pos1 > pos2 ) return -1;      else if ( pos1 > pos2 ) return -1;
     } else {
       schlast_count++;
       pos1 = sum[pos1]->pos;
       pos2 = sum[pos2]->pos;
       if ( dpm_base_ordtype == 1 ) {
         if ( pos1 < pos2 ) return 1;
         else if ( pos1 > pos2 ) return -1;
         else return t;
       } else {
         if ( t ) return t;
         else if ( pos1 < pos2 ) return 1;
         else if ( pos1 > pos2 ) return -1;
         else return 0;
       }
     }
   }
   
   int compdmm_schreyer_old(int n,DMM m1,DMM m2)
   {
     int pos1,pos2,t,npos1,npos2;
     DMM *in,*sum;
     DMMstack s;
     static DL d1=0,d2=0;
     static int dlen=0;
   
     sch_count++;
     pos1 = m1->pos; pos2 = m2->pos;
     if ( pos1 == pos2 ) return (*cmpdl)(n,m1->dl,m2->dl);
     if ( n > dlen ) {
       NEWDL(d1,n); NEWDL(d2,n); dlen = n;
     }
     sum = dmm_stack->sum;
     _copydl(n,m1->dl,d1);
     _copydl(n,m2->dl,d2);
     for ( s = dmm_stack; s; s = NEXT(s) ) {
       in = s->in;
       _addtodl(n,in[pos1]->dl,d1);
       _addtodl(n,in[pos2]->dl,d2);
       if ( in[pos1]->pos == in[pos2]->pos && _eqdl(n,d1,d2)) {
         if ( pos1 < pos2 ) return 1;
         else if ( pos1 > pos2 ) return -1;
         else return 0;
       }
       pos1 = in[pos1]->pos;
       pos2 = in[pos2]->pos;
       if ( pos1 == pos2 ) return (*cmpdl)(n,d1,d2);
     }
     if ( dpm_base_ordtype == 1 ) {
       if ( pos1 < pos2 ) return 1;
       else if ( pos1 > pos2 ) return -1;
     else return (*cmpdl)(n,d1,d2);      else return (*cmpdl)(n,d1,d2);
   } else {    } else {
     t = (*cmpdl)(n,d1,d2);      t = (*cmpdl)(n,d1,d2);
Line 2844  LAST:
Line 3255  LAST:
   }    }
 }  }
   
 #if 1  extern int NaiveSchreyer;
   
 int compdmm(int n,DMM m1,DMM m2)  int compdmm(int n,DMM m1,DMM m2)
 {  {
   int t;    int t,t1;
     int *base_ord;
   
   switch ( dpm_ordtype ) {    switch ( dpm_ordtype ) {
   case 0:    case 0: /* TOP ord->pos */
     t = (*cmpdl)(n,m1->dl,m2->dl);      t = (*cmpdl)(n,m1->dl,m2->dl);
     if ( t ) return t;      if ( t ) return t;
     else if ( m1->pos < m2->pos ) return 1;      else if ( m1->pos < m2->pos ) return 1;
     else if ( m1->pos > m2->pos ) return -1;      else if ( m1->pos > m2->pos ) return -1;
     else return 0;      else return 0;
   case 1:    case 1: /* POT : pos->ord */
     if ( m1->pos < m2->pos ) return 1;      if ( m1->pos < m2->pos ) return 1;
     else if ( m1->pos > m2->pos ) return -1;      else if ( m1->pos > m2->pos ) return -1;
     else return (*cmpdl)(n,m1->dl,m2->dl);      else return (*cmpdl)(n,m1->dl,m2->dl);
   case 2:    case 2:  /* wPOT: weight->pos->ord */
     return compdmm_schreyer(n,m1,m2);      if ( m1->dl->td > m2->dl->td ) return 1;
       else if ( m1->dl->td < m2->dl->td ) return 1;
       else if ( m1->pos < m2->pos ) return 1;
       else if ( m1->pos > m2->pos ) return -1;
       else return (*cmpdl)(n,m1->dl,m2->dl);
     case 3: /* Schreyer */
       if ( NaiveSchreyer )
         t = compdmm_schreyer_old(n,m1,m2);
       else
         t = compdmm_schreyer(n,m1,m2);
       return t;
     case 4:  /* POT with base_ord */
       base_ord = dp_current_spec->module_base_ord;
       if ( base_ord[m1->pos] < base_ord[m2->pos] ) return 1;
       else if ( base_ord[m1->pos] > base_ord[m2->pos] ) return -1;
       else return (*cmpdl)(n,m1->dl,m2->dl);
   default:    default:
     error("compdmm : invalid dpm_ordtype");      error("compdmm : invalid dpm_ordtype");
   }    }
 }  }
 #else  
 int compdmm(int n,DMM m1,DMM m2)  
 {  
   int t;  
   
   if ( dpm_ordtype == 1 ) {  
     if ( m1->pos < m2->pos ) return 1;  
     else if ( m1->pos > m2->pos ) return -1;  
     else return (*cmpdl)(n,m1->dl,m2->dl);  
   } else if ( dpm_ordtype == 0 ) {  
     t = (*cmpdl)(n,m1->dl,m2->dl);  
     if ( t ) return t;  
     else if ( m1->pos < m2->pos ) return 1;  
     else if ( m1->pos > m2->pos ) return -1;  
     else return 0;  
   } else if ( dpm_ordtype == 2 ) {  
     return compdmm_schreyer(n,m1,m2);  
   }  
 }  
 #endif  
   
 void adddpm(VL vl,DPM p1,DPM p2,DPM *pr)  void adddpm(VL vl,DPM p1,DPM p2,DPM *pr)
 {  {
   int n,s;    int n,s;
Line 3139  int compdpm(VL vl,DPM p1,DPM p2)
Line 3547  int compdpm(VL vl,DPM p1,DPM p2)
   }    }
 }  }
   
   void dpm_removecont2(DPM p1,DPM p2,DPM *r1p,DPM *r2p,Z *contp);
   
 // p = ...+c*<<0,...0:pos>>+...  // p = ...+c*<<0,...0:pos>>+...
 DPM dpm_eliminate_term(DPM a,DPM p,Obj c,int pos)  DPM dpm_eliminate_term(DPM a,DPM p,Obj c,int pos)
 {  {
   MP d0,d;    MP d0,d;
     DL dl;
   DMM m;    DMM m;
   DP f;    DP f;
   DPM a1,p1,r;    DPM a1,p1,r,r1,dmy;
     Z dmyz;
   
   if ( !a ) return 0;    if ( !a ) return 0;
   d0 = 0;    d0 = 0;
   for ( m = BDY(a); m; m = NEXT(m) )    for ( m = BDY(a); m; m = NEXT(m) )
     if ( m->pos == pos ) {      if ( m->pos == pos ) {
       NEXTMP(d0,d); d->dl = m->dl; arf_chsgn(m->c,&d->c);        NEXTMP(d0,d);
         arf_chsgn(m->c,&d->c);
         if ( !dp_current_spec || !dp_current_spec->module_top_weight )
           d->dl = m->dl;
         else {
           NEWDL(dl,NV(a));
           _copydl(NV(a),m->dl,dl);
           dl->td -= dp_current_spec->module_top_weight[pos-1];
           d->dl = dl;
         }
     }      }
   if ( d0 ) {    if ( d0 ) {
     NEXT(d) = 0; MKDP(NV(a),d0,f);      NEXT(d) = 0; MKDP(NV(a),d0,f);
     mulcdpm(CO,c,a,&a1);      mulcdpm(CO,c,a,&a1);
     mulobjdpm(CO,(Obj)f,p,&p1);      mulobjdpm(CO,(Obj)f,p,&p1);
     adddpm(CO,a1,p1,&r);      adddpm(CO,a1,p1,&r);
     return r;      dpm_removecont2(0,r,&dmy,&r1,&dmyz);
       return r1;
   } else    } else
     return a;      return a;
 }  }
Line 3184  DPM dpm_compress(DPM p,int *tab)
Line 3606  DPM dpm_compress(DPM p,int *tab)
 }  }
   
 // input : s, s = syz(m) output simplified s, m  // input : s, s = syz(m) output simplified s, m
 void dpm_simplify_syz(LIST s,LIST m,LIST *s1,LIST *m1)  void dpm_simplify_syz(LIST s,LIST m,LIST *s1,LIST *m1,LIST *w1)
 {  {
   int lm,ls,i,j,pos;    int lm,ls,i,j,k,pos,nv;
   DPM *am,*as;    DPM *am,*as;
   DPM p;    DPM p;
   DMM d;    DMM d;
   Obj c;    Obj c;
   int *tab;    Z q;
     int *tab,*dd,*new_w;
   NODE t,t1;    NODE t,t1;
   
   lm = length(BDY(m));    lm = length(BDY(m));
Line 3204  void dpm_simplify_syz(LIST s,LIST m,LIST *s1,LIST *m1)
Line 3627  void dpm_simplify_syz(LIST s,LIST m,LIST *s1,LIST *m1)
   for ( i = 0; i < ls; i++ ) {    for ( i = 0; i < ls; i++ ) {
     p = as[i];      p = as[i];
     if ( p == 0 ) continue;      if ( p == 0 ) continue;
     for ( d = BDY(p); d; d = NEXT(d) ) if ( d->dl->td == 0 ) break;      nv = NV(p);
       for ( d = BDY(p); d; d = NEXT(d) ) {
         dd = d->dl->d;
         for ( k = 0; k < nv; k++ ) if ( dd[k] ) break;
         if ( k == nv ) break;
       }
     if ( d ) {      if ( d ) {
       c = d->c; pos = d->pos;        c = d->c; pos = d->pos;
       for ( j = 0; j < ls; j++ )        for ( j = 0; j < ls; j++ )
Line 3222  void dpm_simplify_syz(LIST s,LIST m,LIST *s1,LIST *m1)
Line 3650  void dpm_simplify_syz(LIST s,LIST m,LIST *s1,LIST *m1)
   tab = (int *)MALLOC((lm+1)*sizeof(int));    tab = (int *)MALLOC((lm+1)*sizeof(int));
   for ( j = 0, i = 1; i <= lm; i++ ) {    for ( j = 0, i = 1; i <= lm; i++ ) {
     if ( am[i] ) { j++; tab[i] = j; }      if ( am[i] ) { j++; tab[i] = j; }
     else tab[i] = 0;      else { tab[i] = 0; }
   }    }
   t = 0;    t = 0;
   for ( i = ls-1; i >= 0; i-- )    for ( i = ls-1; i >= 0; i-- )
Line 3231  void dpm_simplify_syz(LIST s,LIST m,LIST *s1,LIST *m1)
Line 3659  void dpm_simplify_syz(LIST s,LIST m,LIST *s1,LIST *m1)
       MKNODE(t1,(pointer)p,t); t = t1;        MKNODE(t1,(pointer)p,t); t = t1;
     }      }
   MKLIST(*s1,t);    MKLIST(*s1,t);
   
     if ( dp_current_spec && dp_current_spec->module_top_weight ) {
       new_w = (int *)MALLOC(j*sizeof(int));
       for ( j = 0, i = 1; i <= lm; i++ )
         if ( tab[i] ) { new_w[j++] = dp_current_spec->module_top_weight[i-1]; }
       t = 0;
       for ( i = j-1; i >= 0; i-- ) {
         STOZ(new_w[i],q);
         MKNODE(t1,q,t); t = t1;
       }
     } else
       t = 0;
     MKLIST(*w1,t);
   
   t = 0;    t = 0;
   for ( i = lm; i >= 1; i-- )    for ( i = lm; i >= 1; i-- )
     if ( am[i] ) {      if ( am[i] ) {

Legend:
Removed from v.1.8  
changed lines
  Added in v.1.20

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>