===================================================================
RCS file: /home/cvs/OpenXM_contrib2/asir2018/engine/dist.c,v
retrieving revision 1.9
retrieving revision 1.14
diff -u -p -r1.9 -r1.14
--- OpenXM_contrib2/asir2018/engine/dist.c	2019/09/19 06:29:47	1.9
+++ OpenXM_contrib2/asir2018/engine/dist.c	2019/11/12 22:27:04	1.14
@@ -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/engine/dist.c,v 1.8 2019/09/13 02:04:42 noro Exp $
+ * $OpenXM: OpenXM_contrib2/asir2018/engine/dist.c,v 1.13 2019/11/12 12:50:40 noro Exp $
 */
 #include "ca.h"
 
@@ -2654,7 +2654,11 @@ int dpm_base_ordtype;;
 DMMstack push_schreyer_order(LIST data,DMMstack stack)
 {
   DMMstack t;
-  int len,i;
+  DP dp;
+  MP mp;
+  DMM m0,m1;
+  DPM dpm0,dpm1;
+  int len,i,nv;
   NODE in,t1;
   LIST l;
 
@@ -2666,14 +2670,24 @@ DMMstack push_schreyer_order(LIST data,DMMstack stack)
   NEWDMMstack(t);
   t->rank = len;
   t->in = (DMM *)MALLOC((len+1)*sizeof(DMM));
+  t->sum = (DMM *)MALLOC((len+1)*sizeof(DMM));
   if ( stack ) {
     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));
+    }
   }
-  for ( i = 1; i <= len; i++, in = NEXT(in) ) {
-    t->in[i] = BDY((DPM)BDY(in));
-  }
   t->next = stack;;
   dpm_ordtype = 3;
   return t;
@@ -2713,7 +2727,10 @@ void set_schreyer_order(LIST data)
 
 DP dpm_sp_hm(DPM p1,DPM p2);
 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_asir(VECT psv,int i,int j,DPM *nf);
 void dpm_sort(DPM p,DPM *r);
 
 extern int DP_Multiple;
@@ -2752,20 +2769,24 @@ struct oEGT egra;
 
 void dpm_ht(DPM d,DPM *r);
 
+#if 0
 void dpm_schreyer_base(LIST g,LIST *s)
 {
   NODE nd,t0,t,b0,b;
-  int n,i,j,k,nv;
+  int n,i,j,k,nv,max,pos;
   LIST l;
   Z cont;
   P dn,c;
   DP h,t1,t2;
   MP d;
-  DMM r0,r;
+  DMM r0,r,r1;
   DPM sp,nf,dpm;
   DPM *ps;
-  VECT psv;
-  DP **m,*quo;
+  VECT psv,psv2;
+  DPM quo;
+  DP **m;
+  NODE2 *ps2;
+  NODE2 nd2;
   struct oEGT eg0,eg1;
   extern struct oEGT egred;
 
@@ -2775,9 +2796,18 @@ void dpm_schreyer_base(LIST g,LIST *s)
   MKVECT(psv,n);
   ps = (DPM *)BDY(psv);
   for ( i = 0, t = nd; i < n; i++, t = NEXT(t) ) ps[i] = (DPM)BDY(t);
+  for ( i = 0, max = 0; i < n; i++ )
+    if ( (pos=BDY(ps[i])->pos) > max ) max = pos;
+  MKVECT(psv2,max+1);
+  ps2 = (NODE2 *)BDY(psv2);
+  for ( i = n-1; i >= 0; i-- ) {
+    pos = BDY(ps[i])->pos;
+    MKNODE2(nd2,ps[i],(long)i+1,ps2[pos]); ps2[pos] = nd2;
+  }
   nv = ps[0]->nv;
   m = (DP **)almat_pointer(n,n);
   b0 = 0;
+  k = 0;
   for ( i = 0; i < n; i++ ) {
     // sp(ps[i],ps[j]) = ti*ps[i]-tj*ps[j] => m[i][j] = ti
     for ( j = i+1; j < n; j++ ) m[i][j] = dpm_sp_hm(ps[i],ps[j]);
@@ -2788,8 +2818,11 @@ void dpm_schreyer_base(LIST g,LIST *s)
     }
     for ( j = i+1; j < n; j++ ) {
       if ( m[i][j] ) {
+        DPM quo1,nf1;
+        P dn1;
+
         dpm_sp(ps[i],ps[j],&sp,&t1,&t2);
-        quo = dpm_nf_and_quotient(0,sp,psv,&nf,&dn);
+        quo = dpm_nf_and_quotient3(sp,psv2,&nf,&dn);
         if ( nf ) 
           error("dpm_schreyer_base : cannot happen");
         NEWDMM(r0); r = r0; 
@@ -2797,17 +2830,16 @@ void dpm_schreyer_base(LIST g,LIST *s)
         NEWDMM(NEXT(r)); r=NEXT(r);
         mulp(CO,(P)BDY(t2)->c,dn,&c); chsgnp(c,(P *)&r->c); r->pos = j+1; r->dl = BDY(t2)->dl;
         if ( quo ) {
-          for ( k = 0; k < n; k++ ) {
-            if ( !quo[k] ) continue;
-            for ( d = BDY(quo[k]); d; d = NEXT(d) ) {
-              NEXTDMM(r0,r); chsgnp((P)d->c,(P *)&r->c); r->pos = k+1; r->dl = d->dl;
-            }
+          for ( r1 = BDY(quo); r1; r1 = NEXT(r1) ) {
+            chsgnp((P)r1->c,&c); r1->c = (Obj)c;
           }
-        }
-        NEXT(r) = 0;
+          NEXT(r) = BDY(quo);
+        } else
+          NEXT(r) = 0;
         MKDPM(nv,r0,dpm); // XXX : sugar is not set
         NEXTNODE(b0,b);
         BDY(b) = (pointer)dpm;
+        k++;
       }
     }
     if ( b0 ) NEXT(b) = 0;
@@ -2818,18 +2850,200 @@ void dpm_schreyer_base(LIST g,LIST *s)
   if ( t0 ) NEXT(t) = 0;
   MKLIST(l,t0);
   dmm_stack = push_schreyer_order(l,dmm_stack);
-  for ( t = b0; t; t = NEXT(t) ) {
-    dpm_sort((DPM)BDY(t),&dpm); 
-    BDY(t) = (pointer)dpm;
-  }
+//  for ( t = b0; t; t = NEXT(t) ) {
+//    dpm_sort((DPM)BDY(t),&dpm); 
+//    BDY(t) = (pointer)dpm;
+//  }
   b0 = dpm_sort_list(b0);
-// get_eg(&eg0);
+  get_eg(&eg0);
   b0 = dpm_reduceall(b0);
-// get_eg(&eg1); add_eg(&egra,&eg0,&eg1); print_eg("RA",&egra);
+  get_eg(&eg1); add_eg(&egra,&eg0,&eg1); print_eg("RA",&egra);
   MKLIST(*s,b0);
 //  print_eg("red",&egred); printf("\n");
 }
+#elif 0
+void dpm_schreyer_base(LIST g,LIST *s)
+{
+  NODE nd,t0,t,b0,b;
+  int n,i,j,k,nv,max,pos;
+  LIST l;
+  Z cont;
+  P dn,c;
+  DP h,t1,t2;
+  MP d;
+  DMM r0,r,r1;
+  DPM sp,nf,dpm;
+  DPM *ps;
+  VECT psiv;
+  DPM quo;
+  DP **m;
+  NODE *psi;
+  struct oEGT eg0,eg1;
+  extern struct oEGT egred;
 
+  init_eg(&egra);
+  nd = BDY(g);
+  n = length(nd);
+  ps = (DPM *)MALLOC(n*sizeof(DPM));
+  for ( i = 0, t = nd; i < n; i++, t = NEXT(t) ) ps[i] = (DPM)BDY(t);
+  for ( i = 0, 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-1; i >= 0; i-- ) {
+    pos = BDY(ps[i])->pos;
+    MKNODE(nd,(long)(i+1),psi[pos]); psi[pos] = nd;
+  }
+  nv = ps[0]->nv;
+  m = (DP **)almat_pointer(n,n);
+  b0 = 0;
+  k = 0;
+  for ( i = 0; i < n; i++ ) {
+    // sp(ps[i],ps[j]) = ti*ps[i]-tj*ps[j] => m[i][j] = ti
+    for ( j = i+1; j < n; j++ ) m[i][j] = dpm_sp_hm(ps[i],ps[j]);
+    for ( j = i+1; j < n; j++ ) {
+      if ( !m[i][j] ) continue;
+      for ( h = m[i][j], k = i+1; k < n; k++ )
+        if ( k != j && m[i][k] && dp_redble(m[i][k],h) ) m[i][k] = 0;
+    }
+    for ( j = i+1; j < n; j++ ) {
+      if ( m[i][j] ) {
+        DPM quo1,nf1;
+        P dn1;
+
+        dpm_sp(ps[i],ps[j],&sp,&t1,&t2);
+        quo = dpm_nf_and_quotient4(sp,ps,psiv,0,&nf,&dn);
+        if ( nf ) 
+          error("dpm_schreyer_base : cannot happen");
+        NEWDMM(r0); r = r0; 
+        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);
+        mulp(CO,(P)BDY(t2)->c,dn,&c); chsgnp(c,(P *)&r->c); r->pos = j+1; r->dl = BDY(t2)->dl;
+        if ( quo ) {
+          for ( r1 = BDY(quo); r1; r1 = NEXT(r1) ) {
+            chsgnp((P)r1->c,&c); r1->c = (Obj)c;
+          }
+          NEXT(r) = BDY(quo);
+        } else
+          NEXT(r) = 0;
+        MKDPM(nv,r0,dpm); // XXX : sugar is not set
+        NEXTNODE(b0,b);
+        BDY(b) = (pointer)dpm;
+        k++;
+      }
+    }
+    if ( b0 ) NEXT(b) = 0;
+  }
+  for ( t0 = t, nd = BDY(g); nd; nd = NEXT(nd) ) {
+    dpm_ht((DPM)BDY(nd),&dpm); NEXTNODE(t0,t); BDY(t) = (pointer)dpm;
+  }
+  if ( t0 ) NEXT(t) = 0;
+  MKLIST(l,t0);
+  dmm_stack = push_schreyer_order(l,dmm_stack);
+//  for ( t = b0; t; t = NEXT(t) ) {
+//    dpm_sort((DPM)BDY(t),&dpm); 
+//    BDY(t) = (pointer)dpm;
+//  }
+//  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);
+//  print_eg("red",&egred); printf("\n");
+}
+#else
+void dpm_schreyer_base(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 **m;
+  NODE *psi;
+  NODE n1,n2,n3;
+  int p1,p2,p3;
+  struct oEGT eg0,eg1,egsp,egnf;
+  extern struct oEGT egred;
+
+  init_eg(&egra);
+  init_eg(&egsp);
+  init_eg(&egnf);
+  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 = (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;
+  m = (DP **)almat_pointer(n+1,n+1);
+  b0 = 0;
+  get_eg(&eg0);
+  for ( i = 1; i <= max; i++ ) {
+    for ( n1 = psi[i]; n1; n1 = NEXT(n1) ) {
+      p1 = (long)BDY(n1);
+      for ( n2 = NEXT(n1); n2; n2 = NEXT(n2) ) {
+        p2 = (long)BDY(n2);
+        m[p1][p2] = dpm_sp_hm(ps[p1],ps[p2]);
+      }
+    }
+    for ( n1 = psi[i]; n1; n1 = NEXT(n1) ) {
+      p1 = (long)BDY(n1);
+      for ( n2 = NEXT(n1); n2; n2 = NEXT(n2) ) {
+        p2 = (long)BDY(n2);
+        if ( !m[p1][p2] ) continue;
+        for ( h = m[p1][p2], n3 = NEXT(n1); n3; n3 = NEXT(n3) ) {
+          p3 = (long)BDY(n3);
+          if ( n3 != n2 && m[p1][p3] && dp_redble(m[p1][p3],h) ) m[p1][p3] = 0;
+        }
+      }
+    }
+  }
+  get_eg(&eg1); add_eg(&egsp,&eg0,&eg1); print_eg("SP",&egsp);
+  get_eg(&eg0);
+  for ( i = 1; i <= n; i++ ) {
+    for ( j = i+1; j <= n; j++ ) {
+      if ( m[i][j] ) {
+        quo = dpm_sp_nf(psv,psiv,i,j,&nf);
+        if ( nf ) 
+          error("dpm_schreyer_base : cannot happen");
+        NEXTNODE(b0,b); BDY(b) = (pointer)quo;
+      }
+    }
+  }
+  get_eg(&eg1); add_eg(&egnf,&eg0,&eg1); print_eg("NF",&egnf); printf("\n");
+  if ( b0 ) NEXT(b) = 0;
+  for ( t0 = t, nd = BDY(g); nd; nd = NEXT(nd) ) {
+    dpm_ht((DPM)BDY(nd),&dpm); NEXTNODE(t0,t); BDY(t) = (pointer)dpm;
+  }
+  if ( t0 ) NEXT(t) = 0;
+  MKLIST(l,t0);
+  dmm_stack = push_schreyer_order(l,dmm_stack);
+//  for ( t = b0; t; t = NEXT(t) ) {
+//    dpm_sort((DPM)BDY(t),&dpm); 
+//    BDY(t) = (pointer)dpm;
+//  }
+//    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);
+//  print_eg("red",&egred); printf("\n");
+}
+#endif
+
 int compdmm_schreyer(int n,DMM m1,DMM m2)
 {
    int pos1,pos2,t;
@@ -3153,26 +3367,40 @@ 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>>+...
 DPM dpm_eliminate_term(DPM a,DPM p,Obj c,int pos)
 {
   MP d0,d;
+  DL dl;
   DMM m;
   DP f;
-  DPM a1,p1,r;
+  DPM a1,p1,r,r1,dmy;
+  Z dmyz;
 
   if ( !a ) return 0;
   d0 = 0;
   for ( m = BDY(a); m; m = NEXT(m) )
     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_rank )
+        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 ) {
     NEXT(d) = 0; MKDP(NV(a),d0,f);
     mulcdpm(CO,c,a,&a1);
     mulobjdpm(CO,(Obj)f,p,&p1); 
     adddpm(CO,a1,p1,&r);
-    return r;
+    dpm_removecont2(0,r,&dmy,&r1,&dmyz);
+    return r1;
   } else
     return a;
 }
@@ -3198,14 +3426,15 @@ DPM dpm_compress(DPM p,int *tab)
 }
 
 // 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,k,pos,nv;
   DPM *am,*as;
   DPM p;
   DMM d;
   Obj c;
-  int *tab,*dd;
+  Z q;
+  int *tab,*dd,*new_w;
   NODE t,t1;
 
   lm = length(BDY(m));
@@ -3241,7 +3470,7 @@ void dpm_simplify_syz(LIST s,LIST m,LIST *s1,LIST *m1)
   tab = (int *)MALLOC((lm+1)*sizeof(int));
   for ( j = 0, i = 1; i <= lm; i++ ) {
     if ( am[i] ) { j++; tab[i] = j; }
-    else tab[i] = 0;
+    else { tab[i] = 0; }
   }
   t = 0;
   for ( i = ls-1; i >= 0; i-- )
@@ -3250,6 +3479,20 @@ void dpm_simplify_syz(LIST s,LIST m,LIST *s1,LIST *m1)
       MKNODE(t1,(pointer)p,t); t = t1;
     }
   MKLIST(*s1,t);
+
+  if ( dp_current_spec && dp_current_spec->module_rank ) {
+    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;
   for ( i = lm; i >= 1; i-- )
     if ( am[i] ) {