===================================================================
RCS file: /home/cvs/OpenXM_contrib2/asir2018/engine/dist.c,v
retrieving revision 1.4
retrieving revision 1.8
diff -u -p -r1.4 -r1.8
--- OpenXM_contrib2/asir2018/engine/dist.c	2019/09/04 01:12:02	1.4
+++ OpenXM_contrib2/asir2018/engine/dist.c	2019/09/13 02:04:42	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/engine/dist.c,v 1.3 2019/08/21 00:37:47 noro Exp $
+ * $OpenXM: OpenXM_contrib2/asir2018/engine/dist.c,v 1.7 2019/09/06 00:11:59 noro Exp $
 */
 #include "ca.h"
 
@@ -2635,12 +2635,13 @@ NBP harmonic_mul_nbm(NBM a,NBM b)
 /* DPM functions */
 
 DMMstack dmm_stack;
+extern LIST schreyer_obj;
 
 void push_schreyer_order(LIST data)
 {
   DMMstack t;
   int len,i;
-  NODE in;
+  NODE in,t1;
 
   /* data = [DPM,...,DPM] */
   in = BDY(data);
@@ -2655,9 +2656,10 @@ void push_schreyer_order(LIST data)
   t->next = dmm_stack;
   dmm_stack = t; 
   dpm_ordtype = 2;
+  MKNODE(t1,data,schreyer_obj?BDY(schreyer_obj):0);
+  MKLIST(schreyer_obj,t1);
 }
 
-
 // data=[Ink,...,In0]
 // Ini = a list of module monomials
 
@@ -2714,8 +2716,8 @@ NODE dpm_reduceall(NODE in)
   for ( i = 0, t = in; i < n; i++, t = NEXT(t) ) ps[i] = BDY(t);
   for ( i = 0; i < n; i++ ) {
     g = ps[i]; ps[i] = 0;
-    dpm_nf_z(0,g,psv,1,DP_Multiple,&r);
-    ps[i] = r;
+//    dpm_nf_z(0,g,psv,1,DP_Multiple,&ps[i]);
+    dpm_nf_z(0,g,psv,1,0,&ps[i]);
   }
   t = 0;
   for ( i = n-1; i >= 0; i-- ) {
@@ -2725,6 +2727,8 @@ NODE dpm_reduceall(NODE in)
   return t;
 }
 
+struct oEGT egra;
+
 void dpm_schreyer_base(LIST g,LIST *s)
 {
   NODE nd,t,b0,b;
@@ -2738,11 +2742,10 @@ void dpm_schreyer_base(LIST g,LIST *s)
   DPM *ps;
   VECT psv;
   DP **m,*quo;
-  struct oEGT eg_nf,eg0,eg1;
-  extern struct oEGT egc,egcomp;
+  struct oEGT eg0,eg1;
+  extern struct oEGT egred;
 
-//  init_eg(&eg_nf);
-//  init_eg(&egcomp);
+  init_eg(&egra);
   nd = BDY(g);
   n = length(nd);
   MKVECT(psv,n);
@@ -2751,12 +2754,10 @@ void dpm_schreyer_base(LIST g,LIST *s)
   nv = ps[0]->nv;
   m = (DP **)almat_pointer(n,n);
   b0 = 0;
-//  init_eg(&egc);
   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++ ) {
-//    for ( j = n-1; j > i; 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;
@@ -2764,9 +2765,7 @@ void dpm_schreyer_base(LIST g,LIST *s)
     for ( j = i+1; j < n; j++ ) {
       if ( m[i][j] ) {
         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(&eg_nf,&eg0,&eg1);
         if ( nf ) 
           error("dpm_schreyer_base : cannot happen");
         NEWDMM(r0); r = r0; 
@@ -2795,10 +2794,11 @@ void dpm_schreyer_base(LIST g,LIST *s)
     BDY(t) = (pointer)dpm;
   }
   b0 = dpm_sort_list(b0);
-//  b0 = dpm_reduceall(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("nf",&eg_nf); printf("\n");
-//  print_eg("coef",&egc); printf("\n");
+//  print_eg("red",&egred); printf("\n");
 }
 
 int compdmm_schreyer(int n,DMM m1,DMM m2)
@@ -2965,6 +2965,26 @@ void chsgndpm(DPM p,DPM *pr)
   }
 }
 
+void mulcmp(Obj c,MP m)
+{
+  MP t;
+  Obj c1;
+
+  for ( t = m; t; t = NEXT(t) ) {
+    arf_mul(CO,c,C(t),&c1); C(t) = c1;
+  }
+}
+
+void mulcdmm(Obj c,DMM m)
+{
+  DMM t;
+  Obj c1;
+
+  for ( t = m; t; t = NEXT(t) ) {
+    arf_mul(CO,c,C(t),&c1); C(t) = c1;
+  }
+}
+
 void mulcdpm(VL vl,Obj c,DPM p,DPM *pr)
 {
   DMM m,mr=0,mr0;
@@ -3119,3 +3139,102 @@ int compdpm(VL vl,DPM p1,DPM p2)
   }
 }
 
+// p = ...+c*<<0,...0:pos>>+...
+DPM dpm_eliminate_term(DPM a,DPM p,Obj c,int pos)
+{
+  MP d0,d;
+  DMM m;
+  DP f;
+  DPM a1,p1,r;
+
+  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);
+    }
+  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;
+  } else
+    return a;
+}
+
+// <<...:i>> -> <<...:tab[i]>>
+DPM dpm_compress(DPM p,int *tab)
+{
+  DMM m,mr0,mr;
+  DPM t;
+
+  if ( !p ) return 0;
+  else {
+    for ( m = BDY(p), mr0 = 0; m; m = NEXT(m) ) {
+      NEXTDMM(mr0,mr);
+      mr->dl = m->dl; mr->c = m->c; mr->pos = tab[m->pos];
+      if ( mr->pos <= 0 )
+        error("dpm_compress : invalid position");
+    }
+    NEXT(mr) = 0;
+    MKDPM(p->nv,mr0,t); t->sugar = p->sugar;
+    return t;
+  }
+}
+
+// input : s, s = syz(m) output simplified s, m
+void dpm_simplify_syz(LIST s,LIST m,LIST *s1,LIST *m1)
+{
+  int lm,ls,i,j,pos;
+  DPM *am,*as;
+  DPM p;
+  DMM d;
+  Obj c;
+  int *tab;
+  NODE t,t1;
+
+  lm = length(BDY(m));
+  am = (DPM *)MALLOC((lm+1)*sizeof(DPM));
+  ls = length(BDY(s));
+  as = (DPM *)MALLOC(ls*sizeof(DPM));
+  for ( i = 1, t = BDY(m); i <= lm; i++, t = NEXT(t) ) am[i] = (DPM)BDY(t);
+  for ( i = 0, t = BDY(s); i < ls; i++, t = NEXT(t) ) as[i] = (DPM)BDY(t);
+
+  for ( i = 0; i < ls; i++ ) {
+    p = as[i];
+    if ( p == 0 ) continue;
+    for ( d = BDY(p); d; d = NEXT(d) ) if ( d->dl->td == 0 ) break;
+    if ( d ) {
+      c = d->c; pos = d->pos;
+      for ( j = 0; j < ls; j++ )
+        if ( j != i ) {
+          as[j] = dpm_eliminate_term(as[j],p,c,pos);
+        }
+      // remove m[i]
+      am[pos] = 0;
+      as[i] = 0;
+    }
+  }
+  // compress s
+  // create index table from am[]
+  // (0 0 * 0 * ...) -> (0 0 1 0 2 ... ) which means 2->1, 4->2, ...
+  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;
+  }
+  t = 0;
+  for ( i = ls-1; i >= 0; i-- )
+    if ( as[i] ) {
+      p = dpm_compress(as[i],tab);
+      MKNODE(t1,(pointer)p,t); t = t1;
+    }
+  MKLIST(*s1,t);
+  t = 0;
+  for ( i = lm; i >= 1; i-- )
+    if ( am[i] ) {
+      MKNODE(t1,(pointer)am[i],t); t = t1;
+    }
+  MKLIST(*m1,t);
+}