Annotation of OpenXM/src/kan96xx/Kan/Kclass/indeterminate.c, Revision 1.1
1.1 ! maekawa 1: /* Kclass/indeterminate.c */
! 2: /* This file handles indeterminate, tree, recursivePolynomial,
! 3: polynomialInOneVariable
! 4: */
! 5: #include <stdio.h>
! 6: #include "../datatype.h"
! 7: #include "../stackm.h"
! 8: #include "../extern.h"
! 9: #include "../gradedset.h"
! 10: #include "../extern2.h"
! 11: #include "../kclass.h"
! 12:
! 13:
! 14: /* Data conversion function : see KclassDataConversion*/
! 15: struct object KpoIndeterminate(struct object ob) {
! 16: struct object rob;
! 17: struct object *newobp;
! 18: rob.tag = Sclass;
! 19: rob.lc.ival = CLASSNAME_indeterminate;
! 20: newobp = (struct object *) sGC_malloc(sizeof(struct object));
! 21: if (newobp == NULL) errorKan1("%s\n","Kclass/indeterminate.c, no more memory.");
! 22: if (ob.tag != Sdollar) {
! 23: errorKan1("%s\n","Kclass/indeterminate.c, only String object can be transformed into indeterminate.");
! 24: }
! 25: *newobp = ob;
! 26: rob.rc.voidp = newobp;
! 27: return(rob);
! 28: }
! 29:
! 30: /* The second constructor. */
! 31: struct object KnewIndeterminate(char *s) {
! 32: struct object ob;
! 33:
! 34: ob = KpoString(s); /* We do not clone s */
! 35: return(KpoIndeterminate(ob));
! 36: }
! 37:
! 38:
! 39: /* Printing function : see fprintClass */
! 40: void fprintIndeterminate(FILE *fp,struct object op)
! 41: {
! 42: printObject(KopIndeterminate(op),0,fp);
! 43: }
! 44:
! 45:
! 46: /* ---------------------------------------------------- */
! 47: /* Data conversion function : see KclassDataConversion*/
! 48: struct object KpoTree(struct object ob) {
! 49: struct object rob;
! 50: struct object ob1,ob2,ob3;
! 51: struct object *newobp;
! 52: rob.tag = Sclass;
! 53: rob.lc.ival = CLASSNAME_tree;
! 54: newobp = (struct object *) sGC_malloc(sizeof(struct object));
! 55: if (newobp == NULL) errorKan1("%s\n","Kclass/indeterminate.c, no more memory.");
! 56: if (ob.tag != Sarray) {
! 57: errorKan1("%s\n","Kclass/indeterminate.c, only properly formatted list object can be transformed into tree. [name, cdname, arglist].");
! 58: }
! 59: if (getoaSize(ob) < 3) {
! 60: errorKan1("%s\n","Kclass/indeterminate.c, the length must 3 or more than 3. [name, cdname, arglist].");
! 61: }
! 62: ob1 = getoa(ob,0); ob2 = getoa(ob,1); ob3 = getoa(ob,2);
! 63: if (ob1.tag != Sdollar || ob2.tag != Sdollar || ob3.tag != Sarray) {
! 64: errorKan1("%s\n","Kclass/indeterminate.c, [string name, string cdname, list arglist].");
! 65: }
! 66: *newobp = ob;
! 67: rob.rc.voidp = newobp;
! 68: return(rob);
! 69: }
! 70:
! 71:
! 72: /* Printing function : see fprintClass */
! 73: void fprintTree(FILE *fp,struct object op)
! 74: {
! 75: printObject(KopTree(op),0,fp);
! 76: }
! 77:
! 78: int isTreeAdd(struct object ob) {
! 79: struct object name;
! 80: if (ob.tag != Sclass) {
! 81: return(0);
! 82: }
! 83: if (ectag(ob) != CLASSNAME_tree) {
! 84: return(0);
! 85: }
! 86: ob = KopTree(ob);
! 87: if (ob.tag != Sarray) {
! 88: errorKan1("%s\n","CLASSNAME_tree is broken. Should be array.");
! 89: }
! 90: name = getoa(ob,0);
! 91: if (name.tag != Sdollar) {
! 92: errorKan1("%s\n","CLASSNAME_tree is broken. Should be string.");
! 93: }
! 94: if (strcmp(KopString(name),"add") == 0) {
! 95: return(1);
! 96: }else{
! 97: return(0);
! 98: }
! 99: }
! 100:
! 101: struct object addTree(struct object ob1, struct object ob2)
! 102: {
! 103: struct object rob,aob;
! 104: struct object ob3,ob4;
! 105: int i;
! 106: if (isTreeAdd(ob1) && !isTreeAdd(ob2)) {
! 107: ob1 = KopTree(ob1);
! 108: ob3 = getoa(ob1,2);
! 109: aob = newObjectArray(getoaSize(ob3)+1);
! 110: for (i=0; i<getoaSize(ob3); i++) {
! 111: putoa(aob,i,getoa(ob3,i));
! 112: }
! 113: putoa(aob,getoaSize(ob3),ob2);
! 114: }else if (!isTreeAdd(ob1) && isTreeAdd(ob2)) {
! 115: ob2 = KopTree(ob2);
! 116: ob3 = getoa(ob2,2);
! 117: aob = newObjectArray(getoaSize(ob3)+1);
! 118: putoa(aob,0,ob1);
! 119: for (i=0; i<getoaSize(ob3); i++) {
! 120: putoa(aob,1+i,getoa(ob3,i));
! 121: }
! 122: }else if (isTreeAdd(ob1) && isTreeAdd(ob2)) {
! 123: ob1 = KopTree(ob1);
! 124: ob2 = KopTree(ob2);
! 125: ob3 = getoa(ob1,2);
! 126: ob4 = getoa(ob2,2);
! 127: aob = newObjectArray(getoaSize(ob3)+getoaSize(ob4));
! 128: for (i=0; i<getoaSize(ob3); i++) {
! 129: putoa(aob,i,getoa(ob3,i));
! 130: }
! 131: for (i=0; i<getoaSize(ob4); i++) {
! 132: putoa(aob,getoaSize(ob3)+i,getoa(ob4,i));
! 133: }
! 134: }else{
! 135: aob = newObjectArray(2);
! 136: putoa(aob,0,ob1);
! 137: putoa(aob,1,ob2);
! 138: }
! 139: rob = newObjectArray(3);
! 140: putoa(rob,0,KpoString("add"));
! 141: putoa(rob,1,KpoString("Basic"));
! 142: putoa(rob,2,aob);
! 143: return(KpoTree(rob));
! 144: }
! 145:
! 146:
! 147: /*------------------------------------------*/
! 148:
! 149: struct object KpoRecursivePolynomial(struct object ob) {
! 150: struct object rob;
! 151: struct object *newobp;
! 152: rob.tag = Sclass;
! 153: rob.lc.ival = CLASSNAME_recursivePolynomial;
! 154: newobp = (struct object *) sGC_malloc(sizeof(struct object));
! 155: if (newobp == NULL) errorKan1("%s\n","Kclass/indeterminate.c, no more memory.");
! 156: if (ob.tag != Sarray) {
! 157: errorKan1("%s\n","Kclass/indeterminate.c, only array object can be transformed into recusivePolynomial.");
! 158: }
! 159: *newobp = ob;
! 160: rob.rc.voidp = newobp;
! 161: return(rob);
! 162: }
! 163:
! 164: static void printBodyOfRecursivePolynomial(struct object body,
! 165: struct object vlist, FILE *fp)
! 166: {
! 167: int i,j;
! 168: int k;
! 169: if (ectag(body) != CLASSNAME_polynomialInOneVariable) {
! 170: printObject(body,0,fp);
! 171: return;
! 172: }
! 173: body = KopPolynomialInOneVariable(body);
! 174: if (body.tag != Sarray) {
! 175: errorKan1("%s\n","Kclass/indeterminate.c, format error for recursive polynomial.");
! 176: }
! 177: if (getoaSize(body) == 0) {
! 178: errorKan1("%s\n","printBodyOfRecursivePolynomial: format error for a recursive polynomial.");
! 179: }
! 180: i = KopInteger(getoa(body,0));
! 181: for (j=1; j<getoaSize(body); j = j+2) {
! 182: k = KopInteger(getoa(body,j));
! 183: if (k != 0) {
! 184: fprintf(fp,"%s",KopString(getoa(vlist,i)));
! 185: if (k > 1) {
! 186: fprintf(fp,"^%d ",k);
! 187: }else if (k == 1) {
! 188: }else{
! 189: fprintf(fp,"^(%d) ",k);
! 190: }
! 191: fprintf(fp," * ");
! 192: }
! 193: fprintf(fp,"(");
! 194: printBodyOfRecursivePolynomial(getoa(body,j+1),vlist,fp);
! 195: fprintf(fp,")");
! 196: if (j != getoaSize(body)-2) {
! 197: fprintf(fp," + ");
! 198: }
! 199: }
! 200: return;
! 201: }
! 202:
! 203: void fprintRecursivePolynomial(FILE *fp,struct object op)
! 204: {
! 205: /* old code
! 206: printObject(KopRecursivePolynomial(op),0,fp); return;
! 207: */
! 208: struct object ob;
! 209: struct object vlist;
! 210: struct object body;
! 211: ob = KopRecursivePolynomial(op);
! 212: if (ob.tag != Sarray) {
! 213: printObject(ob,0,fp); return;
! 214: }
! 215: if (!isRecursivePolynomial2(op)) {
! 216: printObject(KopRecursivePolynomial(op),0,fp); return;
! 217: }
! 218: vlist = getoa(ob,0);
! 219: body = getoa(ob,1);
! 220: printBodyOfRecursivePolynomial(body,vlist,fp);
! 221: return;
! 222: }
! 223:
! 224: /*------------------------------------------*/
! 225:
! 226: struct object KpoPolynomialInOneVariable(struct object ob) {
! 227: struct object rob;
! 228: struct object *newobp;
! 229: rob.tag = Sclass;
! 230: rob.lc.ival = CLASSNAME_polynomialInOneVariable;
! 231: newobp = (struct object *) sGC_malloc(sizeof(struct object));
! 232: if (newobp == NULL) errorKan1("%s\n","Kclass/indeterminate.c, no more memory.");
! 233: if (ob.tag != Sarray) {
! 234: errorKan1("%s\n","Kclass/indeterminate.c, only array object can be transformed into polynomialInOneVariable.");
! 235: }
! 236: *newobp = ob;
! 237: rob.rc.voidp = newobp;
! 238: return(rob);
! 239: }
! 240:
! 241: void fprintPolynomialInOneVariable(FILE *fp,struct object op)
! 242: {
! 243: printObject(KopPolynomialInOneVariable(op),0,fp);
! 244: }
! 245:
! 246: struct object polyToRecursivePoly(struct object p) {
! 247: struct object rob = NullObject;
! 248: int vx[N0], vd[N0];
! 249: int i,j,k,n,count;
! 250: POLY f;
! 251: struct object vlist,vlist2;
! 252: struct object ob1,ob2,ob3,ob4;
! 253: int vn;
! 254:
! 255: if (p.tag != Spoly) return(rob);
! 256: f = KopPOLY(p);
! 257: if (f == ZERO) {
! 258: rob = p; return(rob);
! 259: }
! 260: /* construct list of variables. */
! 261: for (i=0; i<N0; i++) {
! 262: vx[i] = vd[i] = 0;
! 263: }
! 264: n = f->m->ringp->n; count = 0;
! 265: for (i=0; i<n; i++) {
! 266: if (pDegreeWrtV(f,cxx(1,i,1,f->m->ringp))) {
! 267: vx[i] = 1; count++;
! 268: }
! 269: if (pDegreeWrtV(f,cdd(1,i,1,f->m->ringp))) {
! 270: vd[i] = 1; count++;
! 271: }
! 272: }
! 273: vlist = newObjectArray(count); k = 0;
! 274: vlist2 = newObjectArray(count); k = 0;
! 275: for (i=0; i<n; i++) {
! 276: if (vd[i]) {
! 277: putoa(vlist,k,KpoPOLY(cdd(1,i,1,f->m->ringp)));
! 278: putoa(vlist2,k,KpoString(POLYToString(cdd(1,i,1,f->m->ringp),'*',0)));
! 279: k++;
! 280: }
! 281: }
! 282: for (i=0; i<n; i++) {
! 283: if (vx[i]) {
! 284: putoa(vlist,k,KpoPOLY(cxx(1,i,1,f->m->ringp)));
! 285: putoa(vlist2,k,KpoString(POLYToString(cxx(1,i,1,f->m->ringp),'*',0)));
! 286: k++;
! 287: }
! 288: }
! 289: /* printObject(vlist,1,stdout); */
! 290: if (getoaSize(vlist) == 0) {
! 291: vn = -1;
! 292: }else{
! 293: vn = 0;
! 294: }
! 295: ob1 = polyToRecursivePoly2(p,vlist,vn);
! 296: rob = newObjectArray(2);
! 297: putoa(rob,0,vlist2); putoa(rob,1,ob1);
! 298: /* format of rob
! 299: [ list of variables, poly or universalNumber or yyy to express
! 300: a recursive polynomial. ]
! 301: format of yyy = CLASSNAME_polynomialInOneVariable
! 302: [Sinteger, Sinteger, coeff obj, Sinteger, coeff obj, .....]
! 303: name of var, exp, coeff, exp, coeff
! 304: This format is checked by isRecursivePolynomial2().
! 305: */
! 306: rob = KpoRecursivePolynomial(rob);
! 307: if (isRecursivePolynomial2(rob)) {
! 308: return(rob);
! 309: }else{
! 310: errorKan1("%s\n","polyToRecursivePolynomial could not translate this object.");
! 311: }
! 312: }
! 313:
! 314: static void objectFormatError_ind0(char *s) {
! 315: char tmp[1024];
! 316: sprintf(tmp,"polyToRecursivePoly2: object format error for the variable %s",s);
! 317: errorKan1("%s\n",tmp);
! 318: }
! 319:
! 320: struct object polyToRecursivePoly2(struct object p,struct object vlist, int vn) {
! 321: struct object rob = NullObject;
! 322: POLY f;
! 323: POLY vv;
! 324: struct object v;
! 325: struct object c;
! 326: struct object e;
! 327: int i;
! 328:
! 329:
! 330: if (p.tag != Spoly) return(rob);
! 331: f = KopPOLY(p);
! 332: if (f == ZERO) {
! 333: rob = p; return(rob);
! 334: }
! 335: if (vn < 0 || vn >= getoaSize(vlist)) {
! 336: return(coeffToObject(f->coeffp));
! 337: }
! 338: v = getoa(vlist,vn);
! 339: if (v.tag != Spoly) objectFormatError_ind0("v");
! 340: vv = KopPOLY(v);
! 341: c = parts2(f,vv);
! 342: e = getoa(c,0); /* exponents. Array of integer. */
! 343: if (e.tag != Sarray) objectFormatError_ind0("e");
! 344: c = getoa(c,1); /* coefficients. Array of POLY. */
! 345: if (c.tag != Sarray) objectFormatError_ind0("c");
! 346: rob = newObjectArray(getoaSize(e)*2+1);
! 347:
! 348: putoa(rob,0,KpoInteger(vn)); /* put the variable number. */
! 349: for (i=0; i < getoaSize(e); i++) {
! 350: putoa(rob,1+i*2, getoa(e,i));
! 351: putoa(rob,1+i*2+1, polyToRecursivePoly2(getoa(c,i),vlist,vn+1));
! 352: }
! 353: /* printObject(rob,0,stderr); */
! 354: return(KpoPolynomialInOneVariable(rob));
! 355: }
! 356:
! 357: static int isRecursivePolynomial2a(struct object ob2, int n) {
! 358: char *s = "Format error (isRecursivePolynomial2a) : ";
! 359: struct object tmp;
! 360: int i;
! 361: if (ectag(ob2) == CLASSNAME_polynomialInOneVariable) {
! 362: ob2 = KopPolynomialInOneVariable(ob2);
! 363: }else if (ob2.tag == Sarray) {
! 364: fprintf(stderr,"isRecursivePolynomial2, argument is an array.\n");
! 365: printObject(ob2,0,stderr);
! 366: fprintf(stderr,"\n");
! 367: return(0); /* Array must be an error, but other objects are OK. */
! 368: }else {
! 369: return(1);
! 370: }
! 371: if (ob2.tag != Sarray) {
! 372: return(1);
! 373: /* coeff can be any. */
! 374: }
! 375: if (getoaSize(ob2) % 2 == 0) {
! 376: fprintf(stderr,"%s list body. The size of body must be odd.\n",s); printObject(ob2,1,stderr);
! 377: return(0);
! 378: }
! 379: tmp = getoa(ob2,0);
! 380: if (tmp.tag != Sinteger) {
! 381: fprintf(stderr,"%s list body. body[0] must be integer.\n",s); printObject(ob2,1,stderr);
! 382: return(0);
! 383: }
! 384: if (KopInteger(tmp) < 0 || KopInteger(tmp) >= n) {
! 385: fprintf(stderr,"%s list body. body[0] must be integer between 0 and the size of vlist -1.\n",s); printObject(ob2,1,stderr);
! 386: return(0);
! 387: }
! 388: for (i=1; i<getoaSize(ob2); i = i+2) {
! 389: tmp = getoa(ob2,i);
! 390: if (tmp.tag != Sinteger) {
! 391: fprintf(stderr,"%s [list vlist, list body]. body[%d] must be integer.\n",s,i);
! 392: printObject(ob2,1,stderr);
! 393: return(0);
! 394: }
! 395: }
! 396: for (i=2; i<getoaSize(ob2); i = i+2) {
! 397: tmp = getoa(ob2,i);
! 398: if (ectag(tmp) == CLASSNAME_polynomialInOneVariable) {
! 399: if (isRecursivePolynomial2a(tmp,n)) {
! 400: }else{
! 401: fprintf(stderr,"isRecursivePolynomial2a: entry is not a polynomial in one variable.\n");
! 402: printObject(tmp,0,stderr); fprintf(stderr,"\n");
! 403: return(0);
! 404: }
! 405: }
! 406: }
! 407: return(1);
! 408: }
! 409:
! 410: int isRecursivePolynomial2(struct object ob) {
! 411: /* This checks only the top level */
! 412: char *s = "Format error (isRecursivePolynomial2) : ";
! 413: struct object ob1, ob2,tmp;
! 414: int i;
! 415: int n;
! 416: if (ob.tag != Sclass) return(0);
! 417: if (ectag(ob) != CLASSNAME_recursivePolynomial) return(0);
! 418: ob = KopRecursivePolynomial(ob);
! 419: if (ob.tag != Sarray) {
! 420: fprintf(stderr,"%s [vlist, body]\n",s); printObject(ob,1,stderr);
! 421: return(0);
! 422: }
! 423: if (getoaSize(ob) != 2) {
! 424: fprintf(stderr,"%s [vlist, body]. The length must be 2. \n",s);
! 425: printObject(ob,1,stderr);
! 426: return(0);
! 427: }
! 428: ob1 = getoa(ob,0);
! 429: ob2 = getoa(ob,1);
! 430: if (ob1.tag != Sarray) {
! 431: fprintf(stderr,"%s [list vlist, body].\n",s); printObject(ob,1,stderr);
! 432: return(0);
! 433: }
! 434: n = getoaSize(ob1);
! 435: for (i=0; i<n; i++) {
! 436: tmp = getoa(ob1,i);
! 437: if (tmp.tag != Sdollar) {
! 438: fprintf(stderr,"%s [list vlist, body]. Element of the vlist must be a string.\n",s); printObject(ob,1,stderr);
! 439: return(0);
! 440: }
! 441: }
! 442: return(isRecursivePolynomial2a(ob2,n));
! 443: }
! 444:
! 445:
! 446: struct object coeffToObject(struct coeff *cp) {
! 447: struct object rob = NullObject;
! 448: switch(cp->tag) {
! 449: case INTEGER:
! 450: rob = KpoInteger( coeffToInt(cp) );
! 451: return(rob);
! 452: break;
! 453:
! 454: case MP_INTEGER:
! 455: rob.tag = SuniversalNumber;
! 456: rob.lc.universalNumber = newUniversalNumber2((cp->val).bigp);
! 457: return(rob);
! 458: break;
! 459:
! 460: case POLY_COEFF:
! 461: rob = KpoPOLY((cp->val).f);
! 462: return(rob);
! 463: break;
! 464:
! 465: default:
! 466: return(rob);
! 467: }
! 468: }
! 469:
! 470:
! 471: struct object recursivePolyToPoly(struct object rp) {
! 472: struct object rob = NullObject;
! 473: POLY f;
! 474: errorKan1("%s\n","recursivePolyToPoly() has not yet been implemented. Use ascii parsing or sm1 macros to reconstruct a polynomial.");
! 475:
! 476: return(rob);
! 477: }
! 478:
! 479:
! 480:
! 481:
! 482:
! 483:
! 484:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to indeterminate.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM / src / kan96xx / Kan / Kclass