===================================================================
RCS file: /home/cvs/OpenXM/src/kan96xx/Kan/Kclass/indeterminate.c,v
retrieving revision 1.1.1.1
retrieving revision 1.6
diff -u -p -r1.1.1.1 -r1.6
--- OpenXM/src/kan96xx/Kan/Kclass/indeterminate.c	1999/10/08 02:12:02	1.1.1.1
+++ OpenXM/src/kan96xx/Kan/Kclass/indeterminate.c	2001/09/01 01:37:48	1.6
@@ -1,3 +1,4 @@
+/* $OpenXM: OpenXM/src/kan96xx/Kan/Kclass/indeterminate.c,v 1.5 2001/05/04 01:06:29 takayama Exp $ */
 /* Kclass/indeterminate.c    */
 /* This file handles   indeterminate, tree, recursivePolynomial,
     polynomialInOneVariable
@@ -60,8 +61,8 @@ struct object KpoTree(struct object ob) {
     errorKan1("%s\n","Kclass/indeterminate.c, the length must 3 or more than 3. [name, cdname, arglist].");
   }
   ob1 = getoa(ob,0); ob2 = getoa(ob,1); ob3 = getoa(ob,2);
-  if (ob1.tag != Sdollar || ob2.tag != Sdollar || ob3.tag != Sarray) {
-    errorKan1("%s\n","Kclass/indeterminate.c, [string name, string cdname, list arglist].");
+  if (ob1.tag != Sdollar || ob2.tag != Sarray || ob3.tag != Sarray) {
+    errorKan1("%s\n","Kclass/indeterminate.c, [string name, list attributes, list arglist].");
   }
   *newobp = ob;
   rob.rc.voidp = newobp;
@@ -138,7 +139,7 @@ struct object addTree(struct object ob1, struct object
   }
   rob = newObjectArray(3);
   putoa(rob,0,KpoString("add"));
-  putoa(rob,1,KpoString("Basic"));
+  putoa(rob,1,KpoString("basic"));
   putoa(rob,2,aob);
   return(KpoTree(rob));
 }
@@ -162,7 +163,7 @@ struct object KpoRecursivePolynomial(struct object ob)
 }
 
 static void  printBodyOfRecursivePolynomial(struct object body,
-					    struct object vlist, FILE *fp)
+                                            struct object vlist, FILE *fp)
 {
   int i,j;
   int k;
@@ -181,12 +182,18 @@ static void  printBodyOfRecursivePolynomial(struct obj
   for (j=1; j<getoaSize(body); j = j+2) {
     k = KopInteger(getoa(body,j));
     if (k != 0) {
-      fprintf(fp,"%s",KopString(getoa(vlist,i)));
+      if (getoa(vlist,i).tag == Sdollar) {
+        fprintf(fp,"%s",KopString(getoa(vlist,i)));
+      }else if (ectag(getoa(vlist,i)) == CLASSNAME_tree) {
+        fprintClass(fp,getoa(vlist,i));
+      }else{
+        errorKan1("%s\n","printBodyOfRecursivePolynomial: format error.");
+      }
       if (k > 1) {
-	fprintf(fp,"^%d ",k);
+        fprintf(fp,"^%d ",k);
       }else if (k == 1) {
       }else{
-	fprintf(fp,"^(%d) ",k);
+        fprintf(fp,"^(%d) ",k);
       }
       fprintf(fp," * ");
     }
@@ -203,7 +210,7 @@ static void  printBodyOfRecursivePolynomial(struct obj
 void fprintRecursivePolynomial(FILE *fp,struct object op)
 {
   /* old  code 
-  printObject(KopRecursivePolynomial(op),0,fp); return;
+     printObject(KopRecursivePolynomial(op),0,fp); return;
   */
   struct object ob;
   struct object vlist;
@@ -297,11 +304,11 @@ struct object polyToRecursivePoly(struct object p) {
   putoa(rob,0,vlist2); putoa(rob,1,ob1);
   /* format of rob
      [ list of variables, poly or universalNumber or yyy to express
-                          a recursive polynomial. ]
-     format of yyy = CLASSNAME_polynomialInOneVariable			  
+     a recursive polynomial. ]
+     format of yyy = CLASSNAME_polynomialInOneVariable            
      [Sinteger,    Sinteger, coeff obj, Sinteger, coeff obj, .....]
-      name of var, exp,      coeff,     exp,      coeff
-    This format is checked by isRecursivePolynomial2().
+     name of var, exp,      coeff,     exp,      coeff
+     This format is checked by isRecursivePolynomial2().
   */
   rob = KpoRecursivePolynomial(rob);
   if (isRecursivePolynomial2(rob)) {
@@ -398,9 +405,9 @@ static int isRecursivePolynomial2a(struct object ob2, 
     if (ectag(tmp) == CLASSNAME_polynomialInOneVariable) {
       if (isRecursivePolynomial2a(tmp,n)) {
       }else{
-	fprintf(stderr,"isRecursivePolynomial2a: entry is not a polynomial in one variable.\n");
-	printObject(tmp,0,stderr); fprintf(stderr,"\n");
-	return(0);
+        fprintf(stderr,"isRecursivePolynomial2a: entry is not a polynomial in one variable.\n");
+        printObject(tmp,0,stderr); fprintf(stderr,"\n");
+        return(0);
       }
     }
   }
@@ -434,8 +441,10 @@ int isRecursivePolynomial2(struct object ob) {
   n = getoaSize(ob1);
   for (i=0; i<n; i++) {
     tmp = getoa(ob1,i);
-    if (tmp.tag != Sdollar) {
-      fprintf(stderr,"%s [list vlist, body]. Element of the vlist must be a string.\n",s); printObject(ob,1,stderr);
+    if (tmp.tag == Sdollar) {
+    }else if (ectag(tmp) == CLASSNAME_tree) {
+    }else{
+      fprintf(stderr,"%s [list vlist, body]. Element of the vlist must be a string or a tree.\n",s); printObject(ob,1,stderr);
       return(0);
     }
   }
@@ -477,8 +486,92 @@ struct object recursivePolyToPoly(struct object rp) {
 }
 
 
+struct object KrvtReplace(struct object rp_o,struct object v_o, struct object t_o) {
+  /* rp_o : recursive polynomial.
+     v_o  : variable name (indeterminate).
+     t_o  : tree.
+  */
+  struct object rp, vlist, newvlist, newrp;
+  int i,m;
+  /* Check the data types. */
+  if (ectag(rp_o) != CLASSNAME_recursivePolynomial) {
+    errorKan1("%s\n","KrvtReplace() type mismatch in the first argument.");
+  }
+  if (ectag(v_o) != CLASSNAME_indeterminate) {
+    errorKan1("%s\n","KrvtReplace() type mismatch in the second argument.");
+  }
+  if (ectag(t_o) != CLASSNAME_tree) {
+    errorKan1("%s\n","KrvtReplace() type mismatch in the third argument.");
+  }
+  
+  rp = KopRecursivePolynomial(rp_o);
+  vlist = getoa(rp,0);
+  m = getoaSize(vlist);
+  newvlist = newObjectArray(m);
+  for (i=0; i<m; i++) {
+    if (KooEqualQ(getoa(vlist,i),KopIndeterminate(v_o))) {
+      /* should be KooEqualQ(getoa(vlist,i),v_o). It's not a bug.
+         Internal expression of vlist is an array of string
+         (not indetermiante). */
+      putoa(newvlist,i,t_o);
+    }else{
+      putoa(newvlist,i,getoa(vlist,i));
+    }
+  }
+  newrp = newObjectArray(getoaSize(rp));
+  m = getoaSize(rp);
+  putoa(newrp,0,newvlist);
+  for (i=1; i<m; i++) {
+    putoa(newrp,i,getoa(rp,i));
+  }
+  return(KpoRecursivePolynomial(newrp));
+}
 
 
+struct object KreplaceRecursivePolynomial(struct object of,struct object rule) {
+  struct object rob,f;
+  int i;
+  int n;
+  struct object trule;
+  
 
+  if (rule.tag != Sarray) {
+    errorKan1("%s\n"," KreplaceRecursivePolynomial(): The second argument must be array.");
+  }
+  n = getoaSize(rule);
 
+  if (of.tag ==Sclass && ectag(of) == CLASSNAME_recursivePolynomial) {
+  }else{
+    errorKan1("%s\n"," KreplaceRecursivePolynomial(): The first argument must be a recursive polynomial.");
+  }
+  f = of;
+
+  for (i=0; i<n; i++) {
+    trule = getoa(rule,i);
+    if (trule.tag != Sarray) {
+      errorKan1("%s\n"," KreplaceRecursivePolynomial(): The second argument must be of the form [[a b] [c d] ....].");
+    }
+    if (getoaSize(trule) != 2) {
+      errorKan1("%s\n"," KreplaceRecursivePolynomial(): The second argument must be of the form [[a b] [c d] ....].");
+    }
+
+    if (ectag(getoa(trule,0)) != CLASSNAME_indeterminate) {
+      errorKan1("%s\n"," KreplaceRecursivePolynomial(): The second argument must be of the form [[a b] [c d] ....] where a,b,c,d,... are polynomials.");
+    }
+    /* Do not check the second argument. */
+    /*
+      if (getoa(trule,1).tag != Spoly) {
+      errorKan1("%s\n"," KreplaceRecursivePolynomial(): The second argument must be of the form [[a b] [c d] ....] where a,b,c,d,... are polynomials.");
+      }
+    */
+
+  }
+
+  rob = f;
+  for (i=0; i<n; i++) {
+    trule = getoa(rule,i);
+    rob = KrvtReplace(rob,getoa(trule,0),getoa(trule,1));
+  }
+  return(rob);
+}