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