===================================================================
RCS file: /home/cvs/OpenXM_contrib2/asir2018/builtin/dp-supp.c,v
retrieving revision 1.5
retrieving revision 1.8
diff -u -p -r1.5 -r1.8
--- OpenXM_contrib2/asir2018/builtin/dp-supp.c	2019/09/13 02:04:42	1.5
+++ OpenXM_contrib2/asir2018/builtin/dp-supp.c	2019/11/01 04:28:52	1.8
@@ -45,7 +45,7 @@
  * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
  * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.
  *
- * $OpenXM: OpenXM_contrib2/asir2018/builtin/dp-supp.c,v 1.4 2019/09/04 01:12:02 noro Exp $
+ * $OpenXM: OpenXM_contrib2/asir2018/builtin/dp-supp.c,v 1.7 2019/10/11 03:45:56 noro Exp $
 */
 #include "ca.h"
 #include "base.h"
@@ -1244,6 +1244,56 @@ void dp_removecont2(DP p1,DP p2,DP *r1p,DP *r2p,Z *con
     *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 */
 
 void dp_true_nf_marked(NODE b,DP g,DP *ps,DP *hps,DP *rp,P *nmp,P *dnp)
@@ -2175,51 +2225,88 @@ int create_order_spec(VL vl,Obj obj,struct order_spec 
     spec->ord.simple = ZTOS((Q)obj);
     return 1;
   } else if ( OID(obj) == O_LIST ) {
-    /* module order; obj = [0|1,w,ord] or [0|1,ord] */
+    /* module order */
     node = BDY((LIST)obj); 
     if ( !BDY(node) || NUM(BDY(node)) ) {
       switch ( length(node) ) {
-      case 2:
+      case 2: /* [n,ord] */
         create_order_spec(0,(Obj)BDY(NEXT(node)),&spec);
         spec->id += 256; spec->obj = obj;
         spec->top_weight = 0;
         spec->module_rank = 0;
         spec->module_top_weight = 0;
-        spec->ispot = (BDY(node)!=0);
-        if ( spec->ispot ) {
-          n = ZTOS((Q)BDY(node));
-          if ( n < 0 )
-            spec->pot_nelim = -n;
-          else
+        spec->module_ordtype = ZTOS((Z)BDY(node));
+        if ( spec->module_ordtype < 0  ) {
+            spec->pot_nelim = -spec->module_ordtype;
+            spec->module_ordtype = 1;
+        } else
             spec->pot_nelim = 0;
-        }
         break;
 
-      case 3:
-        create_order_spec(0,(Obj)BDY(NEXT(NEXT(node))),&spec);
-        spec->id += 256; spec->obj = obj;
-        spec->ispot = (BDY(node)!=0);
-        node = NEXT(node);
-        if ( !BDY(node) || OID(BDY(node)) != O_LIST ) 
-          error("create_order_spec : [weight_for_poly,weight_for_modlue] must be specified as a module topweight");
-        wpair = BDY((LIST)BDY(node));
-        if ( length(wpair) != 2 )
-          error("create_order_spec : [weight_for_poly,weight_for_modlue] must be specified as a module topweight");
+      case 3: /* [n,[wv,wm],ord] */
+        spec->module_ordtype = ZTOS((Z)BDY(node));
+        if ( spec->module_ordtype < 0  ) {
+            spec->pot_nelim = -spec->module_ordtype;
+            spec->module_ordtype = 1;
+        } else
+            spec->pot_nelim = 0;
 
-        wp = BDY(wpair);
-        wm = BDY(NEXT(wpair));
-        if ( !wp || OID(wp) != O_LIST || !wm || OID(wm) != O_LIST )
-          error("create_order_spec : [weight_for_poly,weight_for_modlue] must be specified as a module topweight");
-        spec->nv = length(BDY((LIST)wp)); 
-        spec->top_weight = (int *)MALLOC_ATOMIC(spec->nv*sizeof(int));
-        for ( i = 0, t = BDY((LIST)wp); i < spec->nv; t = NEXT(t), i++ )
-          spec->top_weight[i] = ZTOS((Q)BDY(t));
+        if ( spec->module_ordtype == 3 ) { /* schreyer order */
+          Obj baseobj;
+          struct order_spec *basespec;
+          int len;
+          NODE in;
+          LIST *la;
+          DMMstack stack;
+          DMMstack push_schreyer_order(LIST l,DMMstack s);
 
-        spec->module_rank = length(BDY((LIST)wm));
-        spec->module_top_weight = (int *)MALLOC_ATOMIC(spec->module_rank*sizeof(int));
-        for ( i = 0, t = BDY((LIST)wm); i < spec->module_rank; t = NEXT(t), i++ )
-          spec->module_top_weight[i] = ZTOS((Q)BDY(t));
+          spec->id = 300; spec->obj = obj;
+          node = NEXT(node);
+          if ( !BDY(node) || OID(BDY(node)) != O_LIST ) 
+            error("create_order_spec : [mlist1,mlist,...] must be specified for defining a schreyer order");
+          stack = 0;
+          in = BDY((LIST)BDY(node));
+          len = length(in);
+          la = (LIST *)MALLOC(len*sizeof(LIST));
+          for ( i = 0; i < len; i++, in = NEXT(in) ) la[i] = (LIST)(BDY(in));
+          for ( i = len-1; i >= 0; i-- ) stack = push_schreyer_order(la[i],stack);
+          spec->dmmstack = stack;
+
+          node = NEXT(node);
+          baseobj = (Obj)BDY(node);
+          create_order_spec(0,baseobj,&basespec);
+          basespec->obj = baseobj;
+          spec->base = basespec;
+        } else {  /* weighted order */
+          int ordtype;
+
+          ordtype = spec->module_ordtype;
+          create_order_spec(0,(Obj)BDY(NEXT(NEXT(node))),&spec);
+          spec->module_ordtype = ordtype;
+          spec->id += 256; spec->obj = obj;
+          node = NEXT(node);
+          if ( !BDY(node) || OID(BDY(node)) != O_LIST ) 
+            error("create_order_spec : [weight_for_poly,weight_for_modlue] must be specified as a module topweight");
+          wpair = BDY((LIST)BDY(node));
+          if ( length(wpair) != 2 )
+            error("create_order_spec : [weight_for_poly,weight_for_modlue] must be specified as a module topweight");
+  
+          wp = BDY(wpair);
+          wm = BDY(NEXT(wpair));
+          if ( !wp || OID(wp) != O_LIST || !wm || OID(wm) != O_LIST )
+            error("create_order_spec : [weight_for_poly,weight_for_modlue] must be specified as a module topweight");
+          spec->nv = length(BDY((LIST)wp)); 
+          spec->top_weight = (int *)MALLOC_ATOMIC(spec->nv*sizeof(int));
+          for ( i = 0, t = BDY((LIST)wp); i < spec->nv; t = NEXT(t), i++ )
+            spec->top_weight[i] = ZTOS((Q)BDY(t));
+  
+          spec->module_rank = length(BDY((LIST)wm));
+          spec->module_top_weight = (int *)MALLOC_ATOMIC(spec->module_rank*sizeof(int));
+          for ( i = 0, t = BDY((LIST)wm); i < spec->module_rank; t = NEXT(t), i++ )
+            spec->module_top_weight[i] = ZTOS((Q)BDY(t));
+        }
         break;
+
       default:
         error("create_order_spec : invalid arguments for module order");
       }
@@ -2587,6 +2674,56 @@ void create_modorder_spec(int id,LIST shift,struct mod
  *
  */
 
+void dpm_homo(DPM p,DPM *rp)
+{
+  DMM m,mr,mr0,t;
+  int i,n,nv,td;
+  DL dl,dlh;
+
+  if ( !p )
+    *rp = 0;
+  else {
+    n = p->nv; nv = n + 1;
+    m = BDY(p);
+    td = 0;
+    for ( t = m; t; t = NEXT(t) )
+      if ( m->dl->td > td ) td = m->dl->td;
+    for ( mr0 = 0; m; m = NEXT(m) ) {
+      NEXTDMM(mr0,mr); mr->c = m->c; mr->pos = m->pos;
+      dl = m->dl;
+      mr->dl = dlh = (DL)MALLOC_ATOMIC((nv+1)*sizeof(int));
+      dlh->td = td;
+      for ( i = 0; i < n; i++ )
+        dlh->d[i] = dl->d[i];
+      dlh->d[n] = td - dl->td;
+    }
+    NEXT(mr) = 0; MKDPM(nv,mr0,*rp); (*rp)->sugar = p->sugar;
+  }
+}
+
+void dpm_dehomo(DPM p,DPM *rp)
+{
+  DMM m,mr,mr0;
+  int i,n,nv;
+  DL dl,dlh;
+
+  if ( !p )
+    *rp = 0;
+  else {
+    n = p->nv; nv = n - 1;
+    m = BDY(p);
+    for ( mr0 = 0; m; m = NEXT(m) ) {
+      NEXTDMM(mr0,mr); mr->c = m->c; mr->pos = m->pos;
+      dlh = m->dl;
+      mr->dl = dl = (DL)MALLOC_ATOMIC((nv+1)*sizeof(int));
+      dl->td = dlh->td - dlh->d[nv];
+      for ( i = 0; i < nv; i++ )
+        dl->d[i] = dlh->d[i];
+    }
+    NEXT(mr) = 0; MKDPM(nv,mr0,*rp); (*rp)->sugar = p->sugar;
+  }
+}
+
 void dp_homo(DP p,DP *rp)
 {
   MP m,mr,mr0;
@@ -2634,6 +2771,7 @@ void dp_dehomo(DP p,DP *rp)
   }
 }
 
+
 void dp_mod(DP p,int mod,NODE subst,DP *rp)
 {
   MP m,mr,mr0;
@@ -2689,11 +2827,12 @@ void homogenize_order(struct order_spec *old,int n,str
   struct weight_or_block *owb,*nwb;
 
   *newp = new = (struct order_spec *)MALLOC(sizeof(struct order_spec));
+  bcopy((char *)old,(char *)new,sizeof(struct order_spec));
   switch ( old->id ) {
     case 0:
       switch ( old->ord.simple ) {
         case 0:
-          new->id = 0; new->ord.simple = 0; break;
+          break;
         case 1:
           l = (struct order_pair *)
             MALLOC_ATOMIC(2*sizeof(struct order_pair));
@@ -2704,12 +2843,12 @@ void homogenize_order(struct order_spec *old,int n,str
           new->ord.block.length = 2; new->nv = n+1;
           break;
         case 2:
-          new->id = 0; new->ord.simple = 1; break;
+          new->ord.simple = 1; break;
         case 3: case 4: case 5:
-          new->id = 0; new->ord.simple = old->ord.simple+3;
+          new->ord.simple = old->ord.simple+3;
           dp_nelim = n-1; break;
         case 6: case 7: case 8: case 9:
-          new->id = 0; new->ord.simple = old->ord.simple; break;
+          break;
         default:
           error("homogenize_order : invalid input");
       }
@@ -2720,10 +2859,9 @@ void homogenize_order(struct order_spec *old,int n,str
         MALLOC_ATOMIC((length+1)*sizeof(struct order_pair));
       bcopy((char *)old->ord.block.order_pair,(char *)l,length*sizeof(struct order_pair));
       l[length].order = 2; l[length].length = 1;
-      new->id = old->id; new->nv = n+1;
+      new->nv = n+1;
       new->ord.block.order_pair = l;
       new->ord.block.length = length+1;
-      new->ispot = old->ispot;
       break;
     case 2: case 258:
       nv = old->nv; row = old->ord.matrix.row;
@@ -2735,9 +2873,8 @@ void homogenize_order(struct order_spec *old,int n,str
           newm[i+1][j] = oldm[i][j];
         newm[i+1][j] = 0;
       }
-      new->id = old->id; new->nv = nv+1;
+      new->nv = nv+1;
       new->ord.matrix.row = row+1; new->ord.matrix.matrix = newm;
-      new->ispot = old->ispot;
       break;
     case 3: case 259:
       onv = old->nv;
@@ -2773,17 +2910,15 @@ void homogenize_order(struct order_spec *old,int n,str
         (struct sparse_weight *)MALLOC(sizeof(struct sparse_weight));
       nwb[i].body.sparse_weight[0].pos = onv;
       nwb[i].body.sparse_weight[0].value = 1;
-      new->id = old->id;
       new->nv = nnv;
       new->ord.composite.length = nlen;
       new->ord.composite.w_or_b = nwb;
-      new->ispot = old->ispot;
       print_composite_order_spec(new);
       break;
     case 256: /* simple module order */
       switch ( old->ord.simple ) {
         case 0:
-          new->id = 256; new->ord.simple = 0; break;
+          break;
         case 1:
           l = (struct order_pair *)
             MALLOC_ATOMIC(2*sizeof(struct order_pair));
@@ -2794,11 +2929,10 @@ void homogenize_order(struct order_spec *old,int n,str
           new->ord.block.length = 2; new->nv = n+1;
           break;
         case 2:
-          new->id = 256; new->ord.simple = 1; break;
+          new->ord.simple = 1; break;
         default:
           error("homogenize_order : invalid input");
       }
-      new->ispot = old->ispot;
       break;
     default:
       error("homogenize_order : invalid input");