[BACK]Return to gradedset.h CVS log [TXT][DIR] Up to [local] / OpenXM / src / kan96xx / Kan

Annotation of OpenXM/src/kan96xx/Kan/gradedset.h, Revision 1.1

1.1     ! maekawa     1: /* gradedset.h */
        !             2: #define max(a,b) (a>b?a:b)
        !             3:
        !             4: /* You may use only ppAdd() and cpMult() for the elements of SyzRingp. */
        !             5: #define srGrade(s) ((s)->m->e[0].x)  /* s is in the SyzRingp */
        !             6: #define srIndex(s) ((s)->m->e[0].D)
        !             7: #define srSyzCoeffToPOLY(s) ((s)->val.f)
        !             8:
        !             9:
        !            10: /* gradedset.c */
        !            11: void errorGradedSet(char *s);
        !            12: void warningGradedSet(char *s);
        !            13: struct polySet *newPolySet(int n);
        !            14: struct pair *newPair(struct pair *prev);
        !            15: struct pair *pairCopy(struct pair *node);
        !            16: struct gradedPolySet *newGradedPolySet(int n);
        !            17: struct gradedPairs *newGradedPairs(int n);
        !            18: struct gradedPairs *enlargeGradedPairs(int size,struct gradedPairs *grD);
        !            19: void insertPair(struct pair *inode,struct pair *before);
        !            20:                   /* insert inode after before */
        !            21: struct pair *deletePair(struct pair *p); /* delete p->next and returns
        !            22:                                            p->next */
        !            23: struct pair *getPair(struct gradedPairs *grD);
        !            24: void whereInG(struct gradedPolySet *g, POLY fi, int *gradep, int *indexp,int sugar);
        !            25: struct gradedPolySet *putPolyInG(struct gradedPolySet *g, POLY fi, int grade,
        !            26:                                 int index,struct syz0 *syz,int mark,int serial);
        !            27: void markRedundant(struct gradedPolySet *g,POLY gt,int grade,int index,int sugar);
        !            28: void markRedundant0(struct gradedPolySet *g,int grade,int index);
        !            29: struct syz0 *newSyz0(void);
        !            30: struct gradedPairs *putPairInGradedPairs(struct gradedPairs *grP,
        !            31:                                         struct pair *top);
        !            32: void outputGradedPolySet(struct gradedPolySet *grG,int needSyz);
        !            33: void outputGradedPairs(struct gradedPairs *grP);
        !            34: void outputNode(struct pair *p);
        !            35: int countPairs(struct gradedPairs *grD);
        !            36: int countGradedPolySet(struct gradedPolySet *grD);
        !            37: struct gradedPolySet *gradedPolySetCopy(struct gradedPolySet *grG);
        !            38: int deletePairByCriterion2B(struct gradedPairs *grD,POLY gt,struct gradedPolySet *grG);
        !            39:
        !            40: /* red.c */
        !            41: struct spValue (*sp)(POLY f,POLY g);
        !            42: int (*isReducible)(POLY f,POLY g);
        !            43: POLY (*reduction1)(POLY f,POLY g,int needSyz,POLY *cc,POLY *cg);
        !            44: /*  if needSyz, then  result = *cc f + *cg g. */
        !            45: /* syzp->cf is in the CurrentRignp and syzp->syz is in the SyzRingp. */
        !            46: POLY (*reduction)(POLY f,struct gradedPolySet *gset,int needSyz,
        !            47:                  struct syz0 *syzp);
        !            48: POLY (*isCdrReducible)(POLY f,POLY g);
        !            49: POLY (*reduction1Cdr)(POLY f,POLY fs,POLY g,int needSyz,POLY *cc,POLY *cg);
        !            50: /*  if needSyz, then  result = *cc f + *cg g. */
        !            51: POLY (*reductionCdr)(POLY f,struct gradedPolySet *gset,int needSyz,
        !            52:                  struct syz0 *syzp);
        !            53: POLY (*lcm)(POLY f,POLY g);
        !            54: POLY reduction1_gen(POLY f,POLY g,int needSyz,POLY *cc,POLY *cg);
        !            55: POLY reduction1_gen_debug(POLY f,POLY g,int needSyz,POLY *cc,POLY *cg);
        !            56: POLY reduction1_sugar(POLY f,POLY g,int needSyz,POLY *c,POLY *h,int sugarGrade);
        !            57: int isReducible_gen(POLY f,POLY g);
        !            58: POLY reduction_gen(POLY f,struct gradedPolySet *gset,int needSyz,
        !            59:                   struct syz0 *syzp);
        !            60: POLY reduction_gen_rev(POLY f,struct gradedPolySet *gset,int needSyz,
        !            61:                   struct syz0 *syzp);
        !            62: POLY reduction_sugar(POLY f,struct gradedPolySet *gset,int needSyz,
        !            63:                     struct syz0 *syzp,int sugarGrade);
        !            64: POLY reduction1Cdr_gen(POLY f,POLY fs,POLY g,int needSyz,POLY *cc,POLY *cg);
        !            65: POLY isCdrReducible_gen(POLY f,POLY g);
        !            66: POLY reductionCdr_gen(POLY f,struct gradedPolySet *gset,int needSyz,
        !            67:                   struct syz0 *syzp);
        !            68: POLY lcm_gen(POLY f,POLY g);
        !            69: struct spValue sp_gen(POLY f,POLY g);
        !            70: struct spValue sp_q(POLY f,POLY g);
        !            71: int grade_gen(POLY f);
        !            72:
        !            73: /* constructor */
        !            74: POLY toSyzPoly(POLY cg,int grade,int index);
        !            75: struct coeff *toSyzCoeff(POLY f);
        !            76: void initSyzRingp(void);
        !            77:
        !            78: /* gb.c */
        !            79: struct gradedPolySet *(*groebner)(struct arrayOfPOLY *f,
        !            80:                                  int needBack,
        !            81:                                  int needSyz, struct pair **grP,
        !            82:                                  int countDown,int forceReduction);
        !            83: struct gradedPolySet *groebner_gen(struct arrayOfPOLY *f,
        !            84:                                  int needBack,
        !            85:                                  int needSyz, struct pair **grP,
        !            86:                                  int countDown,int forceReduction);
        !            87: struct gradedPairs *updatePairs(struct gradedPairs *grD, POLY gt,
        !            88:                                int gtGrade, int t,
        !            89:                                struct gradedPolySet *grG);
        !            90: /* add gt to grD. gt is indexed by (gtGrade,t) */
        !            91:
        !            92: /* gbGM.c */
        !            93: struct gradedPolySet *groebner_gm(struct arrayOfPOLY *f,
        !            94:                                  int needBack,
        !            95:                                  int needSyz, struct pair **grP,
        !            96:                                  int countDown,int forceReduction);
        !            97:
        !            98: /* syz0 */
        !            99: void simplifyBT(int grd,int index, struct gradedPolySet *grG);
        !           100: /* grG->polys[i]->syz[j],mark[j] is modified. */
        !           101:
        !           102: void getBackwardTransformation(struct gradedPolySet *grG);
        !           103: /* grG->polys[i]->syz[j],mark[j] is modified. */
        !           104:
        !           105: struct arrayOfPOLY *getSyzygy0(struct gradedPolySet *grG,
        !           106:                               struct pair *zeroPairs);
        !           107: /* grG->polys[i]->mark[j] are modified.
        !           108:    grG->polys[i]->del[j] and syz[j] must be set.
        !           109:    syz[j] is the result of the reduction by grBases.  cf. getSyzygy(). */
        !           110:
        !           111: struct matrixOfPOLY *getSyzygy(struct gradedPolySet *grG,struct pair *zp,
        !           112:                               struct gradedPolySet **grBasesp,
        !           113:                               struct matrixOfPOLY **backwardMatp);
        !           114: /* grBasesp is also returned. */
        !           115:
        !           116: POLY getSyzPolyFromSp(struct pair *spij,struct gradedPolySet *grG);
        !           117: /* del and syz of grG and grBases must be properly set. mark of grG
        !           118:    will be modified. */
        !           119:
        !           120: struct matrixOfPOLY *getBackwardMatrixOfPOLY(struct gradedPolySet *grG);
        !           121: /* get B */
        !           122:
        !           123: struct matrixOfPOLY *getSyzygy1(struct matrixOfPOLY *b,struct matrixOfPOLY *nc,
        !           124:                                struct arrayOfPOLY *dc);
        !           125:
        !           126: struct matrixOfPOLY *getNC(struct gradedPolySet *newG,int n,
        !           127:                           struct gradedPolySet *grBases);
        !           128: /* get the numerator of C */
        !           129:
        !           130: struct arrayOfPOLY *getDC(struct gradedPolySet *newG);
        !           131: /* diag(DC) f + C G = 0. */
        !           132:
        !           133: void errorSyz0(char *s);
        !           134:
        !           135: /* conversion */
        !           136: struct arrayOfPOLY *syzPolyToArrayOfPOLY(int size,POLY f,
        !           137:                                         struct gradedPolySet *grG);
        !           138: /* f is in SyzRingp. */
        !           139:
        !           140:
        !           141: #define checkRingSp(f,g,r) {\
        !           142:   if ((f)->m->ringp != (g)->m->ringp) {\
        !           143:     warningPoly("f and g must be in a same ring. Returns 0.\n");\
        !           144:     fprintf(stderr,"f=%s\n",POLYToString(f,'*',0));\
        !           145:     fprintf(stderr,"g=%s\n",POLYToString(g,'*',0));\
        !           146:     r.a = ZERO; r.b = ZERO;\
        !           147:     return(r);\
        !           148:     }\
        !           149: }
        !           150:
        !           151: #define checkRingIsR(f,g) {\
        !           152:   if ((f)->m->ringp != (g)->m->ringp) {\
        !           153:     warningPoly("f and g must be in a same ring. Returns 0.\n");\
        !           154:     fprintf(stderr,"f=%s\n",POLYToString(f,'*',0));\
        !           155:     fprintf(stderr,"g=%s\n",POLYToString(g,'*',0));\
        !           156:     return(0);\
        !           157:     }\
        !           158: }
        !           159:

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>