Return to test.c CVS log

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

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

1.1     ! maekawa     1: struct object test2(ob)  /* test2 */
        !             2: struct object ob;
        !             3: {
        !             4:   struct object rob;
        !             5:   int k;
        !             6:   static POLY f0;
        !             7:   static POLY f1;
        !             8:
        !             9:   POLY addNode;
        !            10:   POLY f;
        !            11:   int i;
        !            12:   static int s=0;
        !            13:   extern struct ring *SmallRingp;
        !            14:   extern struct ring *CurrentRingp;
        !            15:   addNode = pMalloc(SmallRingp);
        !            16:   k = ob.lc.ival;
        !            17:   switch(s) {
        !            18:   case 0:
        !            19:     f0 = addNode;
        !            20:     for (i=0; i<=k; i++) {
        !            21:       f0->next = cxx(iiComb(k,i,CurrentRingp->p),0,i,CurrentRingp);
        !            22:       f0 = f0->next;
        !            23:     }
        !            24:     f0 = addNode->next;
        !            25:     s++;
        !            26:     rob.lc.poly = f0;
        !            27:     break;
        !            28:   case 1:
        !            29:     f1 = addNode;
        !            30:     for (i=0; i<=k; i++) {
        !            31:       f1->next = bxx(BiiComb(k,i),0,i,SmallRingp);
        !            32:       f1 = f1->next;
        !            33:     }
        !            34:     f1 = addNode->next;
        !            35:     s = 0;
        !            36:     rob.lc.poly = f1;
        !            37:     break;
        !            38:   default:
        !            39:     rob.lc.poly = POLYNULL;
        !            40:     s = 0;
        !            41:     break;
        !            42:   }
        !            43:
        !            44:
        !            45:   rob.tag = Spoly;
        !            46:   return(rob);
        !            47: }
        !            48:
        !            49: struct object test1(ob)
        !            50: struct object ob;
        !            51: {
        !            52:   struct object rob;
        !            53:   int k;
        !            54:   static POLY f0;
        !            55:   static POLY f1;
        !            56:   /* It will dump the core
        !            57:   POLY f0; or = 1;
        !            58:   POLY f1;
        !            59:   */
        !            60:
        !            61:   POLY addNode;
        !            62:   POLY f;
        !            63:   int i;
        !            64:   static int s=0;
        !            65:   extern struct ring *SmallRingp;
        !            66:   extern struct ring *CurrentRingp;
        !            67:   addNode = pMalloc(SmallRingp);
        !            68:   k = ob.lc.ival;
        !            69:   switch(s) {
        !            70:   case 0:
        !            71:     f0 = addNode;
        !            72:     for (i=0; i<k; i++) {
        !            73:       f0->next = cxx(i+1,0,i,CurrentRingp);
        !            74:       f0 = f0->next;
        !            75:     }
        !            76:     f0 = addNode->next;
        !            77:     s++;
        !            78:     rob.lc.poly = f0;
        !            79:     break;
        !            80:   case 1:
        !            81:     f1 = addNode;
        !            82:     for (i=k-1; i>=0; i--) {
        !            83:       f1->next = cxx(-i-1,0,-i,CurrentRingp);
        !            84:       f1 = f1->next;
        !            85:     }
        !            86:     f1 = addNode->next;
        !            87:     s++;
        !            88:     rob.lc.poly = f1;
        !            89:     break;
        !            90:   default:
        !            91:     f = addNode;
        !            92:     f->next = cxx(1,0,1,SmallRingp);
        !            93:     f = f->next;
        !            94:     f->coeffp->tag = POLY_COEFF;
        !            95:     f->coeffp->val.f = f0;
        !            96:     f->next = cxx(1,0,2,SmallRingp);
        !            97:     f = f->next;
        !            98:     f->coeffp->tag = POLY_COEFF;
        !            99:     f->coeffp->val.f = f1;
        !           100:     rob.lc.poly = addNode->next;
        !           101:     s = 0;
        !           102:     break;
        !           103:   }
        !           104:
        !           105:
        !           106:   rob.tag = Spoly;
        !           107:   return(rob);
        !           108: }
        !           109: