===================================================================
RCS file: /home/cvs/OpenXM/src/kan96xx/Kan/poly4.c,v
retrieving revision 1.1.1.1
retrieving revision 1.7
diff -u -p -r1.1.1.1 -r1.7
--- OpenXM/src/kan96xx/Kan/poly4.c	1999/10/08 02:12:02	1.1.1.1
+++ OpenXM/src/kan96xx/Kan/poly4.c	2003/07/19 06:03:57	1.7
@@ -1,3 +1,4 @@
+/* $OpenXM: OpenXM/src/kan96xx/Kan/poly4.c,v 1.6 2003/07/17 07:33:03 takayama Exp $ */
 #include <stdio.h>
 #include "datatype.h"
 #include "stackm.h"
@@ -10,17 +11,17 @@ static int degreeOfInitW(POLY f,int w[]);
 
 
 static void shell(v,n)
-int v[];
-int n;
+     int v[];
+     int n;
 {
   int gap,i,j,temp;
   
   for (gap = n/2; gap > 0; gap /= 2) {
     for (i = gap; i<n; i++) {
       for (j=i-gap ; j>=0 && v[j]<v[j+gap]; j -= gap) {
-	temp = v[j];
-	v[j] = v[j+gap];
-	v[j+gap] = temp;
+        temp = v[j];
+        v[j] = v[j+gap];
+        v[j+gap] = temp;
       }
     }
   }
@@ -28,8 +29,8 @@ int n;
 
 
 struct matrixOfPOLY *parts(f,v)
-POLY f;
-POLY v;  /* v must be a single variable, e.g. x */
+     POLY f;
+     POLY v;  /* v must be a single variable, e.g. x */
 {
   struct matrixOfPOLY *evPoly;
   int vi = 0;  /* index of v */
@@ -95,17 +96,17 @@ POLY v;  /* v must be a single variable, e.g. x */
     ft = f;
     while (ft != POLYNULL) {
       if (vx) {
-	if (ft->m->e[vi].x == ev[i]) {
-	  h = newCell(ft->coeffp,monomialCopy(ft->m));
-	  xset0(h,vi); /* touch monomial part, so you need to copy it above. */
-	  ans = ppAdd(ans,h);
-	}
+        if (ft->m->e[vi].x == ev[i]) {
+          h = newCell(ft->coeffp,monomialCopy(ft->m));
+          xset0(h,vi); /* touch monomial part, so you need to copy it above. */
+          ans = ppAdd(ans,h);
+        }
       }else{
-	if (ft->m->e[vi].D == ev[i]) {
-	  h = newCell(ft->coeffp,monomialCopy(ft->m));
-	  dset0(h,vi);
-	  ans = ppAdd(ans,h);
-	}
+        if (ft->m->e[vi].D == ev[i]) {
+          h = newCell(ft->coeffp,monomialCopy(ft->m));
+          dset0(h,vi);
+          ans = ppAdd(ans,h);
+        }
       }
       ft = ft->next;
     }
@@ -113,10 +114,10 @@ POLY v;  /* v must be a single variable, e.g. x */
   }
   return(evPoly);
 }
-	  
+      
 struct object parts2(f,v)
-POLY f;
-POLY v;  /* v must be a single variable, e.g. x */
+     POLY f;
+     POLY v;  /* v must be a single variable, e.g. x */
 {
   struct matrixOfPOLY *evPoly;
   int vi = 0;  /* index of v */
@@ -189,17 +190,17 @@ POLY v;  /* v must be a single variable, e.g. x */
     ft = f;
     while (ft != POLYNULL) {
       if (vx) {
-	if (ft->m->e[vi].x == ev[i]) {
-	  h = newCell(ft->coeffp,monomialCopy(ft->m));
-	  xset0(h,vi); /* touch monomial part, so you need to copy it above. */
-	  ans = ppAdd(ans,h);
-	}
+        if (ft->m->e[vi].x == ev[i]) {
+          h = newCell(ft->coeffp,monomialCopy(ft->m));
+          xset0(h,vi); /* touch monomial part, so you need to copy it above. */
+          ans = ppAdd(ans,h);
+        }
       }else{
-	if (ft->m->e[vi].D == ev[i]) {
-	  h = newCell(ft->coeffp,monomialCopy(ft->m));
-	  dset0(h,vi);
-	  ans = ppAdd(ans,h);
-	}
+        if (ft->m->e[vi].D == ev[i]) {
+          h = newCell(ft->coeffp,monomialCopy(ft->m));
+          dset0(h,vi);
+          ans = ppAdd(ans,h);
+        }
       }
       ft = ft->next;
     }
@@ -215,10 +216,10 @@ POLY v;  /* v must be a single variable, e.g. x */
   putoa(rob,0,ob1); putoa(rob,1,ob2);
   return(rob);
 }
-	  
+      
 int pDegreeWrtV(f,v)
-POLY f;
-POLY v;
+     POLY f;
+     POLY v;
 {
   int vx = 1;
   int vi = 0;
@@ -298,8 +299,8 @@ int containVectorVariable(POLY f)
 }
 
 POLY homogenize(f)
-POLY f;
-/* homogenize by using (*grade)(f) */
+     POLY f;
+     /* homogenize by using (*grade)(f) */
 {
   POLY t;
   int maxg;
@@ -330,13 +331,16 @@ POLY f;
 }
 
 int isHomogenized(f)
-POLY f;
+     POLY f;
 {
   POLY t;
   extern int Homogenize_vec;
   int maxg;
   if (!Homogenize_vec) return(isHomogenized_vec(f));
   if (f == ZERO) return(1);
+  if (f->m->ringp->weightedHomogenization) {
+	return 1; /* BUG: do not chech in case of one-zero homogenization */
+  }
   maxg = (*grade)(f);
   t = f;
   while (t != POLYNULL) {
@@ -347,18 +351,21 @@ POLY f;
 }
 
 int isHomogenized_vec(f)
-POLY f;
+     POLY f;
 {
-/* This is not efficient version. *grade should be grade_module1v(). */
+  /* This is not efficient version. *grade should be grade_module1v(). */
   POLY t;
   int ggg;
   if (f == ZERO) return(1);
+  if (f->m->ringp->weightedHomogenization) {
+	return 1; /* BUG: do not chech in case of one-zero homogenization */
+  }
   while (f != POLYNULL) {
     t = f;
     ggg = (*grade)(f);
     while (t != POLYNULL) {
       if ((*isSameComponent)(f,t)) {
-	if (ggg != (*grade)(t)) return(0);
+        if (ggg != (*grade)(t)) return(0);
       }
       t = t->next;
     }
@@ -369,7 +376,7 @@ POLY f;
 
 
 static int degreeOfPrincipalPart(f)
-POLY f;
+     POLY f;
 {
   int n,i,dd;
   if (f ISZERO) return(0);
@@ -382,7 +389,7 @@ POLY f;
 }
   
 POLY POLYToPrincipalPart(f)
-POLY f;
+     POLY f;
 {
   POLY node;
   struct listPoly nod;
@@ -411,8 +418,8 @@ POLY f;
 }
 
 static int degreeOfInitW(f,w)
-POLY f;
-int w[];
+     POLY f;
+     int w[];
 {
   int n,i,dd;
   if (f ISZERO) {
@@ -427,8 +434,8 @@ int w[];
 }
 
 POLY POLYToInitW(f,w)
-POLY f;
-int w[]; /* weight vector */
+     POLY f;
+     int w[]; /* weight vector */
 {
   POLY node;
   struct listPoly nod;
@@ -492,14 +499,30 @@ int isTheSameRing(struct ring *rstack[],int rp, struct
     if (rrr->orderMatrixSize != newRingp->orderMatrixSize) { a=12; goto bbb ; }
     for (i=0; i<rrr->orderMatrixSize; i++) {
       for (j=0; j<2*(rrr->n); j++) {
-	if (rrr->order[i*2*(rrr->n)+j] != newRingp->order[i*2*(rrr->n)+j])
-	  { a=13; goto bbb ; }
+        if (rrr->order[i*2*(rrr->n)+j] != newRingp->order[i*2*(rrr->n)+j])
+          { a=13; goto bbb ; }
       }
     }
     if (rrr->next != newRingp->next) { a=14; goto bbb ; }
     if (rrr->multiplication != newRingp->multiplication) { a=15; goto bbb ; }
     /* if (rrr->schreyer != newRingp->schreyer) { a=16; goto bbb ; }*/
     if (newRingp->schreyer == 1) { a=16; goto bbb; }
+    if (rrr->weightedHomogenization != newRingp->weightedHomogenization) { a=16; goto bbb; }
+    if (rrr->degreeShiftSize != newRingp->degreeShiftSize) {
+      a = 17; goto bbb;
+    }
+    if (rrr->degreeShiftN != newRingp->degreeShiftN) {
+      a = 17; goto bbb;
+    }
+    for (i=0; i < rrr->degreeShiftSize; i++) {
+      for (j=0; j< rrr->degreeShiftN; j++) {
+        if (rrr->degreeShift[i*(rrr->degreeShiftN)+j] !=
+            newRingp->degreeShift[i*(rrr->degreeShiftN)+j]) {
+          a = 17; goto bbb;
+        }
+      }
+    }
+
     /* The following fields are ignored. 
        void *gbListTower;
        int *outputOrder;
@@ -513,5 +536,164 @@ int isTheSameRing(struct ring *rstack[],int rp, struct
   }
   return(-1);
 }
-  
-  
+
+/* s->1 */  
+POLY goDeHomogenizeS(POLY f) {
+  POLY node;
+  POLY lastf;
+  struct listPoly nod;
+  POLY h;
+  POLY tf;
+  int gt,first;
+
+  if (f == POLYNULL) return(POLYNULL);
+  node = &nod;
+  node->next = POLYNULL;
+  lastf = POLYNULL;
+  first = 1;
+  while (f != POLYNULL) {
+    tf = newCell(f->coeffp,monomialCopy(f->m));
+    tf->m->e[0].x = 0;  /* H, s variable in the G-O paper. */
+    if (first) {
+      node->next = tf;
+      lastf = tf;
+      first = 0;
+    }else{
+      gt = (*mmLarger)(lastf,tf);
+      if (gt == 1) {
+        lastf->next = tf;
+        lastf = tf;
+      }else{
+        h = node->next;
+        h = ppAddv(h,tf);
+        node->next = h;
+        lastf = h;
+        while (lastf->next != POLYNULL) {
+          lastf = lastf->next;
+        }
+      }
+    }
+    f = f->next;
+  }
+  return (node->next);
+}  
+
+/* Granger-Oaku's homogenization for the ecart tangent cone.
+   Note: 2003.07.10.
+   ds[] is the degree shift.
+   ei ( element index ). If it is < 0, then e[n-1]->x will be used,
+                         else ei is used.
+   if onlyS is set to 1, then input is assumed to be (u,v)-h-homogeneous.
+*/
+POLY goHomogenize(POLY f,int u[],int v[],int ds[],int dssize,int ei,int onlyS)
+{
+  POLY node;
+  POLY lastf;
+  struct listPoly nod;
+  POLY h;
+  POLY tf;
+  int gt,first,m,mp,t,tp,dsIdx,message;
+  struct ring *rp;
+
+  message = 1;
+  if (f == POLYNULL) return(POLYNULL);
+  rp = f->m->ringp;
+  if ((rp->degreeShiftSize == 0) && (dssize > 0)) {
+	warningPoly("You are trying to homogenize a polynomial with degree shift. However, the polynomial belongs to the ring without degreeShift option. It may cause a trouble in comparison in free module.\n");
+  }
+  node = &nod;
+  node->next = POLYNULL;
+  lastf = POLYNULL;
+  first = 1;
+  while (f != POLYNULL) {
+    if (first) {
+      t = m = dGrade1(f);
+      tp = mp = uvGrade1(f,u,v,ds,dssize,ei);
+    }else{
+      t =  dGrade1(f);
+      tp = uvGrade1(f,u,v,ds,dssize,ei);
+      if (t > m) m = t;
+      if (tp < mp) mp = tp;
+    }
+
+    tf = newCell(f->coeffp,monomialCopy(f->m));
+	/* Automatic dehomogenize. Not +=  */
+	if (message && ((tf->m->e[0].D != 0) || (tf->m->e[0].x != 0))) {
+      /*go-debug fprintf(stderr,"Automatic dehomogenize and homogenize.\n"); */
+	  message = 0;
+	}
+	if (!onlyS) {
+	  tf->m->e[0].D = -t;  /* h */
+	}
+    tf->m->e[0].x = tp;  /* H, s variable in the G-O paper. */
+	/*go-debug printf("t(h)=%d, tp(uv+ds)=%d\n",t,tp); */
+    if (first) {
+      node->next = tf;
+      lastf = tf;
+      first = 0;
+    }else{
+      gt = (*mmLarger)(lastf,tf);
+      if (gt == 1) {
+        lastf->next = tf;
+        lastf = tf;
+      }else{
+        /*go-debug printf("?\n"); */
+        h = node->next;
+        h = ppAddv(h,tf);
+        node->next = h;
+        lastf = h;
+        while (lastf->next != POLYNULL) {
+          lastf = lastf->next;
+        }
+      }
+	}
+	f = f->next;
+  }
+  h = node->next;
+  /*go-debug printf("m=%d, mp=%d\n",m,mp); */
+  while (h != POLYNULL) {
+    /*go-debug printf("Old: h=%d, s=%d\n",h->m->e[0].D,h->m->e[0].x); */
+    if (!onlyS) h->m->e[0].D += m;   /* h */
+    h->m->e[0].x += -mp; /* H, s*/
+    /*go-debug printf("New: h=%d, s=%d\n",h->m->e[0].D,h->m->e[0].x); */
+    h = h->next;
+  }
+  return (node->next);
+}  
+
+/* u[] = -1, v[] = 1 */
+POLY goHomogenize11(POLY f,int ds[],int dssize,int ei,int onlyS)
+{
+  int r;
+  int i,t,n,m,nn;
+  MONOMIAL tf;
+  static int *u;
+  static int *v;
+  static struct ring *cr = (struct ring *)NULL;
+
+  if (f == POLYNULL) return POLYNULL;
+
+  tf = f->m;
+  if (tf->ringp != cr) {
+    n = tf->ringp->n;
+    m = tf->ringp->m;
+    nn = tf->ringp->nn;
+    cr = tf->ringp;
+	u = (int *)sGC_malloc(sizeof(int)*n);
+	v = (int *)sGC_malloc(sizeof(int)*n);
+	for (i=0; i<n; i++) u[i]=v[i]=0;
+	for (i=m; i<nn; i++) {
+	  u[i] = -1; v[i] = 1;
+	}
+  }
+  return(goHomogenize(f,u,v,ds,dssize,ei,onlyS));
+}
+
+POLY goHomogenize_dsIdx(POLY f,int u[],int v[],int dsIdx,int ei,int onlyS)
+{
+  if (f == POLYNULL) return POLYNULL;
+}
+POLY goHomogenize11_dsIdx(POLY f,int ds[],int dsIdx,int ei,int onlyS)
+{
+  if (f == POLYNULL) return POLYNULL;
+}