Annotation of OpenXM/src/kan96xx/Kan/poly2.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: static POLY mapZmonom(POLY f,struct ring *ringp);
8:
9: POLY ppAdd(f,g)
10: POLY f; POLY g; /* The result is read only. */
11: {
12: POLY node;
13: struct listPoly nod;
14: POLY h;
15: struct coeff *c;
16: int gt;
17:
18: node = &nod;
19: node->next = POLYNULL;
20: h = node;
21: if (f == POLYNULL) return(g);
22: if (g == POLYNULL) return(f);
23: checkRing(f,g);
24:
25: while (f != POLYNULL && g != POLYNULL) {
26: /*printf("%s + %s\n",POLYToString(f,'*',1),POLYToString(g,'*',1));*/
27: checkRing2(f,g); /* for debug */
28: gt = (*mmLarger)(f,g);
29: switch (gt) {
30: case 1: /* f > g */
31: h -> next = newCell(f->coeffp,f->m);
32: h = h->next;
33: f = f->next;
34: if (f == POLYNULL) {
35: h->next = g;
36: return(node->next);
37: }
38: break;
39: case 0: /* f < g */
40: h->next = newCell(g->coeffp,g->m);
41: h = h->next;
42: g = g->next;
43: if (g == POLYNULL) {
44: h->next = f;
45: return(node->next);
46: }
47: break;
48: case 2:/* f == g */
49: c = coeffCopy(f->coeffp);
50: Cadd(c,c,g->coeffp);
51: if (!isZero(c)) {
52: h->next = newCell(c,f->m);
53: h = h->next;
54: f = f->next;
55: g = g->next;
56: if (f == POLYNULL) {
57: h->next = g;
58: return(node->next);
59: }
60: if (g == POLYNULL) {
61: h->next = f;
62: return(node->next);
63: }
64: }else{
65: f = f->next;
66: g = g->next;
67: if (f == POLYNULL) {
68: h->next = g;
69: return(node->next);
70: }
71: if (g == POLYNULL) {
72: h->next = f;
73: return(node->next);
74: }
75: }
76: break;
77: default:
78: errorPoly("ppAdd(). Internal error. Invalid value of mmLarger.");
79: break;
80: }
81: }
82: return(node->next);
83: }
84:
85: POLY ppSub(f,g)
86: POLY f; POLY g; /* The result is read only. */
87: {
88: POLY h;
89: struct coeff *c;
90:
91: if (g == POLYNULL) return(f);
92: if (f == POLYNULL) return(cpMult(intToCoeff(-1,g->m->ringp),g));
93: checkRing(f,g);
94:
95: h = cpMult(intToCoeff(-1,g->m->ringp),g);
96: return(ppAdd(f,h));
97: }
98:
99:
100: POLY cpMult(c,f)
101: struct coeff *c;
102: POLY f;
103: {
104: POLY node;
105: struct listPoly nod;
106: POLY h;
107: struct coeff *newc;
108: int p;
109: node = &nod;
110: if (f == POLYNULL || isZero(c)) return(POLYNULL);
111: p = f->m->ringp->p;
112: node ->next = POLYNULL;
113: h = node;
114: while (f != POLYNULL) {
115: newc = coeffCopy(c);
116: Cmult(newc,newc,f->coeffp);
117: if ((p==0) || !isZero(newc)) {
118: h->next = newCell(newc,f->m);
119: h = h->next;
120: }
121: f = f->next;
122: }
123: return(node->next);
124: }
125:
126: MONOMIAL monomialAdd_poly(m,m2)
127: MONOMIAL m,m2;
128: {
129: extern int Msize;
130: MONOMIAL f;
131: int i;
132: int n;
133: n = m->ringp->n;
134: f = (MONOMIAL) sGC_malloc(sizeof(struct smallMonomial)+n*Msize);
135:
136: if (f == (MONOMIAL) NULL) errorPoly("No more memory.");
137: f->ringp = m->ringp;
138: for (i=0; i<n; i++) {
139: (f->e)[i].x = (m->e)[i].x + (m2->e)[i].x;
140: (f->e)[i].D = (m->e)[i].D + (m2->e)[i].D;
141: }
142: return(f);
143: }
144:
145: /* Note that mpMult_poly is called from mmLarger_tower! */
146: POLY mpMult_poly(f,g)
147: POLY f;
148: POLY g;
149: {
150: POLY node;
151: struct listPoly nod;
152: struct coeff *c;
153: int n,i;
154: POLY h;
155: MONOMIAL m;
156: int p;
157: node = &nod;
158: if (f == POLYNULL || g == POLYNULL) return(POLYNULL);
159: node->next = POLYNULL;
160: h = node;
161: checkRing(f,g);
162: n = f->m->ringp->n; p = f->m->ringp->p;
163: while(g != POLYNULL) {
164: checkRing2(f,g);
165: c = coeffCopy(f->coeffp);
166: Cmult(c,c,g->coeffp);
167: if ((p==0) || !isZero(c)) {
168: m = (*monomialAdd)(f->m,g->m);
169: h->next = newCell(c,m);
170: h = h->next;
171: }
172: g = g->next;
173: }
174: return(node->next);
175: }
176:
177: POLY ppMult_old(f,g)
178: POLY f,g;
179: {
180: POLY r;
181: POLY tmp;
182: r = POLYNULL;
183: while( f != POLYNULL) {
184: tmp = (*mpMult)(f,g);
185: r = ppAddv(r,tmp); /* r and tmp will be broken */
186: f = f->next;
187: }
188: return(r);
189: }
190:
191: POLY ppAddv(f,g)
192: POLY f; POLY g; /* It breaks f and g. Use it just after calling mpMult() */
193: {
194: POLY node;
195: struct listPoly nod;
196: POLY h;
197: struct coeff *c;
198: int gt;
199:
200: node = &nod;
201: /*printf("ppAddv:1%s + %s\n",POLYToString(f,'*',1),POLYToString(g,'*',1));*/
202: node->next = POLYNULL;
203: h = node;
204: if (f == POLYNULL) return(g);
205: if (g == POLYNULL) return(f);
206: checkRing(f,g);
207:
208: while (f != POLYNULL && g != POLYNULL) {
209: checkRing2(f,g); /* for debug */
210: /*printf("%s + %s\n",POLYToString(f,'*',1),POLYToString(g,'*',1));*/
211: gt = (*mmLarger)(f,g);
212: switch (gt) {
213: case 1: /* f > g */
214: h->next = f;
215: h = h->next; f = f->next;;
216: if (f == POLYNULL) {
217: h->next = g;
218: return(node->next);
219: }
220: break;
221: case 0: /* f < g */
222: h->next = g;
223: h = h->next; g = g->next;
224: if (g == POLYNULL) {
225: h->next = f;
226: return(node->next);
227: }
228: break;
229: case 2:/* f == g */
230: c = f->coeffp;
231: Cadd(c,c,g->coeffp);
232: if (!isZero(c)) {
233: h->next = f;
234: h = h->next; f = f->next;;
235: g = g->next;
236: if (f == POLYNULL) {
237: h->next = g;
238: return(node->next);
239: }
240: if (g == POLYNULL) {
241: h->next = f;
242: return(node->next);
243: }
244: }else{
245: f = f->next;
246: g = g->next;
247: if (f == POLYNULL) {
248: h->next = g;
249: return(node->next);
250: }
251: if (g == POLYNULL) {
252: h->next = f;
253: return(node->next);
254: }
255: }
256: break;
257: default:
258: errorPoly("ppAddv(). Internal error. Invalid value of mmLarger.");
259: break;
260: }
261: }
262: return(node->next);
263: }
264:
265: POLY pPower(f,k)
266: POLY f;
267: int k;
268: {
269: POLY r;
270: int i,n;
271: if (f == POLYNULL) return(POLYNULL); /* Is it ok? 0^0 = 0.*/
272: if (k == 0) return(cxx(1,0,0,f->m->ringp));
273: if (f->next == POLYNULL && k<0) {
274: /* when f is monomial. */
275: r = newCell(coeffCopy(f->coeffp),monomialCopy(f->m));
276: n = r->m->ringp->n;
277: for (i=0; i<n; i++) {
278: r->m->e[i].x *= k;
279: r->m->e[i].D *= k;
280: }
281: if (!isOne(r->coeffp)) {
282: warningPoly("pPower(poly,negative integer) not implemented yet. Returns 1.");
283: r = cxx(1,0,0,f->m->ringp);
284: }
285: return(r);
286: }
287: r = cxx(1,0,0,f->m->ringp);
288: if (k < 0) {
289: warningPoly("pPower(poly,negative integer) not implemented yet. Returns 1.");
290: }
291: for (i=0; i<k; i++) {
292: r = ppMult(f,r);
293: }
294: return(r);
295: }
296:
297: POLY pPower_poly(f,k)
298: POLY f;
299: int k;
300: {
301: POLY r;
302: int i,n;
303: if (f == POLYNULL) return(POLYNULL); /* Is it ok? 0^0 = 0.*/
304: if (k == 0) return(cxx(1,0,0,f->m->ringp));
305: if (f->next == POLYNULL && k<0) {
306: /* when f is monomial. */
307: r = newCell(coeffCopy(f->coeffp),monomialCopy(f->m));
308: n = r->m->ringp->n;
309: for (i=0; i<n; i++) {
310: r->m->e[i].x *= k;
311: r->m->e[i].D *= k;
312: }
313: if (!isOne(r->coeffp)) {
314: warningPoly("pPower_poly(poly,negative integer) not implemented yet. Returns 1.");
315: r = cxx(1,0,0,f->m->ringp);
316: }
317: return(r);
318: }
319: r = cxx(1,0,0,f->m->ringp);
320: if (k < 0) {
321: warningPoly("pPower_poly(poly,negative integer) not implemented yet. Returns 1.");
322: }
323: for (i=0; i<k; i++) {
324: r = ppMult_poly(f,r);
325: }
326: return(r);
327: }
328:
329: POLY modulop_trash(f,ringp)
330: POLY f;
331: struct ring *ringp;
332: {
333: int p;
334: POLY h;
335: MP_INT *c;
336: int cc;
337: POLY node;
338: struct ring *nextRing;
339: POLY fc;
340:
341: if (f == POLYNULL) return(f);
342: p = ringp->p;
343: if (f->m->ringp->p != 0) {
344: warningPoly("modulop(f,ringp) must be called with f in the characteristic 0 ring. Returns 0.");
345: return(POLYNULL);
346: }
347: if (f->m->ringp->n != ringp->n) {
348: warningPoly("modulop(f,ringp): f->m->ringp->n must be equal to ringp->n. Returns 0.");
349: return(POLYNULL);
350: }
351:
352: /* The case of ringp->next != NULL */
353: if (ringp->next != (struct ring *)NULL) {
354: nextRing = ringp->next;
355: node = newCell(newCoeff(),newMonomial(ringp));
356: node->next = POLYNULL;
357: h = node;
358:
359: while (f != POLYNULL) {
360: fc = bxx(f->coeffp->val.bigp,0,0,nextRing);
361: h->next = newCell(newCoeff(),monomialCopy(f->m));
362: h = h->next;
363: h->m->ringp = ringp;
364: h->coeffp->tag = POLY_COEFF;
365: h->coeffp->p = p;
366: h->coeffp->val.f = fc;
367: f = f->next;
368: }
369: return(node->next);
370: }
371:
372:
373: /* In case of ringp->next == NULL */
374: if (p != 0) {
375: c = newMP_INT();
376: node = newCell(newCoeff(),newMonomial(ringp));
377: node->next = POLYNULL;
378: h = node;
379:
380: while (f != POLYNULL) {
381: mpz_mod_ui(c,f->coeffp->val.bigp,(unsigned long int)p);
382: cc = (int) mpz_get_si(c);
383: if (cc != 0) {
384: h->next = newCell(newCoeff(),monomialCopy(f->m));
385: h = h->next;
386: h->m->ringp = ringp;
387: h->coeffp->tag = INTEGER;
388: h->coeffp->p = p;
389: h->coeffp->val.i = cc;
390: }
391: f = f->next;
392: }
393: return(node->next);
394: }else{
395: h = f = pcmCopy(f);
396: while (f != POLYNULL) {
397: f->m->ringp = ringp;
398: f = f->next;
399: }
400: return(h);
401: }
402:
403: }
404:
405: POLY modulop(f,ringp)
406: POLY f;
407: struct ring *ringp;
408: /* Z[x] ---> R[x] where R=Z, Z/Zp, ringp->next. */
409: {
410: int p;
411: POLY h;
412: MP_INT *c;
413: int cc;
414: POLY node;
415: POLY fc;
416:
417: if (f == POLYNULL) return(f);
418: p = ringp->p;
419: if (f->m->ringp->p != 0 || f->m->ringp->next != (struct ring *)NULL) {
420: warningPoly("modulop(f,ringp) must be called with f in the characteristic 0 ring Z[x]. Returns 0.");
421: return(POLYNULL);
422: }
423: if (f->m->ringp->n != ringp->n) {
424: warningPoly("modulop(f,ringp): f->m->ringp->n must be equal to ringp->n. Returns 0.");
425: return(POLYNULL);
426: }
427:
428: /* [1] The case of R = ringp->next */
429: if (ringp->next != (struct ring *)NULL) {
430: h = ZERO;
431: while (f != POLYNULL) {
432: h = ppAdd(h,mapZmonom(f,ringp));
433: f = f->next;
434: }
435: return(h);
436: }
437:
438: /* [2] The case of R = Z/Zp */
439: if (p != 0) {
440: c = newMP_INT();
441: node = newCell(newCoeff(),newMonomial(ringp));
442: node->next = POLYNULL;
443: h = node;
444:
445: while (f != POLYNULL) {
446: mpz_mod_ui(c,f->coeffp->val.bigp,(unsigned long int)p);
447: cc = (int) mpz_get_si(c);
448: if (cc != 0) {
449: h->next = newCell(newCoeff(),monomialCopy(f->m));
450: h = h->next;
451: h->m->ringp = ringp;
452: h->coeffp->tag = INTEGER;
453: h->coeffp->p = p;
454: h->coeffp->val.i = cc;
455: }
456: f = f->next;
457: }
458: return(node->next);
459: }
460:
461: /* [3] The case of R = Z */
462: h = f = pcmCopy(f);
463: while (f != POLYNULL) {
464: f->m->ringp = ringp;
465: f = f->next;
466: }
467: return(h);
468:
469:
470: }
471:
472: POLY modulopZ(f,pcoeff)
473: POLY f;
474: struct coeff *pcoeff;
475: /* Z[x] ---> Z[x] , f ---> f mod pcoeff*/
476: {
477: int p;
478: POLY h;
479: struct coeff *c;
480: int cc;
481: POLY node;
482: POLY fc;
483: MP_INT *bigp;
484: MP_INT *tmp;
485: struct ring *ringp;
486:
487: if (f == POLYNULL) return(f);
488: ringp = f->m->ringp;
489: if (pcoeff->tag != MP_INTEGER) {
490: warningPoly("modulopZ(): pcoeff must be a universalNumber.");
491: warningPoly("Returns 0.");
492: return(POLYNULL);
493: }
494: bigp = pcoeff->val.bigp;
495: if (f->m->ringp->p != 0 || f->m->ringp->next != (struct ring *)NULL) {
496: warningPoly("modulopZ(f,p) must be called with f in the characteristic 0 ring Z[x]. Returns 0.");
497: return(POLYNULL);
498: }
499: if (f->m->ringp->n != ringp->n) {
500: warningPoly("modulop(f,ringp): f->m->ringp->n must be equal to ringp->n. Returns 0.");
501: return(POLYNULL);
502: }
503:
504: /* [1] The case of R = ringp->next */
505: if (ringp->next != (struct ring *)NULL) {
506: warningPoly("modulopZ workds only for flat polynomials. Returns 0.");
507: return(POLYNULL);
508: }
509:
510: /* [2] The case of R = Z */
511: node = newCell(newCoeff(),newMonomial(ringp));
512: node->next = POLYNULL;
513: h = node;
514:
515: c = newCoeff();
516: tmp = newMP_INT();
517: while (f != POLYNULL) {
518: mpz_mod(tmp,f->coeffp->val.bigp,bigp);
519: if (mpz_sgn(tmp) != 0) {
520: c->tag = MP_INTEGER;
521: c->p = 0;
522: c->val.bigp = tmp;
523: h->next = newCell(c,monomialCopy(f->m));
524: h = h->next;
525: h->m->ringp = ringp;
526:
527: c = newCoeff();
528: tmp = newMP_INT();
529: }
530: f = f->next;
531: }
532: return(node->next);
533:
534: }
535:
536: struct pairOfPOLY quotientByNumber(f,pcoeff)
537: POLY f;
538: struct coeff *pcoeff;
539: /* Z[x] ---> Z[x],Z[x] , f = first*pcoeff + second */
540: {
541: int p;
542: POLY h;
543: POLY h2;
544: struct coeff *c;
545: int cc;
546: POLY node;
547: struct coeff *c2;
548: POLY node2;
549: POLY fc;
550: MP_INT *bigp;
551: MP_INT *tmp;
552: MP_INT *tmp2;
553: struct ring *ringp;
554: struct pairOfPOLY r;
555:
556: if (f == POLYNULL) {
557: r.first = f; r.second = f;
558: return(r);
559: }
560: ringp = f->m->ringp;
561: if (pcoeff->tag != MP_INTEGER) {
562: warningPoly("quotientByNumber(): pcoeff must be a universalNumber.");
563: warningPoly("Returns (0,0).");
564: r.first = f; r.second = f;
565: return(r);
566: }
567: bigp = pcoeff->val.bigp;
568: if (f->m->ringp->p != 0 || f->m->ringp->next != (struct ring *)NULL) {
569: warningPoly("quotientByNumber(f,p) must be called with f in the characteristic 0 ring Z[x]. Returns (0,0).");
570: r.first = f; r.second = f;
571: return(r);
572: }
573: if (f->m->ringp->n != ringp->n) {
574: warningPoly("quotientByNumber(f,p): f->m->ringp->n must be equal to ringp->n. Returns 0.");
575: r.first = f; r.second = f;
576: return(r);
577: }
578:
579: /* [1] The case of R = ringp->next */
580: if (ringp->next != (struct ring *)NULL) {
581: warningPoly("quotientByNumber() workds only for flat polynomials. Returns 0.");
582: r.first = f; r.second = f;
583: return(r);
584: }
585:
586: /* [2] The case of R = Z */
587: node = newCell(newCoeff(),newMonomial(ringp));
588: node->next = POLYNULL;
589: h = node;
590: node2 = newCell(newCoeff(),newMonomial(ringp));
591: node2->next = POLYNULL;
592: h2 = node2;
593:
594: c = newCoeff();
595: tmp = newMP_INT();
596: c2 = newCoeff();
597: tmp2 = newMP_INT();
598: while (f != POLYNULL) {
599: mpz_mod(tmp,f->coeffp->val.bigp,bigp);
600: if (mpz_sgn(tmp) != 0) {
601: c->tag = MP_INTEGER;
602: c->p = 0;
603: c->val.bigp = tmp;
604: h->next = newCell(c,monomialCopy(f->m));
605: h = h->next;
606: h->m->ringp = ringp;
607:
608: c = newCoeff();
609: tmp = newMP_INT();
610: }
611: mpz_tdiv_q(tmp2,f->coeffp->val.bigp,bigp);
612: if (mpz_sgn(tmp2) != 0) {
613: c2->tag = MP_INTEGER;
614: c2->p = 0;
615: c2->val.bigp = tmp2;
616: h2->next = newCell(c2,monomialCopy(f->m));
617: h2 = h2->next;
618: h2->m->ringp = ringp;
619:
620: c2 = newCoeff();
621: tmp2 = newMP_INT();
622: }
623: f = f->next;
624: }
625: r.first = node2->next;
626: r.second = node->next;
627: return(r);
628:
629: }
630:
631:
632: POLY modulo0(f,ringp)
633: POLY f;
634: struct ring *ringp;
635: {
636: int p;
637: POLY h;
638: struct coeff *c;
639: POLY node;
640: if (f == POLYNULL) return(f);
641: p = ringp->p;
642: if (p != 0) {
643: warningPoly("modulo0(f,ringp) must be called with the characteristic 0 ring*ringp. Returns 0.");
644: return(POLYNULL);
645: }
646: switch (f->coeffp->tag) {
647: case MP_INTEGER:
648: if (f->m->ringp->p == 0) {
649: node = pcmCopy(f);
650: f = node;
651: while (f != POLYNULL) {
652: f->m->ringp = ringp; /* Touch the monomial "ringp" field. */
653: f = f->next;
654: }
655: return(node);
656: }
657: break;
658: case POLY_COEFF:
659: node = pcmCopy(f);
660: f = node;
661: while (f != POLYNULL) {
662: f->m->ringp = ringp; /* Touch the monomial "ringp" field. */
663: f = f->next;
664: }
665: return(node);
666: break;
667: case INTEGER:
668: node = newCell(newCoeff(),newMonomial(ringp));
669: node->next = POLYNULL;
670: h = node;
671:
672: while (f != POLYNULL) {
673: c = newCoeff();
674: c->tag = MP_INTEGER;
675: c->p = 0;
676: c->val.bigp = newMP_INT();
677: mpz_set_si(c->val.bigp,f->coeffp->val.i);
678: h->next = newCell(c,monomialCopy(f->m));
679: h = h->next;
680: h->m->ringp = ringp;
681: f = f->next;
682: }
683: return(node->next);
684: break;
685: default:
686: warningPoly("modulo0(): coefficients have to be MP_INTEGER or INTEGER. Returns 0");
687: return(POLYNULL);
688: break;
689: }
690: }
691:
692:
693: struct object test(ob) /* test3 */
694: struct object ob;
695: {
696: struct object rob;
697: int k;
698: static POLY f0;
699: static POLY f1;
700:
701: POLY addNode;
702: POLY f;
703: int i;
704: static int s=0;
705: MP_INT *mp;
706: extern struct ring *SmallRingp;
707: extern struct ring *CurrentRingp;
708: addNode = pMalloc(SmallRingp);
709: k = ob.lc.ival;
710: switch(s) {
711: case 0:
712: f0 = addNode;
713: for (i=k; i>=0; i--) {
714: f0->next = bxx(BiiPower(-k,i),0,i,CurrentRingp);
715: if (f0->next != POLYNULL) {
716: f0 = f0->next;
717: }
718: }
719: f0 = addNode->next;
720: s++;
721: rob.lc.poly = f0;
722: break;
723: case 1:
724: f1 = addNode;
725: for (i=k; i>=0; i--) {
726: f1->next = bxx(BiiPower(k,i),0,i,CurrentRingp);
727: if (f1->next != POLYNULL) {
728: f1 = f1->next;
729: }
730: }
731: f1 = addNode->next;
732: s = 0;
733: rob.lc.poly = f1;
734: break;
735: default:
736: rob.lc.poly = POLYNULL;
737: s = 0;
738: break;
739: }
740:
741:
742: rob.tag = Spoly;
743: return(rob);
744: }
745:
746:
747: int pLength(f)
748: POLY f;
749: {
750: int c=0;
751: if (f ISZERO) return(0);
752: while (f != POLYNULL) {
753: c++;
754: f = f->next;
755: }
756: return(c);
757: }
758:
759:
760: POLY ppAddv2(f,g,top,nexttop)
761: POLY f; POLY g; /* It breaks f and g. Use it just after calling mpMult() */
762: POLY top;
763: POLY *nexttop;
764: /* top is the starting address in the list f.
765: if top == POLYNULL, start from f.
766:
767: *nexttop == 0
768: == g
769: == h or 0
770:
771: It must be called as r = ppAddv2(r,g,...);
772: */
773: {
774: POLY node;
775: struct listPoly nod;
776: POLY h;
777: struct coeff *c;
778: int gt;
779: POLY g0;
780: POLY f0; /* for debug */
781:
782: node = &nod;
783: /* printf("ppAddv:1%s + %s\n",POLYToString(f,'*',1),POLYToString(g,'*',1)); */
784: node->next = POLYNULL;
785: h = node;
786: *nexttop = POLYNULL;
787: if (f == POLYNULL) return(g);
788: if (g == POLYNULL) return(f);
789: checkRing(f,g);
790:
791: f0 = f;
792: if (top != POLYNULL) {
793: while (f != top) {
794: if (f == POLYNULL) {
795: fprintf(stderr,"\nppAddv2(): Internal error.\n");fflush(stderr);
796: fprintf(stderr,"f = %s\n",POLYToString(f0,'*',0));
797: fprintf(stderr,"g = %s\n",POLYToString(g0,'*',0));
798: fprintf(stderr,"top=%s\n",POLYToString(top,'*',0));
799: errorPoly("ppAddv2(). Internal error=1.");
800: }
801: h->next = f;
802: h = h->next;
803: f = f->next;
804: }
805: }
806: g0 = g;
807: *nexttop = g0;
808:
809: while (f != POLYNULL && g != POLYNULL) {
810: checkRing2(f,g); /* for debug */
811: /* printf("%s + %s\n",POLYToString(f,'*',1),POLYToString(g,'*',1)); */
812: gt = (*mmLarger)(f,g);
813: switch (gt) {
814: case 1: /* f > g */
815: h->next = f;
816: h = h->next; f = f->next;;
817: if (f == POLYNULL) {
818: h->next = g;
819: return(node->next);
820: }
821: break;
822: case 0: /* f < g */
823: h->next = g;
824: h = h->next; g = g->next;
825: if (g == POLYNULL) {
826: h->next = f;
827: return(node->next);
828: }
829: break;
830: case 2:/* f == g */
831: c = g->coeffp;
832: Cadd(c,f->coeffp,c);
833: if (!isZero(c)) {
834: h->next = g;
835: h = h->next;
836: f = f->next;;
837: g = g->next;
838: if (f == POLYNULL) {
839: h->next = g;
840: return(node->next);
841: }
842: if (g == POLYNULL) {
843: h->next = f;
844: return(node->next);
845: }
846: }else{
847: if (g == g0) {
848: if (h != node) {
849: *nexttop = h;
850: }else{
851: *nexttop = POLYNULL;
852: }
853: }
854:
855: f = f->next;
856: g = g->next;
857:
858: if (f == POLYNULL) {
859: h->next = g;
860: return(node->next);
861: }
862: if (g == POLYNULL) {
863: h->next = f;
864: return(node->next);
865: }
866: }
867: break;
868: default:
869: errorPoly("ppAddv(). Internal error. Invalid value of mmLarger.");
870: break;
871: }
872: }
873: return(node->next);
874: }
875:
876: POLY ppMult(f,g)
877: POLY f,g;
878: {
879: POLY r;
880: POLY tmp;
881: POLY top;
882: POLY nexttop;
883: r = POLYNULL; top = POLYNULL;
884: while( f != POLYNULL) {
885: /* tmp = (*mpMult)(f,g); (*mpMult) is no more used. */
886: tmp = (*(f->m->ringp->multiplication))(f,g);
887: /*printf("mpMult(%s,%s) ->%s\n",POLYToString(f,'*',1),POLYToString(g,'*',1),POLYToString(tmp,'*',1)); */
888: r = ppAddv2(r,tmp,top,&nexttop); /* r and tmp will be broken */
889: top = nexttop;
890: f = f->next;
891: }
892: return(r);
893: }
894:
895: POLY ppMult_poly(f,g)
896: POLY f,g;
897: {
898: POLY r;
899: POLY tmp;
900: POLY top;
901: POLY nexttop;
902: r = POLYNULL; top = POLYNULL;
903: while( f != POLYNULL) {
904: tmp = mpMult_poly(f,g);
905: r = ppAddv2(r,tmp,top,&nexttop); /* r and tmp will be broken */
906: top = nexttop;
907: f = f->next;
908: }
909: return(r);
910: }
911:
912: POLY mapZmonom(f,ringp)
913: POLY f; /* assumes monomial. f \in Z[x] */
914: struct ring *ringp; /* R[x] */
915: {
916: struct ring *nextRing;
917: struct ring nextRing0;
918: POLY ff;
919: POLY node;
920: POLY gg;
921: int l,c,d;
922:
923: nextRing = ringp->next;
924: nextRing0 = *nextRing; nextRing0.p = 0; nextRing0.next = 0;
925: /* nextRing0 = Z[y] where y is the variables of R. */
926:
927: ff = bxx(f->coeffp->val.bigp,0,0,&nextRing0);
928: ff = modulop(ff,nextRing);
929:
930: node = newCell(newCoeff(),monomialCopy(f->m));
931: node->next = POLYNULL;
932: node->m->ringp = ringp;
933:
934: node->coeffp->p = ringp->p;
935:
936: l = ringp->l; c = ringp->c;
937: /* If q-analog q x ---> (q) x. */
938: if (l-c > 0) {
939: d = node->m->e[0].x; /* degree of q in R[x].*/
940: node->m->e[0].x = 0;
941: gg = cxx(1,0,d,nextRing); /* q^d = x[0]^d */
942: ff = ppMult(gg,ff);
943: }
944:
945: node->coeffp->tag = POLY_COEFF;
946: node->coeffp->val.f = ff;
947: return(node);
948: }
949:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to poly2.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM / src / kan96xx / Kan