===================================================================
RCS file: /home/cvs/OpenXM/src/kan96xx/Kan/kanExport1.c,v
retrieving revision 1.3
retrieving revision 1.7
diff -u -p -r1.3 -r1.7
--- OpenXM/src/kan96xx/Kan/kanExport1.c	2003/07/10 08:20:04	1.3
+++ OpenXM/src/kan96xx/Kan/kanExport1.c	2003/08/22 11:47:03	1.7
@@ -1,3 +1,4 @@
+/* $OpenXM: OpenXM/src/kan96xx/Kan/kanExport1.c,v 1.6 2003/08/21 12:28:57 takayama Exp $ */
 #include <stdio.h>
 #include "datatype.h"
 #include "stackm.h"
@@ -11,6 +12,10 @@
 static int Message = 1;
 extern int KanGBmessage;
   
+struct object DegreeShifto;
+int DegreeShifto_size = 0;
+int *DegreeShifto_vec = NULL;
+
 /** :kan, :ring */
 struct object Kreduction(f,set)
      struct object f;
@@ -38,6 +43,7 @@ struct object Kreduction(f,set)
   }else{
     r = (*reduction)(f.lc.poly,grG,1,&syz);
   }
+  /* outputGradedPolySet(grG,0); */
   if (flag) {
     rob = newObjectArray(3);
     putoa(rob,0,KpoPOLY(r));
@@ -495,7 +501,7 @@ struct object syzPolyToArray(size,f,grG)
 
   while (f != POLYNULL) {
     g0 = srGrade(f);
-    i0 = srIndex(f);
+    i0 = srIndex(f);  
     serial = grG->polys[g0]->serial[i0];
     if (serial < 0) {
       errorKan1("%s\n","syzPolyToArray(): invalid serial[i] of grG.");
@@ -683,7 +689,7 @@ struct object homogenizeObject(ob,gradep)
     rob = newObjectArray(size);
     flag = 0;
     ob1 = getoa(ob,0);
-	if (ob1.tag == Sdollar) return(homogenizeObject_go(ob,gradep));
+    if (ob1.tag == Sdollar) return(homogenizeObject_go(ob,gradep));
     ob1 = homogenizeObject(ob1,&gr);
     maxg = gr;
     getoa(rob,0) = ob1;
@@ -745,7 +751,7 @@ struct object homogenizeObject_vec(ob,gradep)
     if (size == 0) {
       errorKan1("%s\n","homogenizeObject_vec() is called for the empty array.");
     }
-	if (getoa(ob,0).tag == Sdollar) return(homogenizeObject_go(ob,gradep));
+    if (getoa(ob,0).tag == Sdollar) return(homogenizeObject_go(ob,gradep));
     rob = newObjectArray(size);
     for (i=0; i<size; i++) {
       ob1 = getoa(ob,i);
@@ -785,40 +791,56 @@ struct object homogenizeObject_go(struct object ob,int
     errorKan1("%s\n","homogenizeObject_go(): the first argument must be a string.");
   }
   if (strcmp(KopString(ob0),"degreeShift") == 0) {
-	if (size != 3)
-	  errorKan1("%s\n","homogenizeObject_go(): [(degreeShift) shift-vector obj]");
-	ob1 = getoa(ob,1); ob2 = getoa(ob,2);
-	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 (ob2.tag == Spoly) {
-	  f = goHomogenize11(KopPOLY(ob2),ds,dssize,-1);
-	  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);
+    if (size < 2)
+      errorKan1("%s\n","homogenizeObject_go(): [(degreeShift) shift-vector obj] or [(degreeShift) shift-vector] or [(degreeShift) (value)] homogenize");
+    ob1 = getoa(ob,1);
+	if (ob1.tag != Sarray) {
+	  if (DegreeShifto_size != 0) {
+		return DegreeShifto;
+	  }else{
+        rob = NullObject;
+        return rob;
 	  }
-	}else{
-	  errorKan1("%s\n","homogenizeObject_go(): invalid object for the third element.");
 	}
+    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;
+      DegreeShifto_size = dssize;
+      DegreeShifto_vec = ds;
+      rob = ob1;
+    }else{
+      ob2 = getoa(ob,2);
+      if (ob2.tag == Spoly) {
+        f = goHomogenize11(KopPOLY(ob2),ds,dssize,-1,0);
+        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);
+        }
+      }else{
+        errorKan1("%s\n","homogenizeObject_go(): invalid object for the third element.");
+      }
+    }
   }else{
-	  errorKan1("%s\n","homogenizeObject_go(): unknown key word.");
+      errorKan1("%s\n","homogenizeObject_go(): unknown key word.");
   }
-  return( rob );	
+  return( rob );    
 }
 
 
@@ -902,30 +924,146 @@ struct object oInitW(ob,oWeight)
   int w[2*N0];
   int n,i;
   struct object ow;
+  int shiftvec;
+  struct object oShift;
+  int *s;
+  int ssize,m;
 
+  shiftvec = 0;
+  s = NULL;
+  
   if (oWeight.tag != Sarray) {
     errorKan1("%s\n","oInitW(): the second argument must be array.");
   }
   n = getoaSize(oWeight);
+  if (n == 0)  errorKan1("%s\n","oInitW(): the size of the second argument is invalid.");
+  if (getoa(oWeight,0).tag == Sarray) {
+	if (n != 2) errorKan1("%s\n","oInitW(): 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","oInitW(): the weight vector must be array.");
+	}
+	n = getoaSize(oWeight);
+	if (oShift.tag != Sarray) {
+	  errorKan1("%s\n","oInitW(): the shift vector must be array.");
+	}
+  }
+  /* oWeight = Ksm1WeightExpressionToVec(oWeight); */
   if (n >= 2*N0) errorKan1("%s\n","oInitW(): 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","oInitW(): 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","oInitW() 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","oInitW(): the entries of shift vector must be integers.");
+	  }
+	  s[i] = KopInteger(ow);
+	}
+  }
+
   switch(ob.tag) {
   case Spoly:
     f = KopPOLY(ob);
-    return( KpoPOLY(POLYToInitW(f,w)));
+	if (shiftvec) {
+	  return( KpoPOLY(POLYToInitWS(f,w,s)));
+	}else{
+	  return( KpoPOLY(POLYToInitW(f,w)));
+	}
     break;
+  case Sarray:
+	m = getoaSize(ob);
+	f = objArrayToPOLY(ob);
+    /* printf("1.%s\n",POLYToString(f,'*',1)); */
+	if (shiftvec) {
+	  f =  POLYToInitWS(f,w,s);
+	}else{
+	  f =  POLYToInitW(f,w);
+	}
+    /* printf("2.%s\n",POLYToString(f,'*',1)); */
+
+	return POLYtoObjArray(f,m);
   default:
-    errorKan1("%s\n","oInitW(): Argument must be polynomial.");
+    errorKan1("%s\n","oInitW(): Argument must be polynomial or a vector of polynomials");
     break;
   }
 }
 
+POLY objArrayToPOLY(struct object ob) {
+  int m;
+  POLY f;
+  POLY t;
+  int i,n;
+  struct ring *ringp;
+  if (ob.tag != Sarray) errorKan1("%s\n", "objArrayToPOLY() the argument must be an array.");
+  m = getoaSize(ob);
+  ringp = NULL;
+  f = POLYNULL;
+  for (i=0; i<m; i++) {
+    if (getoa(ob,i).tag != Spoly) errorKan1("%s\n","objArrayToPOLY() elements must be a polynomial.");
+    t = KopPOLY(getoa(ob,i));
+    if (t ISZERO) {
+    }else{
+      if (ringp == NULL) {
+        ringp = t->m->ringp;
+        n = ringp->n;
+      }
+      t = (*mpMult)(cxx(1,n-1,i,ringp),t);
+      f = ppAddv(f,t);
+    }
+  }
+  return f;
+}
+
+struct object POLYtoObjArray(POLY f,int size) {
+  struct object rob;
+  POLY *pa;
+  int d,n,i;
+  POLY t;
+  if (size < 0) errorKan1("%s\n","POLYtoObjArray() invalid size.");
+  rob = newObjectArray(size);
+  pa = (POLY *) sGC_malloc(sizeof(POLY)*(size+1));
+  if (pa == NULL) errorKan1("%s\n","POLYtoObjArray() no more memory.");
+  for (i=0; i<size; i++) {
+    pa[i] = POLYNULL;
+    putoa(rob,i,KpoPOLY(pa[i]));
+  }
+  if (f == POLYNULL) {
+    return rob;
+  }
+  n = f->m->ringp->n;
+  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));
+	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. */
+    f = f->next;
+  }
+  for (i=0; i<size; i++) {
+    putoa(rob,i,KpoPOLY(pa[i]));
+  }
+  return rob;
+}
+
+
 int KpolyLength(POLY f) {
   int size;
   if (f == POLYNULL) return(1);
@@ -1062,10 +1200,10 @@ struct object KvectorToSchreyer_es(struct object obarr
 
 int objToInteger(struct object ob) {
   if (ob.tag == Sinteger) {
-	return KopInteger(ob);
+    return KopInteger(ob);
   }else if (ob.tag == SuniversalNumber) {
-	return(coeffToInt(KopUniversalNumber(ob)));
+    return(coeffToInt(KopUniversalNumber(ob)));
   }else {
-	errorKan1("%s\n","objToInteger(): invalid argument.");
+    errorKan1("%s\n","objToInteger(): invalid argument.");
   }
 }