Return to sugar.c CVS log

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

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

1.2     ! takayama    1: /* $OpenXM$ */
1.1       maekawa     2: #include <stdio.h>
                      3: #include "datatype.h"
                      4: #include "extern2.h"
                      5: #include "gradedset.h"
                      6:
                      7: #define mymax(p,q) (p>q?p:q)
                      8:
                      9: static int DebugReduction = 0;
                     10:
                     11: POLY reduction_sugar(POLY f,struct gradedPolySet *gset,int needSyz,
                     12:                     struct syz0 *syzp,int sugarGrade)
                     13: {
                     14:   int reduced,reduced1,reduced2;
                     15:   int grd;
                     16:   struct polySet *set;
                     17:   POLY cf,syz;
                     18:   int i;
                     19:   POLY cc,cg;
                     20:   int gradelimit;
                     21:   int tdegm;
                     22:
                     23:   extern struct ring *CurrentRingp;
                     24:   struct ring *rp;
                     25:
                     26:   if (needSyz) {
                     27:     if (f ISZERO) { rp = CurrentRingp; } else { rp = f->m->ringp; }
                     28:     cf = cxx(1,0,0,rp);
                     29:     syz = ZERO;
                     30:   }
                     31:
                     32:   reduced = 0; /* no */
                     33:   /* Take minimum */
                     34:   gradelimit = (gset->maxGrade < sugarGrade+1 ?gset->maxGrade: sugarGrade+1);
                     35:   do {
                     36:     reduced1 = 0; /* no */
                     37:     grd = 0;
                     38:     while (grd < gset->maxGrade) {
                     39:       set = gset->polys[grd];
                     40:       do {
                     41:        reduced2 = 0; /* no */
                     42:        for (i=0; i<set->size; i++) {
                     43:          if (f ISZERO) goto ss;
                     44:          if ((*isReducible)(f,set->g[i])) {
                     45:            tdegm = grade_gen(f) - grade_gen(set->g[i]);
                     46:            /* Reduce if and only if sugarGrade does not increase. */
                     47:            if (tdegm+grd <= sugarGrade) {
                     48:              f = reduction1_sugar(f,set->g[i],needSyz,&cc,&cg,sugarGrade);
                     49:              if (needSyz) {
                     50:                cf = ppMult(cc,cf);
                     51:                syz = cpMult(toSyzCoeff(cc),syz);
                     52:                syz = ppAddv(syz,toSyzPoly(cg,grd,i));
                     53:              }
                     54:              reduced = reduced1 = reduced2 = 1; /* yes */
                     55:            }
                     56:          }
                     57:        }
                     58:       } while (reduced2 != 0);
                     59:       grd++;
                     60:     }
                     61:   }while (reduced1 != 0);
                     62:
                     63:   ss: ;
                     64:   if (needSyz) {
                     65:     syzp->cf = cf;   /* cf is in the CurrentRingp */
                     66:     syzp->syz = syz; /* syz is in the SyzRingp */
                     67:   }
                     68:   return(f);
                     69: }
                     70:
                     71: POLY reduction1_sugar(f,g,needSyz,c,h,sugarGrade)
                     72: POLY f;
                     73: POLY g;
                     74: int needSyz;
                     75: POLY *c; /* set */
                     76: POLY *h; /* set */
                     77: int sugarGrade;
                     78: /* f must be reducible by g.  r = c*f + h*g */
                     79: {
                     80:   extern struct ring *CurrentRingp;
                     81:   struct ring *rp;
                     82:   struct spValue sv;
                     83:   POLY f2;
                     84:   int grd,ggrd,tdegm;
                     85:
                     86:
                     87:   if (needSyz) {
                     88:     if (f ISZERO) { rp = CurrentRingp; } else {rp = f->m->ringp; }
                     89:     *c = cxx(1,0,0,rp);
                     90:     *h = ZERO;
                     91:   }
                     92:
                     93:   sv = (*sp)(f,g);
                     94:   f2 = ppAddv(cpMult((sv.a)->coeffp,f),ppMult(sv.b,g));
                     95:   if (DebugReduction) {
                     96:     printf("c=%s, d=%s, g=%s:  f --> c*f + d*g.\n",
                     97:           POLYToString(sv.a,'*',1),POLYToString(sv.b,'*',1),POLYToString(g,'*',1));
                     98:     printf("%s --> %s\n",POLYToString(f,'*',1),POLYToString(f2,'*',1));
                     99:   }
                    100:   f = f2;
                    101:   if (needSyz) {
                    102:     *c = ppMult(sv.a,*c);
                    103:     *h = ppAdd(ppMult(sv.a,*h),sv.b);
                    104:   }
                    105:
                    106:   grd = grade_sugar(g); ggrd = grade_gen(g);
                    107:   while ((*isReducible)(f,g)) {
                    108:     tdegm = grade_gen(f) - ggrd;
                    109:     /* Reduce if and only if sugarGrade does not increase. */
                    110:     if (tdegm+grd <= sugarGrade) {
                    111:       sv = (*sp)(f,g);
                    112:       f2 = ppAddv(cpMult((sv.a)->coeffp,f),ppMult(sv.b,g));
                    113:       if (DebugReduction) {
                    114:        printf("! c=%s, d=%s, g=%s:  f --> c*f + d*g.\n",
                    115:               POLYToString(sv.a,'*',1),POLYToString(sv.b,'*',1),POLYToString(g,'*',1));
                    116:        printf("%s --> %s\n",POLYToString(f,'*',1),POLYToString(f2,'*',1));
                    117:       }
                    118:       f = f2;
                    119:       if (needSyz) {
                    120:        *c = ppMult(sv.a,*c);
                    121:        *h = ppAdd(ppMult(sv.a,*h),sv.b);
                    122:       }
                    123:     }else{
                    124:       break;
                    125:     }
                    126:   }
                    127:   return(f);
                    128: }
                    129:
                    130: int grade_sugar(f)
                    131: POLY f;
                    132: {
                    133:   int r;
                    134:   int i,ans;
                    135:   MONOMIAL tf;
                    136:   static int nn,mm,ll,cc,n,m,l,c;
                    137:   static struct ring *cr = (struct ring *)NULL;
                    138:
                    139:   if (f ISZERO) return(-1);
                    140:   tf = f->m;
                    141:   if (tf->ringp != cr) {
                    142:     n = tf->ringp->n;
                    143:     m = tf->ringp->m;
                    144:     l = tf->ringp->l;
                    145:     c = tf->ringp->c;
                    146:     nn = tf->ringp->nn;
                    147:     mm = tf->ringp->mm;
                    148:     ll = tf->ringp->ll;
                    149:     cc = tf->ringp->cc;
                    150:     cr = tf->ringp;
                    151:   }
                    152:
                    153:   ans = 0;
                    154:   while (f != NULL) {
                    155:     r = 0;
                    156:     tf = f->m;
                    157:     for (i=0; i<cc; i++) {
                    158:       r += tf->e[i].x;
                    159:       r += tf->e[i].D;
                    160:     }
                    161:     for (i=c; i<ll; i++) {
                    162:       r += tf->e[i].x;
                    163:       r += tf->e[i].D;
                    164:     }
                    165:     for (i=l; i<mm; i++) {
                    166:       r += tf->e[i].x;
                    167:       r += tf->e[i].D;
                    168:     }
                    169:     for (i=m; i<nn; i++) {
                    170:       r += tf->e[i].x;
                    171:       r += tf->e[i].D;
                    172:     }
                    173:     f = f->next;
                    174:     ans = (ans>r?ans:r);
                    175:   }
                    176:   return(ans);
                    177: }