===================================================================
RCS file: /home/cvs/OpenXM/src/kan96xx/Kan/gradedset.c,v
retrieving revision 1.2
retrieving revision 1.9
diff -u -p -r1.2 -r1.9
--- OpenXM/src/kan96xx/Kan/gradedset.c	2000/01/16 07:55:38	1.2
+++ OpenXM/src/kan96xx/Kan/gradedset.c	2005/07/03 11:08:53	1.9
@@ -1,5 +1,6 @@
-/* $OpenXM$ */
+/* $OpenXM: OpenXM/src/kan96xx/Kan/gradedset.c,v 1.8 2005/06/30 08:35:07 takayama Exp $ */
 #include <stdio.h>
+#include <stdlib.h>
 #include "datatype.h"
 #include "extern2.h"
 #include "gradedset.h"
@@ -8,17 +9,22 @@
 static int Debug=0;
 
 struct polySet *newPolySet(n)
-int n;
+     int n;
 {
   struct polySet *g;
   int i;
   g = (struct polySet *)sGC_malloc(sizeof(struct polySet));
   g->g = (POLY *)sGC_malloc(sizeof(POLY)*(n+1));
+  g->gh = (POLY *)sGC_malloc(sizeof(POLY)*(n+1));
+  g->gmod = (POLY *)sGC_malloc(sizeof(POLY)*(n+1));
+  g->gen = (int *)sGC_malloc(sizeof(int)*(n+1));
   g->del = (int *)sGC_malloc(sizeof(int)*(n+1));
   g->syz = (struct syz0 **)sGC_malloc(sizeof(struct syz0 *)*(n+1));
   g->mark = (int *)sGC_malloc(sizeof(int)*(n+1));
   g->serial = (int *)sGC_malloc(sizeof(int)*(n+1));
   if (g->g == (POLY *)NULL || g->del == (int *)NULL ||
+      g->gh == (POLY *)NULL || g->gen == (int *)NULL ||
+      g->gmod == (POLY *)NULL ||
       g->syz == (struct syz0 **)NULL || g->mark == (int *)NULL ||
       g->serial == (int *)NULL) {
     errorGradedSet("No more memory.");
@@ -31,7 +37,7 @@ int n;
 }
 
 struct pair *newPair(prev)
-struct pair *prev;
+     struct pair *prev;
 {
   struct pair *g;
   int i;
@@ -47,7 +53,7 @@ struct pair *prev;
 }
 
 struct gradedPolySet *newGradedPolySet(n)
-int n;
+     int n;
 {
   struct gradedPolySet *g;
   g = (struct gradedPolySet *)sGC_malloc(sizeof(struct gradedPolySet));
@@ -57,11 +63,13 @@ int n;
     errorGradedSet("No more memory.");
   g->maxGrade = 0;
   g->lim = n;
+  g->gb = 0;
+  g->reduced = 0;
   return(g);
 }
 
 struct gradedPairs *newGradedPairs(n)
-int n;
+     int n;
 {
   struct gradedPairs *g;
   int i;
@@ -86,7 +94,7 @@ struct syz0 *newSyz0() {
 }
   
 struct pair *pairCopy(node)
-struct pair *node;
+     struct pair *node;
 {
   struct pair *r;
   r = newPair(node->prev);
@@ -95,8 +103,8 @@ struct pair *node;
 }
   
 struct gradedPairs *enlargeGradedPairs(size,grD)
-int size;
-struct gradedPairs *grD;
+     int size;
+     struct gradedPairs *grD;
 {
   struct gradedPairs *new;
   int i;
@@ -108,8 +116,8 @@ struct gradedPairs *grD;
 }
 
 void insertPair(inode,before)
-struct pair *inode;
-struct pair *before;
+     struct pair *inode;
+     struct pair *before;
 {
   struct pair *q;
   inode = pairCopy(inode);
@@ -125,7 +133,7 @@ struct pair *before;
 }
 
 struct pair *deletePair(p)
-struct pair *p;
+     struct pair *p;
 {
   struct pair *q;
   struct pair *r;
@@ -142,7 +150,7 @@ struct pair *p;
 }
 
 struct pair *getPair_org(grD)
-struct gradedPairs *grD;
+     struct gradedPairs *grD;
 {
   int gmax,i;
   struct pair *pair;
@@ -157,7 +165,7 @@ struct gradedPairs *grD;
 }
 
 struct pair *getPair(grD)
-struct gradedPairs *grD;
+     struct gradedPairs *grD;
 {
   int gmax,i;
   struct pair *pair;
@@ -171,11 +179,11 @@ struct gradedPairs *grD;
       minnode = node;
       node = node->next;
       while (node != (struct pair *)NULL) {
-	if ((*mmLarger)(minp,node->lcm) >= 1) {
-	  minnode = node;
-	  minp = minnode->lcm;
-	}
-	node = node->next;
+        if ((*mmLarger)(minp,node->lcm) >= 1) {
+          minnode = node;
+          minp = minnode->lcm;
+        }
+        node = node->next;
       }
       pair = deletePair(minnode->prev);
       return(pair);
@@ -184,17 +192,18 @@ struct gradedPairs *grD;
   return((struct pair *)NULL);
 }
 
+
 void whereInG(g,fi,gradep,indexp,sugar)
-struct gradedPolySet *g;
-POLY fi;
-int *gradep;
-int *indexp;
-int sugar;
+     struct gradedPolySet *g;
+     POLY fi;
+     int *gradep;
+     int *indexp;
+     int sugar;
 {
   if (sugar) {
     if (*gradep < 0 ) {
       /* if sugar and *gradep < 0, then compute the grade.
-	 Otherwise, grade is given by the caller. */
+         Otherwise, grade is given by the caller. */
       *gradep = grade_sugar(fi);
     }
   }else{
@@ -214,13 +223,13 @@ int sugar;
 }
 
 struct gradedPolySet *putPolyInG(g,fi,grade,index,syz,mark,serial)
-struct gradedPolySet *g;
-POLY fi;
-int grade;
-int index;
-struct syz0 *syz;
-int mark;
-int serial;
+     struct gradedPolySet *g;
+     POLY fi;
+     int grade;
+     int index;
+     struct syz0 *syz;
+     int mark;
+     int serial;
 {
   int i,j;
   struct polySet *polysNew;
@@ -228,7 +237,7 @@ int serial;
   struct polySet *ps;
 
   /*printf("--------------------\n");
-  outputGradedPolySet(g,0);*/
+    outputGradedPolySet(g,0);*/
 
   if (grade < 0) {
     warningGradedSet("putPolyInG(): the grade is -1. The element is ignored.");
@@ -245,6 +254,7 @@ int serial;
       gnew->polys[i] = newPolySet(INITSIZE);
     }
     gnew->maxGrade = g->maxGrade;
+    gnew->gb = g->gb; gnew->reduced = g->reduced;
     g = gnew;
   }
 
@@ -254,6 +264,9 @@ int serial;
     polysNew = newPolySet(index*2+1);
     for (i=0; i<g->polys[grade]->lim; i++) {
       polysNew->g[i] = g->polys[grade]->g[i];
+      polysNew->gh[i] = g->polys[grade]->gh[i];
+      polysNew->gmod[i] = g->polys[grade]->gmod[i];
+      polysNew->gen[i] = g->polys[grade]->gen[i];
       polysNew->del[i] = g->polys[grade]->del[i];
       polysNew->syz[i] = g->polys[grade]->syz[i];
       polysNew->mark[i] = g->polys[grade]->mark[i];
@@ -265,6 +278,9 @@ int serial;
   
   g->polys[grade]->size = index+1;
   g->polys[grade]->g[index] = fi;
+  g->polys[grade]->gh[index] = POLYNULL;
+  g->polys[grade]->gmod[index] = POLYNULL;
+  g->polys[grade]->gen[index] = 0;
   g->polys[grade]->del[index] = 0;
   g->polys[grade]->syz[index] = syz;
   g->polys[grade]->mark[index] = mark;
@@ -272,15 +288,15 @@ int serial;
   if (g->maxGrade < grade+1) g->maxGrade = grade+1;
 
   /*printf("grade=%d, index=%d\n",grade,index);
-  outputGradedPolySet(g,0);*/
+    outputGradedPolySet(g,0);*/
   return(g);
 }
 
 void markRedundant(g,fi,grade,index,sugar)
-struct gradedPolySet *g;
-POLY fi;
-int grade,index;
-int sugar;
+     struct gradedPolySet *g;
+     POLY fi;
+     int grade,index;
+     int sugar;
 {
   int i,j;
   struct polySet *ps;
@@ -293,15 +309,15 @@ int sugar;
     for (j=0; j<ps->size; j++) {
       if (i == grade && j == index) {
       }else if ((*isReducible)(ps->g[j],fi)) {
-	ps->del[j] = 1;
+		if (! ps->gen[j]) ps->del[j] = 1; /*?*/
       }
     }
   }
 }
 
 void markRedundant0(g,grade,index)
-struct gradedPolySet *g;
-int grade,index;
+     struct gradedPolySet *g;
+     int grade,index;
 {
   int i,j;
   struct polySet *ps;
@@ -314,17 +330,17 @@ int grade,index;
     for (j=0; j<ps->size; j++) {
       if (i == grade && j == index) {
       }else if ((*isReducible)(ps->g[j],fi)) {
-	ps->del[j] = 1;
+        if (! ps->gen[j] ) ps->del[j] = 1; /*?*/
       }else if ((*isReducible)(fi,ps->g[j])) {
-	g->polys[grade]->del[index] = 1;
-	return;
+        if (! g->polys[grade]->gen[index] ) g->polys[grade]->del[index] = 1; /*?*/
+        return;
       }
     }
   }
 }
 
 struct gradedPairs *putPairInGradedPairs(struct gradedPairs *grP,
-					 struct pair *top)
+                                         struct pair *top)
 {
   if (grP == (struct gradedPairs *)NULL) {
     grP = newGradedPairs(top->grade +1);
@@ -338,25 +354,26 @@ struct gradedPairs *putPairInGradedPairs(struct graded
 }
   
 void errorGradedSet(s)
-char *s;
+     char *s;
 {
   fprintf(stderr,"Error in gradedset.c, red.c, gb.c: %s\n",s);
   exit(23);
 }
 
 void warningGradedSet(s)
-char *s;
+     char *s;
 {
   fprintf(stderr,"Warning in gradedset.c, red.c, gb.c: %s\n",s);
 }
 
 
 void outputGradedPolySet(grG,needSyz)
-struct gradedPolySet *grG;
-int needSyz;
+     struct gradedPolySet *grG;
+     int needSyz;
 {
   int i,j;
   struct polySet *set;
+  extern Ecart;
   printf("======== gradedPolySet ==========\n");
   printf("maxGrade=%d\n",grG->maxGrade);
   for (i=0; i<grG->maxGrade; i++) {
@@ -364,13 +381,14 @@ int needSyz;
     printf("grade=%d, size=%d\n",i,set->size);
     for (j=0; j<set->size; j++) {
       printf("j=%d, del=%d, g=%s\n",j,set->del[j],POLYToString(set->g[j],'*',1));
+	  if (Ecart) printf("     gh=%s\n",POLYToString(set->gh[j],'*',1));
       if (needSyz) {
-	printf("mark=%d,serial=%d, syz.cf=%s, syz.syz=%s\n",set->mark[j],
-	       set->serial[j],POLYToString(set->syz[j]->cf,'*',1),
-	       POLYToString(set->syz[j]->syz,'*',1));
+        printf("mark=%d,serial=%d, syz.cf=%s, syz.syz=%s\n",set->mark[j],
+               set->serial[j],POLYToString(set->syz[j]->cf,'*',1),
+               POLYToString(set->syz[j]->syz,'*',1));
       }else{
-	printf("mark=%d,serial=%d\n",set->mark[j],
-	       set->serial[j]);
+        printf("mark=%d,serial=%d\n",set->mark[j],
+               set->serial[j]);
       }
     }
   }
@@ -378,7 +396,7 @@ int needSyz;
 }
 
 int countGradedPolySet(grG)
-struct gradedPolySet *grG;
+     struct gradedPolySet *grG;
 {
   int i,j;
   struct polySet *set;
@@ -392,7 +410,7 @@ struct gradedPolySet *grG;
 
 
 void outputGradedPairs(grP)
-struct gradedPairs *grP;
+     struct gradedPairs *grP;
 {
   int i,j;
   struct pair *pair;
@@ -412,7 +430,7 @@ struct gradedPairs *grP;
 }
 
 void outputNode(pair)
-struct pair *pair;
+     struct pair *pair;
 {
   int i = 0;
   printf("=== list === \n");
@@ -432,7 +450,7 @@ struct pair *pair;
 
 
 int countPairs(grD)
-struct gradedPairs *grD;
+     struct gradedPairs *grD;
 {
   int i;
   int c;
@@ -450,7 +468,7 @@ struct gradedPairs *grD;
 }
 
 struct gradedPolySet *gradedPolySetCopy(grG)
-struct gradedPolySet *grG;
+     struct gradedPolySet *grG;
 {
   int i,j;
   struct polySet *ps,*psOld;
@@ -474,7 +492,7 @@ struct gradedPolySet *grG;
 }
 
 int deletePairByCriterion2B(struct gradedPairs *grD,POLY gt,
-			    struct gradedPolySet *grG)
+                            struct gradedPolySet *grG)
 {
   int gmax,i;
   struct pair *node;
@@ -489,24 +507,41 @@ int deletePairByCriterion2B(struct gradedPairs *grD,PO
     if ((grD->pairs[i])->next != (struct pair *)NULL) {
       node = grD->pairs[i]->next;
       while (node != (struct pair *)NULL) {
-	ig = node->ig; ii = node->ii;
-	jg = node->jg; ji = node->ji;
-	if ((*isReducible)(node->lcm,gt)) {
-	  ig = node->ig; ii = node->ii;
-	  jg = node->jg; ji = node->ji;
-	  it = (*lcm)(grG->polys[ig]->g[ii],gt);
-	  ij = (*lcm)(grG->polys[ig]->g[ii],grG->polys[jg]->g[ji]);
-	  jt = (*lcm)(grG->polys[jg]->g[ji],gt);
-	  if ((*mmLarger)(it,ij) != 2 &&
-	      (*mmLarger)(it,jt) != 2 &&
-	      (*mmLarger)(ij,jt) != 2) {
-	    node = deletePair(node->prev);
-	    count++;
-	  }
-	}
-	node = node->next;
+        ig = node->ig; ii = node->ii;
+        jg = node->jg; ji = node->ji;
+        if ((*isReducible)(node->lcm,gt)) {
+          ig = node->ig; ii = node->ii;
+          jg = node->jg; ji = node->ji;
+          it = (*lcm)(grG->polys[ig]->g[ii],gt);
+          ij = (*lcm)(grG->polys[ig]->g[ii],grG->polys[jg]->g[ji]);
+          jt = (*lcm)(grG->polys[jg]->g[ji],gt);
+          if ((*mmLarger)(it,ij) != 2 &&
+              (*mmLarger)(it,jt) != 2 &&
+              (*mmLarger)(ij,jt) != 2) {
+            node = deletePair(node->prev);
+            count++;
+          }
+        }
+        node = node->next;
       }
     }
   }
   return(count);
+}
+
+int markGeneratorInG(struct gradedPolySet *g,int grade,int index)
+{
+  g->polys[grade]->gen[index] = 1;
+  return 1;
+}
+
+int clearGmod(struct gradedPolySet *gset) {
+  int grd,i;
+  struct polySet *set;
+  for (grd=0; grd < gset->maxGrade; grd++) {
+	set = gset->polys[grd];
+	for (i = 0; i<set->size; i++) {
+	  set->gmod[i] = POLYNULL;
+	}
+  }
 }