===================================================================
RCS file: /home/cvs/OpenXM/src/kan96xx/Kan/kanExport0.c,v
retrieving revision 1.13
retrieving revision 1.32
diff -u -p -r1.13 -r1.32
--- OpenXM/src/kan96xx/Kan/kanExport0.c	2003/07/05 01:53:33	1.13
+++ OpenXM/src/kan96xx/Kan/kanExport0.c	2004/09/09 11:42:22	1.32
@@ -1,4 +1,4 @@
-/* $OpenXM: OpenXM/src/kan96xx/Kan/kanExport0.c,v 1.12 2003/06/26 13:00:10 takayama Exp $  */
+/* $OpenXM: OpenXM/src/kan96xx/Kan/kanExport0.c,v 1.31 2004/09/09 03:14:46 takayama Exp $  */
 #include <stdio.h>
 #include "datatype.h"
 #include "stackm.h"
@@ -19,6 +19,7 @@ int SerialCurrent = -1;  /* Current Serial number of t
 
 int ReverseOutputOrder = 1;  
 int WarningNoVectorVariable = 1;
+extern int QuoteMode;
 
 /** :arithmetic **/
 struct object KooAdd(ob1,ob2)
@@ -142,7 +143,11 @@ struct object KooAdd(ob1,ob2)
     
 
   default:
-    warningKan("KooAdd() has not supported yet these objects.\n");
+    if (QuoteMode) {
+      rob = addTree(ob1,ob2);
+    }else{
+      warningKan("KooAdd() has not supported yet these objects.\n");
+    }
     break;
   }
   return(rob);
@@ -270,7 +275,11 @@ struct object KooSub(ob1,ob2)
     break;
 
   default:
-    warningKan("KooSub() has not supported yet these objects.\n");
+    if (QuoteMode) {
+      rob = minusTree(ob1,ob2);
+    }else{
+      warningKan("KooSub() has not supported yet these objects.\n");
+    }
     break;
   }
   return(rob);
@@ -412,7 +421,11 @@ struct object KooMult(ob1,ob2)
     break;
 
   default:
-    warningKan("KooMult() has not supported yet these objects.\n");
+    if (QuoteMode) {
+      rob = timesTree(ob1,ob2);
+    }else{
+      warningKan("KooMult() has not supported yet these objects.\n");
+    }
     break;
   }
   return(rob);
@@ -451,7 +464,11 @@ struct object KoNegate(obj)
     break;
 
   default:
-    warningKan("KoNegate() has not supported yet these objects.\n");
+    if (QuoteMode) {
+      rob = unaryminusTree(obj);
+    }else{
+      warningKan("KoNegate() has not supported yet these objects.\n");
+    }
     break;
   }
   return(rob);
@@ -653,7 +670,11 @@ struct object KooDiv(ob1,ob2)
 
 
   default:
-    warningKan("KooDiv() has not supported yet these objects.\n");
+    if (QuoteMode) {
+      rob = divideTree(ob1,ob2);
+    }else{
+      warningKan("KooDiv() has not supported yet these objects.\n");
+    }
     break;
   }
   return(rob);
@@ -776,6 +797,21 @@ struct object KooGreater(obj1,obj2)
     if ( KopDouble(obj1) > KopDouble(obj2) ) return(KpoInteger(1));
     else return(KpoInteger(0));
     break;
+  case Sarray:
+  {
+    int i,m1,m2;
+    struct object rr;
+    m1 = getoaSize(obj1); m2 = getoaSize(obj2);
+    for (i=0; i< (m1>m2?m2:m1); i++) {
+      rr=KooGreater(getoa(obj1,i),getoa(obj2,i));
+      if (KopInteger(rr) == 1) return rr;
+      rr=KooGreater(getoa(obj2,i),getoa(obj1,i));
+      if (KopInteger(rr) == 1) return KpoInteger(0);
+    }
+    if (m1 > m2) return KpoInteger(1);
+    else return KpoInteger(0);
+  }
+  break;
   default:
     errorKan1("%s\n","KooGreater() has not supported these objects yet.");
     break;
@@ -817,6 +853,21 @@ struct object KooLess(obj1,obj2)
     if ( KopDouble(obj1) < KopDouble(obj2) ) return(KpoInteger(1));
     else return(KpoInteger(0));
     break;
+  case Sarray:
+  {
+    int i,m1,m2;
+    struct object rr;
+    m1 = getoaSize(obj1); m2 = getoaSize(obj2);
+    for (i=0; i< (m1>m2?m2:m1); i++) {
+      rr=KooLess(getoa(obj1,i),getoa(obj2,i));
+      if (KopInteger(rr) == 1) return rr;
+      rr=KooLess(getoa(obj2,i),getoa(obj1,i));
+      if (KopInteger(rr) == 1) return KpoInteger(0);
+    }
+    if (m1 < m2) return KpoInteger(1);
+    else return KpoInteger(0);
+  }
+  break;
   default:
     errorKan1("%s\n","KooLess() has not supported these objects yet.");
     break;
@@ -868,6 +919,10 @@ struct object KdataConversion(obj,key)
       return(rob);
     }else if (strcmp(key,"poly") == 0) {
       rob = KpoPOLY(ZERO);
+      return rob;
+    }else if (strcmp(key,"array") == 0) {
+      rob = newObjectArray(0);
+      return rob;
     }else{
       warningKan("Sorry. The data conversion from null to this data type has not supported yet.\n");
     }
@@ -893,8 +948,7 @@ struct object KdataConversion(obj,key)
       strcpy(rob.lc.str,intstr);
       return(rob);
     }else if (strcmp(key,"universalNumber")==0) {
-      rob.tag = SuniversalNumber;
-      rob.lc.universalNumber = intToCoeff(obj.lc.ival,&SmallRing);
+      rob = KintToUniversalNumber(obj.lc.ival);
       return(rob);
     }else if (strcmp(key,"double") == 0) {
       rob = KpoDouble((double) (obj.lc.ival));
@@ -965,7 +1019,7 @@ struct object KdataConversion(obj,key)
     if (strcmp(key,"array") == 0) {
       return(rob);
     }else if (strcmp(key,"list") == 0) {
-      rob = *( arrayToList(obj) );
+      rob = KarrayToList(obj);
       return(rob);
     }else if (strcmp(key,"arrayOfPOLY")==0) {
       rob = KpoArrayOfPOLY(arrayToArrayOfPOLY(obj));
@@ -980,11 +1034,19 @@ struct object KdataConversion(obj,key)
       rob = NullObject;
       return(rob);
     }else {
-      warningKan("Sorry. This type of data conversion has not supported yet.\n");
+	  { /* Automatically maps the elements. */
+		int n,i;
+		n = getoaSize(obj);
+		rob = newObjectArray(n);
+		for (i=0; i<n; i++) {
+		  putoa(rob,i,KdataConversion(getoa(obj,i),key));
+		}
+		return(rob);
+	  }
     }
     break;
   case Spoly:
-    if (strcmp(key,"poly")==0) {
+    if ((strcmp(key,"poly")==0) || (strcmp(key,"numerator")==0)) {
       rob = obj;
       return(rob);
     }else if (strcmp(key,"integer")==0) {
@@ -1050,12 +1112,13 @@ struct object KdataConversion(obj,key)
     break;
   case Slist:
     if (strcmp(key,"array") == 0) {
-      rob = listToArray(&obj);
+      rob = KlistToArray(obj);
       return(rob);
     }
     break;
   case SuniversalNumber:
-    if (strcmp(key,"universalNumber")==0) {
+    if ((strcmp(key,"universalNumber")==0) || (strcmp(key,"numerator")==0)) {
+      rob = obj;
       return(rob);
     }else if (strcmp(key,"integer")==0) {
       rob = KpoInteger(coeffToInt(obj.lc.universalNumber));
@@ -1073,6 +1136,9 @@ struct object KdataConversion(obj,key)
     }else if (strcmp(key,"double") == 0) {
       rob = KpoDouble( toDouble0(obj) );
       return(rob);
+    }else if (strcmp(key,"denominator") == 0) {
+      rob = KintToUniversalNumber(1);
+      return(rob);
     }else{
       warningKan("Sorry. This type of data conversion of universalNumber has not supported yet.\n");
     }
@@ -1137,6 +1203,9 @@ struct object KdataConversion(obj,key)
     if (strcmp(key,"orderMatrix")==0) {
       rob = oGetOrderMatrix(KopRingp(obj));
       return(rob);
+    }else if (strcmp(key,"oxRingStructure")==0) {
+      rob = oRingToOXringStructure(KopRingp(obj));
+      return(rob);
     }else{
       warningKan("Sorryl This type of data conversion of ringp has not supported yet.\n");
     }
@@ -1146,7 +1215,24 @@ struct object KdataConversion(obj,key)
   }
   return(NullObject);
 }
-    
+
+/* cf. macro to_int32 */
+struct object Kto_int32(struct object ob) {
+  int n,i;
+  struct object otmp;
+  struct object rob;
+  if (ob.tag == SuniversalNumber) return KdataConversion(ob,"integer");
+  if (ob.tag == Sarray) {
+	n = getoaSize(ob);
+	rob = newObjectArray(n);
+	for (i=0; i<n; i++) {
+	  otmp = Kto_int32(getoa(ob,i));
+	  putoa(rob,i,otmp);
+	}
+	return rob;
+  }
+  return ob;
+}    
 /* conversion functions between primitive data and objects.
    If it's not time critical, it is recommended to use these functions */
 struct object KpoInteger(k)
@@ -1200,6 +1286,24 @@ struct object KpoRingp(ringp)
   return(obj);
 }
 
+struct object KpoUniversalNumber(u)
+     struct coeff *u;
+{
+  struct object obj;
+  obj.tag = SuniversalNumber;
+  obj.lc.universalNumber = u;
+  return(obj);
+}
+struct object KintToUniversalNumber(n)
+	 int n;
+{
+  struct object rob;
+  extern struct ring SmallRing;
+  rob.tag = SuniversalNumber;
+  rob.lc.universalNumber = intToCoeff(n,&SmallRing);
+  return(rob);
+}
+
 /*** conversion 2. Data conversions on arrays and matrices. ****/
 struct object arrayOfPOLYToArray(aa)
      struct arrayOfPOLY *aa;
@@ -1496,7 +1600,8 @@ int KsetUpRing(ob1,ob2,ob3,ob4,ob5)
       outputVars[i] = i;
     }
   }
-  
+
+  ob4 = Kto_int32(ob4); /* order matrix */
   oasize = getoaSize(ob4);
   order = (int *)sGC_malloc(sizeof(int)*((2*n)*oasize+1));
   if (order == (int *)NULL) errorKan1("%s\n","No memory.");
@@ -1621,8 +1726,8 @@ int KsetUpRing(ob1,ob2,ob3,ob4,ob5)
             }
           }
         }
-		switch_function("grade","module1v");
-		/* Warning: grading is changed to module1v!! */
+        switch_function("grade","module1v");
+        /* Warning: grading is changed to module1v!! */
       } else {
         errorKan1("%s\n","Unknown keyword to set_up_ring@");
       }
@@ -2062,7 +2167,47 @@ int KtoArgvbyCurryBrace(str,argv,limit)
   return(argc);
 }
 
+struct object KstringToArgv(struct object ob) {
+  struct object rob;
+  char *s;
+  int n,wc,i,inblank;
+  char **argv;
+  if (ob.tag != Sdollar)
+    errorKan1("%s\n","KstringToArgv(): the argument must be a string.");
+  n = strlen(KopString(ob));
+  s = (char *) sGC_malloc(sizeof(char)*(n+2));
+  if (s == NULL) errorKan1("%s\n","KstringToArgv(): No memory.");
+  strcpy(s,KopString(ob));
+  inblank = 1;  wc = 0; 
+  for (i=0; i<n; i++) {
+    if (inblank && (s[i] > ' ')) {
+      wc++; inblank = 0;
+    }else if ((!inblank) && (s[i] <= ' ')) {
+      inblank = 1;
+    }
+  }
+  argv = (char **) sGC_malloc(sizeof(char *)*(wc+2));
+  argv[0] = NULL;
+  inblank = 1;  wc = 0; 
+  for (i=0; i<n; i++) {
+    if (inblank && (s[i] > ' ')) {
+      argv[wc] = &(s[i]); argv[wc+1]=NULL;
+      wc++; inblank = 0;
+    }else if ((inblank == 0) && (s[i] <= ' ')) {
+      inblank = 1; s[i] = 0;
+    }else if (inblank && (s[i] <= ' ')) {
+      s[i] = 0;
+    }
+  }
 
+  rob = newObjectArray(wc);
+  for (i=0; i<wc; i++) {
+    putoa(rob,i,KpoString(argv[i]));
+    /* printf("%s\n",argv[i]); */
+  }
+  return(rob);
+}
+
 static void checkDuplicateName(xvars,dvars,n)
      char *xvars[];
      char *dvars[];
@@ -2084,6 +2229,16 @@ static void checkDuplicateName(xvars,dvars,n)
   }
 }
 
+struct object KooPower(struct object ob1,struct object ob2) {
+  struct object rob;
+  /* Bug. It has not yet been implemented. */
+  if (QuoteMode) {
+    rob = powerTree(ob1,ob2);
+  }else{
+    warningKan("KooDiv2() has not supported yet these objects.\n");
+  }
+  return(rob);
+}
 
 
 
@@ -2146,7 +2301,11 @@ struct object KooDiv2(ob1,ob2)
     break;
 
   default:
-    warningKan("KooDiv2() has not supported yet these objects.\n");
+    if (QuoteMode) {
+      rob = divideTree(ob1,ob2);
+    }else{
+      warningKan("KooDiv2() has not supported yet these objects.\n");
+    }
     break;
   }
   return(rob);
@@ -2202,6 +2361,7 @@ struct object KgbExtension(struct object obj)
   POLY f;
   int m,i;
   struct pairOfPOLY pf;
+  struct coeff *cont;
 
   if (obj.tag != Sarray) errorKan1("%s\n","KgbExtension(): The argument must be an array.");
   size = getoaSize(obj);
@@ -2281,6 +2441,13 @@ struct object KgbExtension(struct object obj)
       errorKan1("%s\n","The datatype of the argument mismatch: [(isConstant) polynomial] gbext");
     }
     return(KpoInteger(isConstant(KopPOLY(obj1))));
+  }else if (strcmp(key,"isConstantAll")==0) {
+    if (size != 2) errorKan1("%s\n","[(isConstantAll) poly ] gbext bool");
+    obj1 = getoa(obj,1);
+    if (obj1.tag != Spoly) {
+      errorKan1("%s\n","The datatype of the argument mismatch: [(isConstantAll) polynomial] gbext");
+    }
+    return(KpoInteger(isConstantAll(KopPOLY(obj1))));
   }else if (strcmp(key,"schreyerSkelton") == 0) {
     if (size != 2) errorKan1("%s\n","[(schreyerSkelton) array_of_poly ] gbext array");
     obj1 = getoa(obj,1);
@@ -2315,6 +2482,37 @@ struct object KgbExtension(struct object obj)
     obj1 = getoa(obj,1);
     if (obj1.tag != Spoly) errorKan1("%s\n","[(isOrdered) poly] gbext poly");
     return(KisOrdered(obj1));
+  }else if (strcmp(key,"reduceContent")==0) {
+    if (size != 2) errorKan1("%s\n","[(reduceContent)  poly1 ] gbext.");
+    obj1 = getoa(obj,1);
+    if (obj1.tag != Spoly)
+      errorKan1("%s\n","[(reduceContent)  poly1 ] gbext.");
+    f1 = KopPOLY(obj1);
+    rob = newObjectArray(2);
+    f1 = reduceContentOfPoly(f1,&cont);
+    putoa(rob,0,KpoPOLY(f1));
+    if (f1 == POLYNULL) {
+      putoa(rob,1,KpoPOLY(f1));
+    }else{
+      putoa(rob,1,KpoPOLY(newCell(cont,newMonomial(f1->m->ringp))));
+    }
+  }else if (strcmp(key,"ord_ws_all")==0) {
+    if (size != 3) errorKan1("%s\n","[(ord_ws_all) fv wv] gbext");
+    obj1 = getoa(obj,1);
+    obj2 = getoa(obj,2);
+    rob  = KordWsAll(obj1,obj2);
+  }else if (strcmp(key,"exponents")==0) {
+    if (size == 3) {
+      obj1 = getoa(obj,1);
+      obj2 = getoa(obj,2);
+      rob  = KgetExponents(obj1,obj2);
+    }else if (size == 2) {
+      obj1 = getoa(obj,1);
+      obj2 = KpoInteger(2);
+      rob  = KgetExponents(obj1,obj2);
+    }else{
+      errorKan1("%s\n","[(exponents) f type] gbext");
+    }
   }else {
     errorKan1("%s\n","gbext : unknown tag.");
   }
@@ -2350,6 +2548,12 @@ struct object KmpzExtension(struct object obj)
     if (size != 3) errorKan1("%s\n","[(gcd)  universalNumber universalNumber] mpzext.");
     obj1 = getoa(obj,1);
     obj2 = getoa(obj,2);
+    if (obj1.tag != SuniversalNumber) {
+      obj1 = KdataConversion(obj1,"universalNumber");
+	}
+    if (obj2.tag != SuniversalNumber) {
+      obj2 = KdataConversion(obj2,"universalNumber");
+	}
     if (obj1.tag != SuniversalNumber || obj2.tag != SuniversalNumber)
       errorKan1("%s\n","[(gcd)  universalNumber universalNumber] mpzext.");
     if (! is_this_coeff_MP_INT(obj1.lc.universalNumber) ||
@@ -2366,6 +2570,12 @@ struct object KmpzExtension(struct object obj)
     if (size != 3) errorKan1("%s\n","[(tdiv_qr)  universalNumber universalNumber] mpzext.");
     obj1 = getoa(obj,1);
     obj2 = getoa(obj,2);
+    if (obj1.tag != SuniversalNumber) {
+      obj1 = KdataConversion(obj1,"universalNumber");
+	}
+    if (obj2.tag != SuniversalNumber) {
+      obj2 = KdataConversion(obj2,"universalNumber");
+	}
     if (obj1.tag != SuniversalNumber || obj2.tag != SuniversalNumber)
       errorKan1("%s\n","[(tdiv_qr)  universalNumber universalNumber] mpzext.");
     if (! is_this_coeff_MP_INT(obj1.lc.universalNumber) ||
@@ -2424,6 +2634,9 @@ struct object KmpzExtension(struct object obj)
     /*  One arg functions  */
     if (size != 2) errorKan1("%s\n","[key num] mpzext");
     obj1 = getoa(obj,1);
+    if (obj1.tag != SuniversalNumber) {
+      obj1 = KdataConversion(obj1,"universalNumber");
+	}
     if (obj1.tag != SuniversalNumber)
       errorKan1("%s\n","[key num] mpzext : num must be a universalNumber.");
     if (! is_this_coeff_MP_INT(obj1.lc.universalNumber))
@@ -2445,6 +2658,12 @@ struct object KmpzExtension(struct object obj)
     if (size != 3) errorKan1("%s\n","[key  num1 num2] mpzext.");
     obj1 = getoa(obj,1);
     obj2 = getoa(obj,2);
+    if (obj1.tag != SuniversalNumber) {
+      obj1 = KdataConversion(obj1,"universalNumber");
+	}
+    if (obj2.tag != SuniversalNumber) {
+      obj2 = KdataConversion(obj2,"universalNumber");
+	}
     if (obj1.tag != SuniversalNumber || obj2.tag != SuniversalNumber)
       errorKan1("%s\n","[key num1 num2] mpzext.");
     if (! is_this_coeff_MP_INT(obj1.lc.universalNumber) ||
@@ -2476,6 +2695,15 @@ struct object KmpzExtension(struct object obj)
     /* three args */
     if (size != 4) errorKan1("%s\n","[key num1 num2 num3] mpzext");
     obj1 = getoa(obj,1); obj2 = getoa(obj,2); obj3 = getoa(obj,3);
+    if (obj1.tag != SuniversalNumber) {
+      obj1 = KdataConversion(obj1,"universalNumber");
+	}
+    if (obj2.tag != SuniversalNumber) {
+      obj2 = KdataConversion(obj2,"universalNumber");
+	}
+    if (obj3.tag != SuniversalNumber) {
+      obj3 = KdataConversion(obj3,"universalNumber");
+	}
     if (obj1.tag != SuniversalNumber ||
         obj2.tag != SuniversalNumber ||
         obj3.tag != SuniversalNumber ) {
@@ -2494,6 +2722,28 @@ struct object KmpzExtension(struct object obj)
     mpz_powm(r1,f,g,h);
     rob.tag = SuniversalNumber;
     rob.lc.universalNumber = mpintToCoeff(r1,SmallRingp);
+  } else if (strcmp(key,"lcm")==0) {
+    if (size != 3) errorKan1("%s\n","[(lcm)  universalNumber universalNumber] mpzext.");
+    obj1 = getoa(obj,1);
+    obj2 = getoa(obj,2);
+    if (obj1.tag != SuniversalNumber) {
+      obj1 = KdataConversion(obj1,"universalNumber");
+	}
+    if (obj2.tag != SuniversalNumber) {
+      obj2 = KdataConversion(obj2,"universalNumber");
+	}
+    if (obj1.tag != SuniversalNumber || obj2.tag != SuniversalNumber)
+      errorKan1("%s\n","[lcm num1 num2] mpzext.");
+    if (! is_this_coeff_MP_INT(obj1.lc.universalNumber) ||
+        ! is_this_coeff_MP_INT(obj2.lc.universalNumber)) {
+      errorKan1("%s\n","[(lcm)  universalNumber universalNumber] mpzext.");
+    }
+    f = coeff_to_MP_INT(obj1.lc.universalNumber);
+    g = coeff_to_MP_INT(obj2.lc.universalNumber);
+    r1 = newMP_INT();
+    mpz_lcm(r1,f,g);
+    rob.tag = SuniversalNumber;
+    rob.lc.universalNumber = mpintToCoeff(r1,SmallRingp); 
   }else {
     errorKan1("%s\n","mpzExtension(): Unknown tag.");
   }
@@ -2700,6 +2950,47 @@ struct object KdefaultPolyRing(struct object ob) {
 }
   
   
+struct object Krest(struct object ob) {
+  struct object rob;
+  struct object *op;
+  int n,i;
+  if (ob.tag == Sarray) {
+    n = getoaSize(ob);
+    if (n == 0) return ob;
+    rob = newObjectArray(n-1);
+    for (i=1; i<n; i++) {
+      putoa(rob,i-1,getoa(ob,i));
+    }
+    return rob;
+  }else if ((ob.tag == Slist) || (ob.tag == Snull)) {
+    return Kcdr(ob);
+  }else{
+    errorKan1("%s\n","Krest(ob): ob must be an array or a list.");
+  }
+}
+struct object Kjoin(struct object ob1, struct object ob2) {
+  struct object rob;
+  int n1,n2,i;
+  if ((ob1.tag == Sarray) &&  (ob2.tag == Sarray)) {
+    n1 = getoaSize(ob1); n2 = getoaSize(ob2);
+    rob = newObjectArray(n1+n2);
+    for (i=0; i<n1; i++) {
+      putoa(rob,i,getoa(ob1,i));
+    }
+    for (i=n1; i<n1+n2; i++) {
+      putoa(rob,i,getoa(ob2,i-n1));
+    }
+    return rob;
+  }else if ((ob1.tag == Slist) || (ob1.tag == Snull)) {
+	if ((ob2.tag == Slist) || (ob2.tag == Snull)) {
+	  return KvJoin(ob1,ob2);
+	}else{
+	  errorKan1("%s\n","Kjoin: both argument must be a list.");
+	}
+  }else{
+    errorKan1("%s\n","Kjoin: arguments must be arrays.");
+  }
+}
   
   
 
@@ -2726,6 +3017,7 @@ errorKan1(str,message)
   if (ErrorMessageMode != 1) {
     fprintf(stderr,"\nERROR(kanExport[0|1].c): ");
     fprintf(stderr,str,message);
+    (void) traceShowStack(); traceClearStack();
   }
   /* fprintf(stderr,"Hello "); */
   if (GotoP) {
@@ -2741,6 +3033,7 @@ errorKan1(str,message)
   longjmp(EnvOfStackMachine,1);
 #endif
 }
+
 
 warningKan(str)
      char *str;