Return to sugar.c CVS log

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

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

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