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

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: