Annotation of OpenXM/src/kan96xx/Kan/poly.c, Revision 1.1.1.1
1.1 maekawa 1: #include <stdio.h>
2: #include "datatype.h"
3: #include "stackm.h"
4: #include "extern.h"
5: #include "extern2.h"
6:
7:
8: void KinitKan(void) {
9:
10: extern int Msize;
11: extern struct ring SmallRing;
12: extern struct ring *CurrentRingp;
13: extern MP_INT *Mp_one;
14: extern MP_INT *Mp_zero;
15: extern MP_INT Mp_work_iiComb;
16: extern MP_INT Mp_work_iiPoch;
17: extern MP_INT Mp_work_iiPower;
18:
19: static MP_INT Mp_One;
20: static MP_INT Mp_Zero;
21:
22: extern struct coeff *UniversalZero;
23: extern struct coeff *UniversalOne;
24:
25: int i;
26: static char *smallx[] = {"x","t"};
27: static char *smalld[] = {"h","T"};
28: /* t x T h */
29: static int smallOrder[] = { 1, 0, 0, 0,
30: 0, 1, 0, 0,
31: 0, 0, 1, 0,
32: 0, 0, 0, 1};
33:
34: static int outputOrderForSmallRing[] = {1,0,3,2};
35: Msize = sizeof(struct monomial) - sizeof(struct monomialDummy);
36: if (Msize <= 0) errorPoly("Problem of your C-compiler??!!");
37:
38: /* Define the CurrentRingp */
39: /* Define the SmallRingp */
40:
41: SmallRing.p = 0;
42: SmallRing.n = SmallRing.m = SmallRing.l = SmallRing.c = 2;
43: SmallRing.nn = SmallRing.mm = SmallRing.ll = 2;
44: SmallRing.cc = 1;
45: SmallRing.x = smallx;
46: SmallRing.D = smalld;
47: SmallRing.order = smallOrder;
48: SmallRing.orderMatrixSize = 4;
49: setFromTo(&SmallRing);
50: SmallRing.next = (struct ring *)NULL;
51: SmallRing.multiplication = mpMult_poly;
52: SmallRing.schreyer = 0;
53: SmallRing.gbListTower = NULL;
54: SmallRing.outputOrder = outputOrderForSmallRing;
55: SmallRing.name = "SmallRingp";
56:
57: CurrentRingp = &SmallRing;
58: initSyzRingp();
59:
60: switch_init();
61: initT(); /* Initialize poly3.c */
62:
63:
64: #ifndef NOGC
65: /* initialize MPZ */
66: mp_set_memory_functions(sGC_malloc,sGC_realloc2,sGC_free2);
67: #endif
68:
69: /* Msize is 8 on SUN gcc */
70:
71: /* We have defined a ring. Let's initialize Nodes */
72:
73: Mp_one = &Mp_One;
74: mpz_init(Mp_one); mpz_set_si(Mp_one,(long) 1);
75: Mp_zero = &Mp_Zero;
76: mpz_init(Mp_zero); mpz_set_si(Mp_zero,(long) 0);
77: mpz_init(&Mp_work_iiComb); mpz_init(&Mp_work_iiPoch);
78: mpz_init(&Mp_work_iiPower);
79:
80: UniversalZero = intToCoeff(0,&SmallRing);
81: UniversalOne = intToCoeff(1,&SmallRing);
82:
83: KdefaultPolyRing(KpoInteger(0));
84: }
85:
86: #ifndef NOGC
87: void *sGC_realloc2(void *p,size_t old,size_t new)
88: {
89: return((void *)sGC_realloc(p,(int) new));
90: }
91: void sGC_free2(void *p,size_t size)
92: {
93: /* Do nothing. */
94: }
95: #endif
96:
97:
98: MONOMIAL newMonomial(ringp)
99: struct ring *ringp;
100: {
101: MONOMIAL f;
102: extern int Msize;
103: int i;
104: int n;
105: n = ringp->n;
106: f = (MONOMIAL) sGC_malloc(sizeof(struct smallMonomial)+n*Msize);
107: if (f == (MONOMIAL) NULL) errorPoly("No more memory.");
108: f->ringp = ringp;
109: for (i=0; i<n; i++) {
110: (f->e)[i].x = 0;
111: (f->e)[i].D = 0; /* necessary?->Yes. */
112: }
113: return(f);
114: }
115:
116:
117: MONOMIAL monomialCopy(m)
118: MONOMIAL m;
119: {
120: extern int Msize;
121: MONOMIAL f;
122: int i;
123: int n;
124: n = m->ringp->n;
125: f = (MONOMIAL) sGC_malloc(sizeof(struct smallMonomial)+n*Msize);
126:
127: if (f == (MONOMIAL) NULL) errorPoly("No more memory.");
128: f->ringp = m->ringp;
129: for (i=0; i<n; i++) {
130: (f->e)[i].x = (m->e)[i].x;
131: (f->e)[i].D = (m->e)[i].D;
132: }
133: return(f);
134: }
135:
136:
137: struct coeff *newCoeff() {
138: struct coeff *cp;
139: cp = (struct coeff *)sGC_malloc(sizeof (struct coeff));
140: if (cp == (struct coeff *)NULL) errorPoly("No more memory.");
141: cp->tag = UNKNOWN;
142: cp->p = -123; /* stupid value */
143: return(cp);
144: }
145:
146: MP_INT *newMP_INT() {
147: MP_INT *ip;
148: ip = (MP_INT *)sGC_malloc(sizeof(MP_INT));
149: if (ip == (MP_INT *)NULL) errorPoly("No more memory.");
150: mpz_init(ip);
151: return(ip);
152: }
153:
154: POLY newCell(c,mon)
155: struct coeff *c;
156: MONOMIAL mon;
157: {
158: POLY ff;
159: ff = (POLY) sGC_malloc(sizeof(struct listPoly));
160: if (ff == POLYNULL) errorPoly("No more memory.");
161: ff->next = POLYNULL;
162: ff->coeffp = c;
163: ff->m = mon;
164: return(ff);
165: }
166:
167: /* constructors */
168: POLY cxx(c,i,k,ringp)
169: int c,i,k;
170: struct ring *ringp;
171: /* c x_i^k where p is the characteristic. */
172: /* New cell, monomial and coeff. */
173: {
174: POLY f;
175: int p;
176: p = ringp->p;
177: if (c == 0) return(POLYNULL);
178: f = pMalloc(ringp);
179: if (ringp->next == (struct ring *)NULL) {
180: if (p) {
181: f->coeffp->tag = INTEGER; f->coeffp->p = p;
182: f->coeffp->val.i = c % p;
183: if (f->coeffp->val.i == 0) return(POLYNULL);
184: }else{
185: f->coeffp->tag = MP_INTEGER; f->coeffp->p = 0;
186: f->coeffp->val.bigp = newMP_INT();
187: mpz_set_si(f->coeffp->val.bigp,(long) c);
188: }
189: f->m->e[i].x = k;
190: return(f);
191: }else{
192: f->coeffp->tag = POLY_COEFF; f->coeffp->p = p;
193: f->coeffp->val.f = cxx(c,0,0,ringp->next);
194: if (f->coeffp->val.f == POLYNULL) return(POLYNULL);
195: f->m->e[i].x = k;
196: return(f);
197: }
198: }
199:
200: POLY bxx(c,i,k,ringp)
201: MP_INT *c;
202: int i,k;
203: struct ring *ringp;
204: /* c x_i^k. c is not copied. */
205: {
206: /* new cell, monomial, coeff. MP_INT c is not copied. */
207: POLY f;
208: int p;
209: p = ringp->p;
210: if (mpz_cmp_si(c,(long)0) == 0) return(POLYNULL);
211: f = pMalloc(ringp);
212: if (ringp->next == (struct ring *)NULL) {
213: if (p) {
214: f->coeffp->tag = INTEGER; f->coeffp->p = p;
215: f->coeffp->val.i = (int) mpz_get_si(c);
216: f->coeffp->val.i %= p;
217: if (f->coeffp->val.i == 0) return(POLYNULL);
218: }else{
219: f->coeffp->tag = MP_INTEGER; f->coeffp->p = 0;
220: f->coeffp->val.bigp = c;
221: }
222: f->m->e[i].x = k;
223: return(f);
224: }else{
225: warningPoly("cbb(): ringp->next is not NULL. Returns 0.");
226: return(POLYNULL);
227: }
228: }
229:
230: POLY cdd(c,i,k,ringp)
231: int c,i,k;
232: struct ring *ringp;
233: /* c D_i^k where p is the characteristic. */
234: /* New cell, monomial and coeff. */
235: {
236: POLY f;
237: int p;
238: p = ringp->p;
239: if (c == 0) return(POLYNULL);
240: f = pMalloc(ringp);
241: if (ringp->next == (struct ring *)NULL) {
242: if (p) {
243: f->coeffp->tag = INTEGER; f->coeffp->p = p;
244: f->coeffp->val.i = c % p;
245: if (f->coeffp->val.i == 0) return(POLYNULL);
246: }else{
247: f->coeffp->tag = MP_INTEGER; f->coeffp->p = 0;
248: f->coeffp->val.bigp = newMP_INT();
249: mpz_set_si(f->coeffp->val.bigp,(long) c);
250: }
251: f->m->e[i].D = k;
252: return(f);
253: }else{
254: f->coeffp->tag = POLY_COEFF; f->coeffp->p = p;
255: f->coeffp->val.f = cdd(c,0,0,ringp->next);
256: if (f->coeffp->val.f == POLYNULL) return(POLYNULL);
257: f->m->e[i].D = k;
258: return(f);
259: }
260:
261: }
262:
263:
264: POLY pCopy(f)
265: POLY f;
266: {
267: POLY node;
268: struct listPoly nod;
269: POLY h;
270: node = &nod;
271: if (f == POLYNULL) return(POLYNULL);
272: node->next = POLYNULL;
273: h = node;
274: while (f != POLYNULL) {
275: h->next = newCell(f->coeffp,f->m); /* shallow */
276: h = h->next;
277: f = f->next;
278: }
279: return(node->next);
280: }
281:
282: POLY pcCopy(f)
283: POLY f;
284: {
285:
286: POLY node;
287: struct listPoly nod;
288: POLY h;
289: struct coeff *c;
290: node = &nod;
291: if (f == POLYNULL) return(POLYNULL);
292: node->next = POLYNULL;
293: h = node;
294: while (f != POLYNULL) {
295: c = coeffCopy(f->coeffp);
296: h->next = newCell(c,f->m); /* poly and coeff. */
297: h = h->next;
298: f = f->next;
299: }
300: return(node->next);
301: }
302:
303: POLY pmCopy(f)
304: POLY f;
305: {
306: POLY node;
307: struct listPoly nod;
308: POLY h;
309: struct coeff *c;
310: node = &nod;
311: if (f == POLYNULL) return(POLYNULL);
312: node->next = POLYNULL;
313: h = node;
314: while (f != POLYNULL) {
315: h->next = newCell(f->coeffp,monomialCopy(f->m));
316: h = h->next;
317: f = f->next;
318: }
319: return(node->next);
320: }
321:
322: POLY pcmCopy(f)
323: POLY f;
324: {
325: POLY node;
326: struct listPoly nod;
327: POLY h;
328: struct coeff *c;
329: node = &nod;
330: if (f == POLYNULL) return(POLYNULL);
331: node->next = POLYNULL;
332: h = node;
333: while (f != POLYNULL) {
334: h->next = newCell(coeffCopy(f->coeffp),monomialCopy(f->m));
335: h = h->next;
336: f = f->next;
337: }
338: return(node->next);
339: }
340:
341: POLY head(f)
342: POLY f;
343: {
344: if (f == ZERO) return(f);
345: else {
346: return(newCell(f->coeffp,f->m));
347: }
348: }
349:
350: void errorPoly(str)
351: char *str;
352: {
353: fprintf(stderr,"Error(poly.c): %s\n",str);
354: exit(20);
355: }
356:
357: void warningPoly(str)
358: char *str;
359: {
360: fprintf(stderr,"Warning(poly.c): %s\n",str);
361: }
362:
363:
364:
365:
366:
367:
368:
369:
370:
371:
372:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to poly.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM / src / kan96xx / Kan