===================================================================
RCS file: /home/cvs/OpenXM/src/kan96xx/Kan/kanExport1.c,v
retrieving revision 1.7
retrieving revision 1.20
diff -u -p -r1.7 -r1.20
--- OpenXM/src/kan96xx/Kan/kanExport1.c	2003/08/22 11:47:03	1.7
+++ OpenXM/src/kan96xx/Kan/kanExport1.c	2005/06/16 08:40:04	1.20
@@ -1,4 +1,4 @@
-/* $OpenXM: OpenXM/src/kan96xx/Kan/kanExport1.c,v 1.6 2003/08/21 12:28:57 takayama Exp $ */
+/* $OpenXM: OpenXM/src/kan96xx/Kan/kanExport1.c,v 1.19 2005/06/16 06:54:55 takayama Exp $ */
 #include <stdio.h>
 #include "datatype.h"
 #include "stackm.h"
@@ -12,9 +12,12 @@
 static int Message = 1;
 extern int KanGBmessage;
   
-struct object DegreeShifto;
+struct object DegreeShifto = OINIT;
 int DegreeShifto_size = 0;
 int *DegreeShifto_vec = NULL;
+struct object DegreeShiftD = OINIT;
+int DegreeShiftD_size = 0;
+int *DegreeShiftD_vec = NULL;
 
 /** :kan, :ring */
 struct object Kreduction(f,set)
@@ -24,7 +27,7 @@ struct object Kreduction(f,set)
   POLY r;
   struct gradedPolySet *grG;
   struct syz0 syz;
-  struct object rob;
+  struct object rob = OINIT;
   int flag;
   extern int ReduceLowerTerms;
   
@@ -67,36 +70,40 @@ struct object Kgroebner(ob)
   int needInput = 0;
   int countDown = 0;
   int cdflag = 0;
-  struct object ob1,ob2,ob2c;
+  struct object ob1 = OINIT;
+  struct object ob2 = OINIT;
+  struct object ob2c = OINIT;
   int i;
   struct gradedPolySet *grG;
   struct pair *grP;
   struct arrayOfPOLY *a;
-  struct object rob;
+  struct object rob = OINIT;
   struct gradedPolySet *grBases;
   struct matrixOfPOLY *mp;
   struct matrixOfPOLY *backwardMat;
-  struct object ob1New;
+  struct object ob1New = OINIT;
   extern char *F_groebner;
   extern int CheckHomogenization;
   extern int StopDegree;
   int sdflag = 0;
   int forceReduction = 0;
+  int reduceOnly = 0;
+  int gbCheck = 0;  /* see @s/2005/06/16-note.pdf */
 
   int ob1Size, ob2Size, noZeroEntry;
   int *ob1ToOb2;
   int *ob1ZeroPos;
   int method;
   int j,k;
-  struct object rob2;
-  struct object rob3;
-  struct object rob4;
+  struct object rob2 = OINIT;
+  struct object rob3 = OINIT;
+  struct object rob4 = OINIT;
   struct ring *myring;
   POLY f;
-  struct object orgB;
-  struct object newB;
-  struct object orgC;
-  struct object newC;
+  struct object orgB = OINIT;
+  struct object newB = OINIT;
+  struct object orgC = OINIT;
+  struct object newC = OINIT;
   static struct object paddingVector(struct object ob, int table[], int m);
   static struct object unitVector(int pos, int size,struct ring *r);
   extern struct ring *CurrentRingp;
@@ -115,6 +122,7 @@ struct object Kgroebner(ob)
     if (ob2.tag != Sarray) {
       errorKan1("%s\n","Kgroebner(): The options must be given by an array.");
     }
+    /* Note: If you add a new option, change /configureGroebnerOption, too */
     for (i=0; i<getoaSize(ob2); i++) {
       ob2c = getoa(ob2,i);
       if (ob2c.tag == Sdollar) {
@@ -127,6 +135,10 @@ struct object Kgroebner(ob)
           needSyz = needBack = 1;
         }else if (strcmp(ob2c.lc.str,"forceReduction")==0) {
           forceReduction = 1;
+        }else if (strcmp(ob2c.lc.str,"reduceOnly")==0) {
+          reduceOnly = 1;
+        }else if (strcmp(ob2c.lc.str,"gbCheck")==0) {
+          gbCheck = 1;
         }else if (strcmp(ob2c.lc.str,"countDown")==0) {
           countDown = 1; cdflag = 1;
           if (needSyz) {
@@ -231,8 +243,8 @@ struct object Kgroebner(ob)
   }
   /* Assume ob1Size , ob2Size > 0 */
   ob2 = newObjectArray(ob2Size);
-  ob1ToOb2 =   (int *)GC_malloc(sizeof(int)*ob1Size);
-  ob1ZeroPos = (int *)GC_malloc(sizeof(int)*(ob1Size-ob2Size+1));
+  ob1ToOb2 =   (int *)sGC_malloc(sizeof(int)*ob1Size);
+  ob1ZeroPos = (int *)sGC_malloc(sizeof(int)*(ob1Size-ob2Size+1));
   if (ob1ToOb2 == NULL || ob1ZeroPos == NULL) errorKan1("%s\n","No more memory.");
   j = 0; k = 0;
   for (i=0; i<ob1Size; i++) {
@@ -248,7 +260,7 @@ struct object Kgroebner(ob)
   }
 
   a = arrayToArrayOfPOLY(ob2);
-  grG = (*groebner)(a,needBack,needSyz,&grP,countDown,forceReduction);
+  grG = (*groebner)(a,needBack,needSyz,&grP,countDown,forceReduction,reduceOnly,gbCheck);
 
   if (strcmp(F_groebner,"gm") == 0 && (needBack || needSyz)) {
     warningKan("The options needBack and needSyz are ignored.");
@@ -271,6 +283,7 @@ struct object Kgroebner(ob)
       fflush(stdout);
     }
     mp = getSyzygy(grG,grP->next,&grBases,&backwardMat);
+	if (mp == NULL) errorKan1("%s\n","Internal error in getSyzygy(). BUG of sm1.");
     if (KanGBmessage) printf("Done.\n");
 
     putoa(rob,0,gradedPolySetToArray(grG,0));
@@ -292,6 +305,8 @@ struct object Kgroebner(ob)
   }
 
   /* To handle zero entries in the input. */
+  rob=KsetAttribute(rob,KpoString("gb"),KpoInteger(grG->gb));
+  putoa(rob,0,KsetAttribute(getoa(rob,0),KpoString("gb"),KpoInteger(grG->gb)));
   if (noZeroEntry) {
     return(rob);
   }
@@ -309,6 +324,7 @@ struct object Kgroebner(ob)
     rob2 = newObjectArray(2);
     putoa(rob2,0,getoa(rob,0));
     putoa(rob2,1,newB);
+    rob2=KsetAttribute(rob2,KpoString("gb"),KpoInteger(grG->gb));
     return(rob2);
     break;
   case 3:
@@ -329,6 +345,7 @@ struct object Kgroebner(ob)
     putoa(rob2,0,getoa(rob,0));
     putoa(rob2,1,newB);
     putoa(rob2,2,newC);
+    rob2=KsetAttribute(rob2,KpoString("gb"),KpoInteger(grG->gb));
     return(rob2);
     break;
   default:
@@ -338,7 +355,7 @@ struct object Kgroebner(ob)
 
 static struct object paddingVector(struct object ob, int table[], int m)
 {
-  struct object rob;
+  struct object rob = OINIT;
   int i;
   rob = newObjectArray(m);
   for (i=0; i<m; i++) {
@@ -353,7 +370,7 @@ static struct object paddingVector(struct object ob, i
   
 static struct object unitVector(int pos, int size,struct ring *r)
 {
-  struct object rob;
+  struct object rob = OINIT;
   int i;
   POLY one;
   rob = newObjectArray(size);
@@ -408,7 +425,7 @@ struct object polySetToArray(ps,keepRedundant)
      int keepRedundant;
 {
   int n,i,j;
-  struct object ob;
+  struct object ob = OINIT;
   if (ps == (struct polySet *)NULL) return(newObjectArray(0));
   n = 0;
   if (keepRedundant) {
@@ -434,7 +451,8 @@ struct object gradedPolySetToGradedArray(gps,keepRedun
      struct gradedPolySet *gps;
      int keepRedundant;
 {
-  struct object ob,vec;
+  struct object ob = OINIT;
+  struct object vec = OINIT;
   int i;
   if (gps == (struct gradedPolySet *)NULL) return(NullObject);
   ob = newObjectArray(gps->maxGrade +1);
@@ -452,7 +470,8 @@ struct object gradedPolySetToArray(gps,keepRedundant)
      struct gradedPolySet *gps;
      int keepRedundant;
 {
-  struct object ob,vec;
+  struct object ob = OINIT;
+  struct object vec = OINIT;
   struct polySet *ps;
   int k;
   int i,j;
@@ -491,7 +510,7 @@ struct object syzPolyToArray(size,f,grG)
      POLY f;
      struct gradedPolySet *grG;
 {
-  struct object ob;
+  struct object ob = OINIT;
   int i,g0,i0,serial;
 
   ob = newObjectArray(size);
@@ -521,7 +540,7 @@ struct object getBackwardArray(grG)
   /* use serial, del.  cf. getBackwardTransformation(). */
   int inputSize,outputSize;
   int i,j,k;
-  struct object ob;
+  struct object ob = OINIT;
   struct polySet *ps;
   
   inputSize = 0; outputSize = 0;
@@ -552,7 +571,7 @@ POLY arrayToPOLY(ob)
      struct object ob;
 {
   int size,i;
-  struct object f;
+  struct object f = OINIT;
   POLY r;
   static int nn,mm,ll,cc,n,m,l,c;
   static struct ring *cr = (struct ring *)NULL;
@@ -601,7 +620,7 @@ struct object POLYToArray(ff)
   int k,i,matn,size;
   struct matrixOfPOLY *mat;
   POLY ex,sizep;
-  struct object ob;
+  struct object ob = OINIT;
 
   if (ff != ZERO) {
     tf = ff->m;
@@ -661,7 +680,8 @@ struct object homogenizeObject(ob,gradep)
      struct object ob;
      int *gradep;
 {
-  struct object rob,ob1;
+  struct object rob = OINIT;
+  struct object ob1 = OINIT;
   int maxg;
   int gr,flag,i,d,size;
   struct ring *rp;
@@ -727,7 +747,8 @@ struct object homogenizeObject_vec(ob,gradep)
      struct object ob;
      int *gradep;
 {
-  struct object rob,ob1;
+  struct object rob = OINIT;
+  struct object ob1 = OINIT;
   int maxg;
   int gr,i,size;
   POLY f;
@@ -771,17 +792,46 @@ struct object homogenizeObject_vec(ob,gradep)
   }
 }
 
+void KresetDegreeShift() {
+  DegreeShifto = NullObject;
+  DegreeShifto_vec = (int *)NULL;
+  DegreeShifto_size = 0;
+  DegreeShiftD = NullObject;
+  DegreeShiftD_vec = (int *)NULL;
+  DegreeShiftD_size = 0;
+}
+
 struct object homogenizeObject_go(struct object ob,int *gradep) {
   int size,i,dssize,j;
-  struct object ob0;
-  struct object ob1;
-  struct object ob2;
-  struct object rob;
-  struct object tob;
-  struct object ob1t;
+  struct object ob0 = OINIT;
+  struct object ob1 = OINIT;
+  struct object ob2 = OINIT;
+  struct object rob = OINIT;
+  struct object tob = OINIT;
+  struct object ob1t = OINIT;
   int *ds;
   POLY f;
+  int onlyS; 
+
+  onlyS = 0;  /* default value */
   rob = NullObject;
+  /*printf("[%d,%d]\n",DegreeShiftD_size,DegreeShifto_size);*/
+  if (DegreeShifto_size == 0) DegreeShifto = NullObject;
+  if (DegreeShiftD_size == 0) DegreeShiftD = NullObject;
+  /*
+      DegreeShiftD : Degree shift vector for (0,1)-h-homogenization,
+                     which is {\vec n} in G-O paper.
+                     It is used in dGrade1()  redm.c
+      DegreeShifto : Degree shift vector for (u,v)-s-homogenization
+                     which is used only in ecart division and (u,v) is
+                     usually (-1,1).
+                     This shift vector is written {\vec v} in G-O paper.
+                     It may differ from the degree shift for the ring,
+                     which is used to get (minimal) Schreyer resolution.
+                     This shift vector is denoted by {\vec m} in G-O paper.  
+                     It is often used as an argument for uvGrade1 and
+                     goHomogenize*
+   */
   if (ob.tag != Sarray) errorKan1("%s\n","homogenizeObject_go(): Invalid argument data type.");
 
   size = getoaSize(ob);
@@ -792,47 +842,76 @@ struct object homogenizeObject_go(struct object ob,int
   }
   if (strcmp(KopString(ob0),"degreeShift") == 0) {
     if (size < 2)
-      errorKan1("%s\n","homogenizeObject_go(): [(degreeShift) shift-vector obj] or [(degreeShift) shift-vector] or [(degreeShift) (value)] homogenize");
+      errorKan1("%s\n","homogenizeObject_go(): [(degreeShift) shift-vector obj] or [(degreeShift) shift-vector] or [(degreeShift) (value)] homogenize.\nshift-vector=(0,1)-shift vector or [(0,1)-shift vector, (u,v)-shift vector].");
     ob1 = getoa(ob,1);
 	if (ob1.tag != Sarray) {
-	  if (DegreeShifto_size != 0) {
-		return DegreeShifto;
-	  }else{
-        rob = NullObject;
-        return rob;
+	  if ((ob1.tag == Sdollar) && (strcmp(KopString(ob1),"value")==0)) {
+        /* Reporting the value. It is done below. */
+	  }else if ((ob1.tag == Sdollar) && (strcmp(KopString(ob1),"reset")==0)) {
+		KresetDegreeShift();
 	  }
+	  rob = newObjectArray(2);
+	  putoa(rob,0,DegreeShiftD);
+	  putoa(rob,1,DegreeShifto);
+	  return rob;
 	}
-    dssize = getoaSize(ob1);
-    ds = (int *)sGC_malloc(sizeof(int)*(dssize>0?dssize:1));
-    for (i=0; i<dssize; i++) {
-      ds[i] = objToInteger(getoa(ob1,i));
-    }
-    if (size == 2) {
-      DegreeShifto = ob1;
+
+	if (getoaSize(ob1) == 2) {
+	  /* [(degreeShift) [ [1 2]   [3 4] ]  ...] homogenize */
+      /*                  (0,1)-h (u,v)-s                  */
+	  DegreeShiftD = getoa(ob1,0);
+	  dssize = getoaSize(DegreeShiftD);
+	  ds = (int *)sGC_malloc(sizeof(int)*(dssize>0?dssize:1));
+	  if (ds == NULL) errorKan1("%s\n","no more memory.");
+	  for (i=0; i<dssize; i++) {
+		ds[i] = objToInteger(getoa(DegreeShiftD,i));
+	  }
+      DegreeShiftD_size = dssize;
+	  DegreeShiftD_vec = ds;
+
+	  DegreeShifto = getoa(ob1,1);
+	  dssize = getoaSize(DegreeShifto);
+	  ds = (int *)sGC_malloc(sizeof(int)*(dssize>0?dssize:1));
+	  if (ds == NULL) errorKan1("%s\n","no more memory.");
+	  for (i=0; i<dssize; i++) {
+		ds[i] = objToInteger(getoa(DegreeShifto,i));
+	  }
       DegreeShifto_size = dssize;
-      DegreeShifto_vec = ds;
-      rob = ob1;
+	  DegreeShifto_vec = ds;
+	}else if (getoaSize(ob1) == 1) {
+	  /* Set only  for (0,1)-h */
+	  DegreeShiftD = getoa(ob1,0);
+	  dssize = getoaSize(DegreeShiftD);
+	  ds = (int *)sGC_malloc(sizeof(int)*(dssize>0?dssize:1));
+	  if (ds == NULL) errorKan1("%s\n","no more memory.");
+	  for (i=0; i<dssize; i++) {
+		ds[i] = objToInteger(getoa(DegreeShiftD,i));
+	  }
+      DegreeShiftD_size = dssize;
+	  DegreeShiftD_vec = ds;
+	}
+
+	ds = DegreeShifto_vec;
+	dssize = DegreeShifto_size;
+
+    if (size == 2) {
+	  rob = newObjectArray(2);
+	  putoa(rob,0,DegreeShiftD);
+	  putoa(rob,1,DegreeShifto);
+	  return rob;
     }else{
       ob2 = getoa(ob,2);
       if (ob2.tag == Spoly) {
-        f = goHomogenize11(KopPOLY(ob2),ds,dssize,-1,0);
+        f = goHomogenize11(KopPOLY(ob2),ds,dssize,-1,onlyS);
         rob = KpoPOLY(f);
       }else if (ob2.tag == SuniversalNumber) {
         rob = ob2;
       }else if (ob2.tag == Sarray) {
-        rob = newObjectArray(getoaSize(ob2));
-        for (i=0; i<getoaSize(ob2); i++) {
-          tob = newObjectArray(3);
-          ob1t = newObjectArray(dssize);
-          if (getoa(ob2,i).tag == Spoly) {
-            for (j=0; j<dssize; j++) getoa(ob1t,j) = KpoInteger(0);
-            for (j=0; j<dssize-i; j++) getoa(ob1t,j) = getoa(ob1,j+i);
-          }else{
-            ob1t = ob1;
-          }
-          getoa(tob,0) = ob0; getoa(tob,1) = ob1t; getoa(tob,2) = getoa(ob2,i);
-          getoa(rob,i) = homogenizeObject_go(tob,gradep);
-        }
+		int mm;
+		mm = getoaSize(ob2);
+		f = objArrayToPOLY(ob2);
+        f = goHomogenize11(f,ds,dssize,-1,onlyS);
+        rob = POLYtoObjArray(f,mm);
       }else{
         errorKan1("%s\n","homogenizeObject_go(): invalid object for the third element.");
       }
@@ -903,7 +982,7 @@ struct object oPrincipalPart(ob)
      struct object ob;
 {
   POLY f;
-  struct object rob;
+  struct object rob = OINIT;
 
   switch(ob.tag) {
   case Spoly:
@@ -920,12 +999,12 @@ struct object oInitW(ob,oWeight)
      struct object oWeight;
 {
   POLY f;
-  struct object rob;
+  struct object rob = OINIT;
   int w[2*N0];
   int n,i;
-  struct object ow;
+  struct object ow = OINIT;
   int shiftvec;
-  struct object oShift;
+  struct object oShift = OINIT;
   int *s;
   int ssize,m;
 
@@ -935,8 +1014,14 @@ struct object oInitW(ob,oWeight)
   if (oWeight.tag != Sarray) {
     errorKan1("%s\n","oInitW(): the second argument must be array.");
   }
+  oWeight = Kto_int32(oWeight);
   n = getoaSize(oWeight);
-  if (n == 0)  errorKan1("%s\n","oInitW(): the size of the second argument is invalid.");
+  if (n == 0) {
+	m = getoaSize(ob);
+	f = objArrayToPOLY(ob);
+	f = head(f);
+    return POLYtoObjArray(f,m);
+  }
   if (getoa(oWeight,0).tag == Sarray) {
 	if (n != 2) errorKan1("%s\n","oInitW(): the size of the second argument should be 2.");
 	shiftvec = 1;
@@ -1023,6 +1108,7 @@ POLY objArrayToPOLY(struct object ob) {
       if (ringp == NULL) {
         ringp = t->m->ringp;
         n = ringp->n;
+		if (n - ringp->nn <= 0) errorKan1("%s\n","Graduation variable in D is not given.");
       }
       t = (*mpMult)(cxx(1,n-1,i,ringp),t);
       f = ppAddv(f,t);
@@ -1032,7 +1118,7 @@ POLY objArrayToPOLY(struct object ob) {
 }
 
 struct object POLYtoObjArray(POLY f,int size) {
-  struct object rob;
+  struct object rob = OINIT;
   POLY *pa;
   int d,n,i;
   POLY t;
@@ -1051,7 +1137,7 @@ struct object POLYtoObjArray(POLY f,int size) {
   while (f != POLYNULL) {
     d = f->m->e[n-1].x;
     if (d >= size) errorKan1("%s\n","POLYtoObjArray() size is too small.");
-    t = newCell(f->coeffp,monomialCopy(f->m));
+    t = newCell(coeffCopy(f->coeffp),monomialCopy(f->m));
 	i = t->m->e[n-1].x;
     t->m->e[n-1].x = 0;
     pa[i] = ppAddv(pa[i],t); /* slow to add from the top. */
@@ -1063,7 +1149,100 @@ struct object POLYtoObjArray(POLY f,int size) {
   return rob;
 }
 
+struct object KordWsAll(ob,oWeight)
+     struct object ob;
+     struct object oWeight;
+{
+  POLY f;
+  struct object rob = OINIT;
+  int w[2*N0];
+  int n,i;
+  struct object ow = OINIT;
+  int shiftvec;
+  struct object oShift = OINIT;
+  int *s;
+  int ssize,m;
 
+  shiftvec = 0;
+  s = NULL;
+  
+  if (oWeight.tag != Sarray) {
+    errorKan1("%s\n","ordWsAll(): the second argument must be array.");
+  }
+  oWeight = Kto_int32(oWeight);
+  n = getoaSize(oWeight);
+  if (n == 0) {
+	m = getoaSize(ob);
+	f = objArrayToPOLY(ob);
+	f = head(f);
+    return POLYtoObjArray(f,m);
+  }
+  if (getoa(oWeight,0).tag == Sarray) {
+	if (n != 2) errorKan1("%s\n","ordWsAll(): the size of the second argument should be 2.");
+	shiftvec = 1;
+	oShift = getoa(oWeight,1);
+	oWeight = getoa(oWeight,0);
+	if (oWeight.tag != Sarray) {
+	  errorKan1("%s\n","ordWsAll(): the weight vector must be array.");
+	}
+	n = getoaSize(oWeight);
+	if (oShift.tag != Sarray) {
+	  errorKan1("%s\n","ordWsAll(): the shift vector must be array.");
+	}
+  }
+  /* oWeight = Ksm1WeightExpressionToVec(oWeight); */
+  if (n >= 2*N0) errorKan1("%s\n","ordWsAll(): the size of the second argument is invalid.");
+  for (i=0; i<n; i++) {
+    ow = getoa(oWeight,i);
+	if (ow.tag == SuniversalNumber) {
+	  ow = KpoInteger(coeffToInt(ow.lc.universalNumber));
+	}
+    if (ow.tag != Sinteger) {
+      errorKan1("%s\n","ordWsAll(): the entries of the second argument must be integers.");
+    }
+    w[i] = KopInteger(ow);
+  }
+  if (shiftvec) {
+    ssize = getoaSize(oShift);
+	s = (int *)sGC_malloc(sizeof(int)*(ssize+1));
+	if (s == NULL) errorKan1("%s\n","ordWsAll() no more memory.");
+	for (i=0; i<ssize; i++) {
+	  ow = getoa(oShift,i);
+	  if (ow.tag == SuniversalNumber) {
+		ow = KpoInteger(coeffToInt(ow.lc.universalNumber));
+	  }
+	  if (ow.tag != Sinteger) {
+		errorKan1("%s\n","ordWsAll(): the entries of shift vector must be integers.");
+	  }
+	  s[i] = KopInteger(ow);
+	}
+  }
+
+  switch(ob.tag) {
+  case Spoly:
+    f = KopPOLY(ob);
+	if (f == POLYNULL) errorKan1("%s\n","ordWsAll(): the argument is 0");
+	if (shiftvec) {
+	  return( KpoInteger(ordWsAll(f,w,s)));
+	}else{
+	  return( KpoInteger(ordWsAll(f,w,(int *) NULL)));
+	}
+    break;
+  case Sarray:
+	m = getoaSize(ob);
+	f = objArrayToPOLY(ob);
+	if (f == POLYNULL) errorKan1("%s\n","ordWsAll(): the argument is 0");
+	if (shiftvec) {
+	  return KpoInteger(ordWsAll(f,w,s));
+	}else{
+	  return KpoInteger(ordWsAll(f,w,(int *)NULL));
+	}
+  default:
+    errorKan1("%s\n","ordWsAll(): Argument must be polynomial or a vector of polynomials");
+    break;
+  }
+}
+
 int KpolyLength(POLY f) {
   int size;
   if (f == POLYNULL) return(1);
@@ -1090,8 +1269,8 @@ int validOutputOrder(int ord[],int n) {
 struct object KsetOutputOrder(struct object ob, struct ring *rp)
 {
   int n,i;
-  struct object ox;
-  struct object otmp;
+  struct object ox = OINIT;
+  struct object otmp = OINIT;
   int *xxx;
   int *ddd;
   if (ob.tag  != Sarray) {
@@ -1122,10 +1301,10 @@ struct object KsetOutputOrder(struct object ob, struct
 
 struct object KschreyerSkelton(struct object g)
 {
-  struct object rob;
-  struct object ij;
-  struct object ab;
-  struct object tt;
+  struct object rob = OINIT;
+  struct object ij = OINIT;
+  struct object ab = OINIT;
+  struct object tt = OINIT;
   struct arrayOfPOLY *ap;
   struct arrayOfMonomialSyz ans;
   int k;
@@ -1171,7 +1350,7 @@ struct object KvectorToSchreyer_es(struct object obarr
   int nn;
   POLY f;
   POLY g;
-  struct object ob;
+  struct object ob = OINIT;
   struct ring *rp;
   if (obarray.tag != Sarray) {
     errorKan1("%s\n","KvectorToSchreyer_es(): argument must be an array of polynomials.");
@@ -1206,4 +1385,142 @@ int objToInteger(struct object ob) {
   }else {
     errorKan1("%s\n","objToInteger(): invalid argument.");
   }
+}
+
+struct object KgetExponents(struct object obPoly,struct object otype) {
+  int type,asize,i;
+  POLY f;
+  POLY ff;
+  MONOMIAL tf;
+  struct object rob = OINIT;
+  struct object tob = OINIT;
+  static int nn,mm,ll,cc,n,m,l,c;
+  static struct ring *cr = (struct ring *)NULL;
+  extern struct ring *CurrentRingp;
+  int size,hsize,fsize,p,r;
+
+  if (otype.tag == Sinteger) {
+    type = KopInteger(otype);
+  }else if (otype.tag == SuniversalNumber) {
+    type = coeffToInt(KopUniversalNumber(otype));
+  }else {
+    errorKan1("%s\n","KgetExponents(): invalid translation type.");
+  }
+
+  if (obPoly.tag == Spoly) {
+    f = KopPOLY(obPoly);
+  }else if (obPoly.tag == Sarray) {
+    asize = getoaSize(obPoly);
+    rob = newObjectArray(asize);
+    for (i=0; i<asize; i++) {
+      tob = KgetExponents(getoa(obPoly,i),otype);
+      putoa(rob,i,tob);
+    }
+	return rob;
+  }else{
+    errorKan1("%s\n","KgetExponents(): argument must be a polynomial.");
+  }
+
+  /* type == 0    x,y,Dx,Dy     (no commutative, no vector)
+     type == 1    x,y,Dx,Dy,h,H (commutative & no vector)
+     type == 2    x,y,Dx,Dy,h   (commutative & no vector)
+  */
+  if (f ISZERO) {
+    cr = CurrentRingp;
+  }else{
+    tf = f->m;
+  }
+  if (tf->ringp != cr) {
+    n = tf->ringp->n;
+    m = tf->ringp->m;
+    l = tf->ringp->l;
+    c = tf->ringp->c;
+    nn = tf->ringp->nn;
+    mm = tf->ringp->mm;
+    ll = tf->ringp->ll;
+    cc = tf->ringp->cc;
+    cr = tf->ringp;
+  }
+  if (type == 0) {
+    size = 0;
+    for (i=c; i<ll; i++) size += 2;
+    for (i=l; i<mm; i++) size += 2;
+    for (i=m; i<nn; i++) size += 2;
+  }else if (type == 1) {
+    size = 0;
+    for (i=0; i<cc; i++) size += 2;
+    for (i=c; i<ll; i++) size += 2;
+    for (i=l; i<mm; i++) size += 2;
+    for (i=m; i<nn; i++) size += 2;
+  }else if (type == 2) {
+    size = 0;
+    for (i=0; i<cc; i++) size += 1;
+    for (i=c; i<ll; i++) size += 2;
+    for (i=l; i<mm; i++) size += 2;
+    for (i=m; i<nn; i++) size += 2;
+  }else{
+    errorKan1("%s\n","KgetExponent, unknown type.");
+  }
+  if (type == 1 || type == 2) {
+    hsize = (size-cc)/2;
+  }else{
+    hsize = size/2;
+  } 
+  if (f ISZERO) {
+    tob = newObjectArray(size);
+    for (i=0; i<size; i++) {
+      putoa(tob,i,KpoInteger(0));
+    }
+    rob = newObjectArray(1);
+    putoa(rob,0,tob);
+    return rob;
+  }
+  fsize = 0;
+  ff = f;
+  while (ff != POLYNULL) {
+    fsize++;
+    ff = ff->next;
+  }
+  rob = newObjectArray(fsize);
+
+  ff = f;
+  p = 0;
+  while (ff != POLYNULL) {
+    r = 0;
+    tob = newObjectArray(size);
+	tf = ff->m;
+    for (i=ll-1; i>=c; i--) {
+      putoa(tob,r,KpoInteger(tf->e[i].x));
+      putoa(tob,hsize+r,KpoInteger(tf->e[i].D));
+      r++;
+    }
+    for (i=mm-1; i>=l; i--) {
+      putoa(tob,r,KpoInteger(tf->e[i].x));
+      putoa(tob,hsize+r,KpoInteger(tf->e[i].D));
+      r++;
+    }
+    for (i=nn-1; i>=m; i--) {
+      putoa(tob,r,KpoInteger(tf->e[i].x));
+      putoa(tob,hsize+r,KpoInteger(tf->e[i].D));
+      r++;
+    }
+    if (type == 1) {
+      for (i=cc-1; i>=0; i--) {
+        putoa(tob,hsize+r,KpoInteger(tf->e[i].D));
+        r++;
+        putoa(tob,hsize+r,KpoInteger(tf->e[i].x)); 
+        r++;
+      }
+    }else if (type == 2) {
+      for (i=cc-1; i>=0; i--) {
+        putoa(tob,hsize+r,KpoInteger(tf->e[i].D)); 
+        r++;
+      }
+	}
+
+    putoa(rob,p,tob);
+    p++;
+    ff = ff->next;
+  }
+  return rob;
 }