Return to test.c CVS log

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

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

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