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

Annotation of OpenXM/src/kan96xx/Kan/poly2.c, Revision 1.2

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

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