Return to trash.c CVS log

Up to [local] / OpenXM / src / kan96xx / Kan

Annotation of OpenXM/src/kan96xx/Kan/trash.c, Revision 1.1

1.1     ! maekawa     1: struct object gradedPolySetToGradedArray(struct gradedPolySet *gps,
        !             2:                                         int keepRedundant);
        !             3: struct gradedPolySet *gradedArrayToGradedPolySet(struct object ob);
        !             4:
        !             5: struct object gradedPolySetToGradedArray(gps,keepRedundant)
        !             6: struct gradedPolySet *gps;
        !             7: int keepRedundant;
        !             8: {
        !             9:   struct object ob,vec;
        !            10:   int i;
        !            11:   if (gps == (struct gradedPolySet *)NULL) return(NullObject);
        !            12:   ob = newObjectArray(gps->maxGrade +1);
        !            13:   vec = newObjectArray(gps->maxGrade);
        !            14:   for (i=0; i<gps->maxGrade; i++) {
        !            15:     putoa(vec,i,KpoInteger(i));
        !            16:     putoa(ob,i+1,polySetToArray(gps->polys[i],keepRedundant));
        !            17:   }
        !            18:   putoa(ob,0,vec);
        !            19:   return(ob);
        !            20: }
        !            21:
        !            22: struct gradedPolySet *gradedArrayToGradedPolySet(ob)
        !            23: struct object ob;
        !            24: {
        !            25:   int n,max,i,j;
        !            26:   struct object vec,gvec;
        !            27:   struct gradedPolySet *grG;
        !            28:   POLY f;
        !            29:   int grd,ind;
        !            30:   if (ob.tag != Sarray) errorKan1("%s\n","gradedArrayToGradedPolySet(): the argument must be an array.");
        !            31:   n = getoaSize(ob);
        !            32:   if (n<2) return(arrayToGradedPolySet(ob));
        !            33:   if (getoa(ob,0).tag != Sarray) return(arrayToGradedPolySet(ob));
        !            34:   if (n-1 != getoaSize(getoa(ob,0)))
        !            35:     errorKan1("%s\n","gradedArrayToGradedPolySet(): the sizes of arrays mismatch.");
        !            36:   max = 0; n--;
        !            37:   gvec = getoa(ob,0); /* grade vector */
        !            38:   for (i=0; i<n; i++) {
        !            39:     if (getoa(gvec,i).tag != Sinteger)
        !            40:       errorKan1("%s\n","gradedArrayToGradedPolySet(): the first argument must be a vector of grades.");
        !            41:     if (KopInteger(getoa(gvec,i)) > max) max = KopInteger(getoa(gvec,i));
        !            42:   }
        !            43:   grG = newGradedPolySet(max+1);
        !            44:   j = 0;
        !            45:   for (i=0; i<grG->lim;i++) {
        !            46:     if (i == KopInteger(getoa(gvec,i))) {
        !            47:       j++;
        !            48:       if (getoa(ob,j).tag != Sarray) errorKan1("%s\n","gradedArrayToGradedPolySet(): the argument must be an array of polynomials.");
        !            49:       grG->polys[i] = newPolySet(getoaSize(getoa(ob,j)));
        !            50:     }else {
        !            51:       grG->polys[i] = newPolySet(0);
        !            52:     }
        !            53:   }
        !            54:   for (i=0; i<n; i++) {
        !            55:     vec = getoa(ob,i+1);
        !            56:     for (j=0; j<getoaSize(vec);j++) {
        !            57:       if (getoa(vec,j).tag != Spoly) {
        !            58:        errorKan1("%s(%d,%d)\n","gradedArrayToGradedPolySet(): the element must be polynomial. (i,j)=");
        !            59:       }
        !            60:       f = KopPOLY(getoa(vec,j));
        !            61:       whereInG(grG,f,&grd,&ind);
        !            62:       grG = putPolyInG(grG,f,grd,ind,(struct syz0 *)NULL,1);
        !            63:     }
        !            64:   }
        !            65:   return(grG);
        !            66: }
        !            67:
        !            68:
        !            69:   static int tmpOrder[] =
        !            70: /*
        !            71:    0    1    2    3    4    5    6    7    8    9   10   11
        !            72:   x5   x4   x3   x2   x1   x0   D5   D4   D3   D2   D1   D0
        !            73: */
        !            74:   {
        !            75:    1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
        !            76:    0,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   0,
        !            77:    0,   0,   0,   0,   0,  -1,   0,   0,   0,   0,   0,   0,
        !            78:    0,   0,   0,   0,  -1,   0,   0,   0,   0,   0,   0,   0,
        !            79:    0,   0,   0,  -1,   0,   0,   0,   0,   0,   0,   0,   0,
        !            80:    0,   0,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,
        !            81:    0,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
        !            82:    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  -1,   0,
        !            83:    0,   0,   0,   0,   0,   0,   0,   0,   0,  -1,   0,   0,
        !            84:    0,   0,   0,   0,   0,   0,   0,   0,  -1,   0,   0,   0,
        !            85:    0,   0,   0,   0,   0,   0,   0,  -1,   0,   0,   0,   0,
        !            86:    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   1};
        !            87:
        !            88:
        !            89:   /* tmp code */
        !            90:   TransX[0] = "x0"; TransX[1] = "x1"; TransX[2] = "x2";
        !            91:   TransX[3] = "x3"; TransX[4] = "x4"; TransX[5] = "t";
        !            92:
        !            93:   TransD[0] = "h"; TransD[1] = "D1"; TransD[2] = "D2";
        !            94:   TransD[3] = "D3"; TransD[4] = "D4"; TransD[5] = "T";
        !            95:
        !            96:   CurrentRingp = (struct ring *)GC_malloc(sizeof(struct ring));
        !            97:   CurrentRingp->p = P;
        !            98:   CurrentRingp->n = N; CurrentRingp->m = M; CurrentRingp->l = L; CurrentRingp->c = C;
        !            99:   CurrentRingp->nn = NN; CurrentRingp->mm = MM; CurrentRingp->ll = LL;
        !           100:   CurrentRingp->cc = CC;
        !           101:   CurrentRingp->x = TransX;
        !           102:   CurrentRingp->D = TransD;
        !           103:   CurrentRingp->order = tmpOrder;
        !           104:   CurrentRingp->next = (struct ring *)NULL;
        !           105:   Order = tmpOrder;