Changeset b85e37 in git


Ignore:
Timestamp:
Oct 8, 2009, 7:02:33 PM (14 years ago)
Author:
Hans Schönemann <hannes@…>
Branches:
(u'spielwiese', '828514cf6e480e4bafc26df99217bf2a1ed1ef45')
Children:
d8db707919fa01c928aa53fa8778bf431ce018ef
Parents:
9193d93b4d40ee988851d32b6b7d64e21ec55ab1
Message:
*hannes: new naNormalize


git-svn-id: file:///usr/local/Singular/svn/trunk@12177 2c84dea3-7e68-4137-9b89-c4e89433aadc
File:
1 edited

Legend:

Unmodified
Added
Removed

  • kernel/longalg.cc

    r9193d9 rb85e37  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: longalg.cc,v 1.55 2009-10-08 08:38:31 Singular Exp $ */
     4/* $Id: longalg.cc,v 1.56 2009-10-08 17:02:33 Singular Exp $ */
    55/*
    66* ABSTRACT:   algebraic numbers
    … …  
    4747static number   (*nacGcd)(number a, number b, const ring r);
    4848static number   (*nacLcm)(number a, number b, const ring r);
    49 static void     (*nacDelete)(number *a, const ring r);
    5049static number   (*nacInit)(int i, const ring r);
    5150static int      (*nacInt)(number &n, const ring r);
     51static void     (*nacDelete)(number *a, const ring r);
     52#undef n_Delete
     53#define n_Delete(A,R) nacDelete(A,R)
    5254       void     (*nacNormalize)(number &a);
    5355static number   (*nacNeg)(number a);
    … …  
    6668       ring nacRing;
    6769
    68 #define napCopy(p)       (napoly)p_Copy((poly)p,nacRing)
     70#define napCopy(p)       p_Copy(p,nacRing)
    6971
    7072static number nadGcd( number a, number b, const ring r) { return nacInit(1,r); }
    … …  
    137139  nacGcd         = nacRing->cf->nGcd;
    138140  nacLcm         = nacRing->cf->nLcm;
    139   nacDelete      = nacRing->cf->cfDelete;
    140141  nacMult        = nacRing->cf->nMult;
    141142  nacDiv         = nacRing->cf->nDiv;
    142143  nacIntDiv      = nacRing->cf->nIntDiv;
    143144  nacInvers      = nacRing->cf->nInvers;
     145  nacDelete      = nacRing->cf->cfDelete;
    144146}
    145147
    … …  
    163165
    164166#define napInit(i)       (napoly)p_ISet(i,nacRing)
    165 #define napSetCoeff(p,n) {nacDelete(&pGetCoeff(p),nacRing);pGetCoeff(p)=n;}
     167#define napSetCoeff(p,n) {n_Delete(&pGetCoeff(p),nacRing);pGetCoeff(p)=n;}
    166168#define napDelete1(p)    p_LmDelete((poly *)p, nacRing)
    167169#define napComp(p,q)     p_LmCmp((poly)p,(poly)q, nacRing)
    168170#define napMultT(A,E)    A=(napoly)p_Mult_mm((poly)A,(poly)E,nacRing)
    169 #define napMult(A,B)     (napoly)p_Mult_q((poly)A,(poly)B,nacRing)
    170 #define napMultCopy(A,B)   (napoly)pp_Mult_qq((poly)A,(poly)B,nacRing)
    171171#define napIsConstant(p) p_LmIsConstant(p,nacRing)
    172172#define napDeg(p)        (int)p_ExpVectorQuerSum(p, nacRing)
    … …  
    203203    t = nacMult(pGetCoeff(p), z);
    204204    nacNormalize(t);
    205     nacDelete(&pGetCoeff(p),nacRing);
     205    n_Delete(&pGetCoeff(p),nacRing);
    206206    pGetCoeff(p) = t;
    207207    pIter(p);
    … …  
    223223  do
    224224  {
    225     napSetExp(qq,1, napGetExp(a,1) - napGetExp(g,1));
     225    napSetExp(qq,1, p_GetExp(a,1,nacRing) - p_GetExp(g,1,nacRing));
    226226    napSetm(qq);
    227227    pGetCoeff(qq) = nacDiv(pGetCoeff(a), pGetCoeff(g));
    … …  
    231231    napMultT(h, qq);
    232232    p_Normalize(h,nacRing);
    233     nacDelete(&pGetCoeff(qq),nacRing);
     233    n_Delete(&pGetCoeff(qq),nacRing);
    234234    a = napAdd(a, h);
    235235  }
    236   while ((a!=NULL) && (napGetExp(a,1) >= napGetExp(g,1)));
     236  while ((a!=NULL) && (p_GetExp(a,1,nacRing) >= p_GetExp(g,1,nacRing)));
    237237  omFreeBinAddr(qq);
    238238  return a;
    … …  
    253253  do
    254254  {
    255     napSetExp(qq,1, napGetExp(a,1) - napGetExp(g,1));
     255    napSetExp(qq,1, p_GetExp(a,1,nacRing) - p_GetExp(g,1,nacRing));
    256256    p_Setm(qq,nacRing);
    257257    pGetCoeff(qq) = nacDiv(pGetCoeff(a), pGetCoeff(g));
    … …  
    262262    napMultT(h, qq);
    263263    p_Normalize(h,nacRing);
    264     nacDelete(&pGetCoeff(qq),nacRing);
     264    n_Delete(&pGetCoeff(qq),nacRing);
    265265    a = napAdd(a, h);
    266266  }
    267   while ((a!=NULL) && (napGetExp(a,1) >= napGetExp(g,1)));
     267  while ((a!=NULL) && (p_GetExp(a,1,nacRing) >= p_GetExp(g,1,nacRing)));
    268268  omFreeBinAddr(qq);
    269269  *q = b;
    … …  
    279279  number t, h;
    280280
    281   if (napGetExp(x,1) >= napGetExp(c,1))
     281  if (p_GetExp(x,1,nacRing) >= p_GetExp(c,1,nacRing))
    282282    x = napRemainder(x, c);
    283283  if (x==NULL)
    … …  
    285285    goto zero_divisor;
    286286  }
    287   if (napGetExp(x,1)==0)
     287  if (p_GetExp(x,1,nacRing)==0)
    288288  {
    289289    if (!nacIsOne(pGetCoeff(x)))
    … …  
    292292      t = nacInvers(pGetCoeff(x));
    293293      nacNormalize(t);
    294       nacDelete(&pGetCoeff(x),nacRing);
     294      n_Delete(&pGetCoeff(x),nacRing);
    295295      pGetCoeff(x) = t;
    296296    }
    … …  
    303303    goto zero_divisor;
    304304  }
    305   if (napGetExp(r,1)==0)
     305  if (p_GetExp(r,1,nacRing)==0)
    306306  {
    307307    nacNormalize(pGetCoeff(r));
    … …  
    310310    t = nacNeg(t);
    311311    napMultN(qa, t);
    312     nacDelete(&t,nacRing);
     312    n_Delete(&t,nacRing);
    313313    p_Normalize(qa,nacRing);
    314314    p_Delete(&x,nacRing);
    … …  
    323323    goto zero_divisor;
    324324  }
    325   if (napGetExp(r,1)==0)
    326   {
    327     q = napMult(q, qa);
     325  if (p_GetExp(r,1,nacRing)==0)
     326  {
     327    q = p_Mult_q(q, qa,nacRing);
    328328    q = napAdd(q, napInit(1));
    329329    nacNormalize(pGetCoeff(r));
    … …  
    331331    napMultN(q, t);
    332332    p_Normalize(q,nacRing);
    333     nacDelete(&t,nacRing);
     333    n_Delete(&t,nacRing);
    334334    p_Delete(&x,nacRing);
    335335    p_Delete(&r,nacRing);
    336     if (napGetExp(q,1) >= napGetExp(c,1))
     336    if (p_GetExp(q,1,nacRing) >= p_GetExp(c,1,nacRing))
    337337      q = napRemainder(q, c);
    338338    return q;
    339339  }
    340   q = napMult(q, napCopy(qa));
     340  q = p_Mult_q(q, napCopy(qa),nacRing);
    341341  q = napAdd(q, napInit(1));
    342342  qa = napNeg(qa);
    … …  
    350350      break;
    351351    }
    352     if (napGetExp(r,1)==0)
    353     {
    354       q = napMult(q, qn);
     352    if (p_GetExp(r,1,nacRing)==0)
     353    {
     354      q = p_Mult_q(q, qn,nacRing);
    355355      q = napNeg(q);
    356356      q = napAdd(q, qa);
    … …  
    360360      napMultN(q, t);
    361361      p_Normalize(q,nacRing);
    362       nacDelete(&t,nacRing);
     362      n_Delete(&t,nacRing);
    363363      p_Delete(&x,nacRing);
    364364      p_Delete(&r,nacRing);
    365       if (napGetExp(q,1) >= napGetExp(c,1))
     365      if (p_GetExp(q,1,nacRing) >= p_GetExp(c,1,nacRing))
    366366        q = napRemainder(q, c);
    367367      return q;
    368368    }
    369369    y = q;
    370     q = napMult(napCopy(q), qn);
     370    q = p_Mult_q(napCopy(q), qn, nacRing);
    371371    q = napNeg(q);
    372372    q = napAdd(q, qa);
    … …  
    452452      for (i = 0; i < naNumbOfPar; i++)
    453453      {
    454         if (napGetExp(p,i+1) > 0)
     454        int e=p_GetExp(p,i+1,nacRing);
     455        if (e > 0)
    455456        {
    456457          if (wroteCoeff)
    … …  
    459460            wroteCoeff=(currRing->ShortOut==0);
    460461          StringAppendS(naParNames[i]);
    461           if (napGetExp(p,(i+1)) > 1)
     462          if (e > 1)
    462463          {
    463464            if (currRing->ShortOut == 0)
    464465              StringAppendS("^");
    465             StringAppend("%d", napGetExp(p,i+1));
     466            StringAppend("%d", e);
    466467          }
    467468        }
    … …  
    530531    if (olds == s)
    531532      i++;
    532     else if (*s == '\0') 
     533    else if (*s == '\0')
    533534    {
    534535      *b = a;
    … …  
    557558{
    558559  while (pNext(a)!=NULL) pIter(a);
    559   int m = napGetExp(a,1);
     560  int m = p_GetExp(a,1,nacRing);
    560561  if (m==0) return 0;
    561562  while (pNext(b)!=NULL) pIter(b);
    562   int mm=napGetExp(b,1);
     563  int mm=p_GetExp(b,1,nacRing);
    563564  if (m > mm) m = mm;
    564565  return m;
    … …  
    572573{
    573574  if (a==NULL || b==NULL) return 0;
    574   int m = napGetExp(a,i+1);
     575  int m = p_GetExp(a,i+1,nacRing);
    575576  if (m==0) return 0;
    576577  while (pNext(a) != NULL)
    577578  {
    578579    pIter(a);
    579     if (m > napGetExp(a,i+1))
    580     {
    581       m = napGetExp(a,i+1);
     580    if (m > p_GetExp(a,i+1,nacRing))
     581    {
     582      m = p_GetExp(a,i+1,nacRing);
    582583      if (m==0) return 0;
    583584    }
    … …  
    585586  do
    586587  {
    587     if (m > napGetExp(b,i+1))
    588     {
    589       m = napGetExp(b,i+1);
     588    if (m > p_GetExp(b,i+1,nacRing))
     589    {
     590      m = p_GetExp(b,i+1,nacRing);
    590591      if (m==0) return 0;
    591592    }
    … …  
    611612    if(nacIsOne(d))
    612613    {
    613       nacDelete(&h,nacRing);
    614       nacDelete(&d,nacRing);
     614      n_Delete(&h,nacRing);
     615      n_Delete(&d,nacRing);
    615616      return;
    616617    }
    617     nacDelete(&h,nacRing);
     618    n_Delete(&h,nacRing);
    618619    h = d;
    619620    pIter(p);
    … …  
    621622  while (p!=NULL);
    622623  h = nacInvers(d);
    623   nacDelete(&d,nacRing);
     624  n_Delete(&d,nacRing);
    624625  p = ph;
    625626  while (p!=NULL)
    626627  {
    627628    d = nacMult(pGetCoeff(p), h);
    628     nacDelete(&pGetCoeff(p),nacRing);
     629    n_Delete(&pGetCoeff(p),nacRing);
    629630    pGetCoeff(p) = d;
    630631    pIter(p);
    631632  }
    632   nacDelete(&h,nacRing);
     633  n_Delete(&h,nacRing);
    633634}
    634635
    … …  
    645646  {
    646647    d = nacLcm(h, pGetCoeff(p), nacRing);
    647     nacDelete(&h,nacRing);
     648    n_Delete(&h,nacRing);
    648649    h = d;
    649650    pIter(p);
    … …  
    655656    {
    656657      d=nacMult(h, pGetCoeff(p));
    657       nacDelete(&pGetCoeff(p),nacRing);
     658      n_Delete(&pGetCoeff(p),nacRing);
    658659      nacNormalize(d);
    659660      pGetCoeff(p) = d;
    660661      pIter(p);
    661662    }
    662     nacDelete(&h,nacRing);
     663    n_Delete(&h,nacRing);
    663664  }
    664665  napContent(ph);
    … …  
    677678    pIter(a);
    678679    y = nacGcd(x, pGetCoeff(a), nacRing);
    679     nacDelete(&x,nacRing);
     680    n_Delete(&x,nacRing);
    680681    x = y;
    681682    if (nacIsOne(x))
    … …  
    685686  {
    686687    y = nacGcd(x, pGetCoeff(b), nacRing);
    687     nacDelete(&x,nacRing);
     688    n_Delete(&x,nacRing);
    688689    x = y;
    689690    if (nacIsOne(x))
    … …  
    720721  if (naMinimalPoly != NULL)
    721722  {
    722     if (napGetExp(a,1) >= napGetExp(b,1))
     723    if (p_GetExp(a,1,nacRing) >= p_GetExp(b,1,nacRing))
    723724    {
    724725      x = a;
    … …  
    789790    {
    790791      d = nacLcm(h, pGetCoeff(b), nacRing);
    791       nacDelete(&h,nacRing);
     792      n_Delete(&h,nacRing);
    792793      h = d;
    793794      pIter(b);
    … …  
    807808  int j=1;   /* evtl. von naNumber.. -1 abwaerts zaehlen */
    808809
    809   while (napGetExp(p,j) <= napGetExp(q,j))
     810  while (p_GetExp(p,j,nacRing) <= p_GetExp(q,j,nacRing))
    810811  {
    811812    j++;
    … …  
    834835      pGetCoeff(h) = nacCopy(pGetCoeff(q));
    835836      for (j=naNumbOfPar; j>0; j--)
    836         napSetExp(h,j, napGetExp(q,j) - napGetExp(naI->liste[i],j));
     837        napSetExp(h,j, p_GetExp(q,j,nacRing) - p_GetExp(naI->liste[i],j,nacRing));
    837838      p_Setm(h,nacRing);
    838       h = napMult (h, napCopy(naI->liste[i]));
     839      h = p_Mult_q(h, napCopy(naI->liste[i]),nacRing);
    839840      h = napNeg (h);
    840841      q = napAdd (q, napCopy(h));
    … …  
    10231024  omCheckAddrSize(b,sizeof(snumber));
    10241025  lu = (lnumber)omAllocBin(rnumber_bin);
    1025   if (b->n!=NULL) x = napMultCopy(a->z, b->n);
     1026  if (b->n!=NULL) x = pp_Mult_qq(a->z, b->n,nacRing);
    10261027  else            x = napCopy(a->z);
    1027   if (a->n!=NULL) y = napMultCopy(b->z, a->n);
     1028  if (a->n!=NULL) y = pp_Mult_qq(b->z, a->n,nacRing);
    10281029  else            y = napCopy(b->z);
    10291030  lu->z = napAdd(x, y);
    … …  
    10351036  if (a->n!=NULL)
    10361037  {
    1037     if (b->n!=NULL) x = napMultCopy(a->n, b->n);
     1038    if (b->n!=NULL) x = pp_Mult_qq(a->n, b->n,nacRing);
    10381039    else            x = napCopy(a->n);
    10391040  }
    … …  
    10491050  //    number inv=nacInvers(pGetCoeff(x));
    10501051  //    napMultN(lu->z,inv);
    1051   //    nacDelete(&inv,nacRing);
     1052  //    n_Delete(&inv,nacRing);
    10521053  //    napDelete(&x);
    10531054  //  }
    … …  
    10881089  napoly x, y;
    10891090  lu = (lnumber)omAllocBin(rnumber_bin);
    1090   if (b->n!=NULL) x = napMultCopy(a->z, b->n);
     1091  if (b->n!=NULL) x = pp_Mult_qq(a->z, b->n,nacRing);
    10911092  else            x = napCopy(a->z);
    1092   if (a->n!=NULL) y = napMult(napCopy(b->z), napCopyNeg(a->n));
     1093  if (a->n!=NULL) y = p_Mult_q(napCopy(b->z), napCopyNeg(a->n),nacRing);
    10931094  else            y = napCopyNeg(b->z);
    10941095  lu->z = napAdd(x, y);
    … …  
    11001101  if (a->n!=NULL)
    11011102  {
    1102     if (b->n!=NULL) x = napMultCopy(a->n, b->n);
     1103    if (b->n!=NULL) x = pp_Mult_qq(a->n, b->n,nacRing);
    11031104    else            x = napCopy(a->n);
    11041105  }
    … …  
    11141115  //    number inv=nacInvers(pGetCoeff(x));
    11151116  //    napMultN(lu->z,inv);
    1116   //    nacDelete(&inv,nacRing);
     1117  //    n_Delete(&inv,nacRing);
    11171118  //    napDelete(&x);
    11181119  //  }
    … …  
    11491150
    11501151  lo = (lnumber)omAllocBin(rnumber_bin);
    1151   lo->z = napMultCopy(a->z, b->z);
     1152  lo->z = pp_Mult_qq(a->z, b->z,nacRing);
    11521153
    11531154  if (a->n==NULL)
    … …  
    11661167    else
    11671168    {
    1168       x = napMultCopy(b->n, a->n);
     1169      x = pp_Mult_qq(b->n, a->n, nacRing);
    11691170    }
    11701171  }
    11711172  if (naMinimalPoly!=NULL)
    11721173  {
    1173     if (napGetExp(lo->z,1) >= napGetExp(naMinimalPoly,1))
     1174    if (p_GetExp(lo->z,1,nacRing) >= p_GetExp(naMinimalPoly,1,nacRing))
    11741175      lo->z = napRemainder(lo->z, naMinimalPoly);
    1175     if ((x!=NULL) && (napGetExp(x,1) >= napGetExp(naMinimalPoly,1)))
     1176    if ((x!=NULL) && (p_GetExp(x,1,nacRing) >= p_GetExp(naMinimalPoly,1,nacRing)))
    11761177      x = napRemainder(x, naMinimalPoly);
    11771178  }
    … …  
    12501251  napoly x;
    12511252
    1252   if ((a==NULL) || (a->z==NULL))
     1253  if (a==NULL)
    12531254    return NULL;
    12541255
    1255   if ((b==NULL) || (b->z==NULL))
     1256  if (b==NULL)
    12561257  {
    12571258    WerrorS(nDivBy0);
    … …  
    12621263  lo = (lnumber)omAllocBin(rnumber_bin);
    12631264  if (b->n!=NULL)
    1264     lo->z = napMultCopy(a->z, b->n);
     1265    lo->z = pp_Mult_qq(a->z, b->n,nacRing);
    12651266  else
    12661267    lo->z = napCopy(a->z);
    12671268  if (a->n!=NULL)
    1268     x = napMultCopy(b->z, a->n);
     1269    x = pp_Mult_qq(b->z, a->n, nacRing);
    12691270  else
    12701271    x = napCopy(b->z);
    12711272  if (naMinimalPoly!=NULL)
    12721273  {
    1273     if (napGetExp(lo->z,1) >= napGetExp(naMinimalPoly,1))
     1274    if (p_GetExp(lo->z,1,nacRing) >= p_GetExp(naMinimalPoly,1,nacRing))
    12741275      lo->z = napRemainder(lo->z, naMinimalPoly);
    1275     if (napGetExp(x,1) >= napGetExp(naMinimalPoly,1))
     1276    if (p_GetExp(x,1,nacRing) >= p_GetExp(naMinimalPoly,1,nacRing))
    12761277      x = napRemainder(x, naMinimalPoly);
    12771278  }
    … …  
    13511352  {
    13521353    x = napInvers(x, naMinimalPoly);
    1353     x = napMult(x, lo->z);
    1354     if (napGetExp(x,1) >= napGetExp(naMinimalPoly,1))
     1354    x = p_Mult_q(x, lo->z,nacRing);
     1355    if (p_GetExp(x,1,nacRing) >= p_GetExp(naMinimalPoly,1,nacRing))
    13551356      x = napRemainder(x, naMinimalPoly);
    13561357    lo->z = x;
    … …  
    13831384  if ((zb!=NULL) && (zb->z==NULL)) WerrorS("internal zero error(2)");
    13841385#endif
    1385   return ((zb==NULL) || (zb->z==NULL));
     1386  return (zb==NULL);
    13861387}
    13871388
    … …  
    13941395#endif
    13951396  naTest(za);
    1396   if ((zb!=NULL) && (zb->z!=NULL))
     1397  if (zb!=NULL)
    13971398  {
    13981399    return (nacGreaterZero(pGetCoeff(zb->z))||(!napIsConstant(zb->z)));
    … …  
    14641465  a = (lnumber)*p;
    14651466  if ((naMinimalPoly!=NULL)
    1466   && (napGetExp(x,1) >= napGetExp(naMinimalPoly,1)))
     1467  && (p_GetExp(x,1,nacRing) >= p_GetExp(naMinimalPoly,1,nacRing)))
    14671468    a->z = napRemainder(x, naMinimalPoly);
    14681469  else if (naI!=NULL)
    … …  
    14941495{
    14951496  lnumber ph = (lnumber)n;
    1496   if ((ph==NULL)||(ph->z==NULL))
     1497  if (ph==NULL)
    14971498    return NULL;
    14981499  int i;
    … …  
    15021503  for (i = 0; i <= naNumbOfPar - 1; i++)
    15031504  {
    1504     if (napGetExp(ph->z,i+1) > 0)
    1505     {
    1506       if (napGetExp(ph->z,i+1) >1)
     1505    int e=p_GetExp(ph->z,i+1,nacRing);
     1506    if (e > 0)
     1507    {
     1508      if (e >1)
    15071509      {
    1508         sprintf(t,"%s%d",naParNames[i],(int)napGetExp(ph->z,i+1));
     1510        sprintf(t,"%s%d",naParNames[i],e);
    15091511        strcat(s,t);
    15101512      }
    … …  
    15301532{
    15311533  lnumber ph = (lnumber)phn;
    1532   if ((ph==NULL)||(ph->z==NULL))
     1534  if (ph==NULL)
    15331535    StringAppendS("0");
    15341536  else
    … …  
    15571559  omCheckAddrSize(a,sizeof(snumber));
    15581560#ifdef LDEBUG
    1559   if (a->z==NULL) WerrorS("internal zero error(4)");
     1561  if (a->z==NULL)
     1562  {
     1563    WerrorS("internal zero error(4)");
     1564    return FALSE;
     1565  }
    15601566#endif
    15611567  if (a->n==NULL)
    15621568  {
    1563     if (napIsConstant(a->z))
    1564     {
    1565 #ifdef LDEBUG
    1566        if (a->z==NULL) return FALSE;
    1567        else
    1568 #endif
    1569          return nacIsOne(pGetCoeff(a->z));
     1569    if (napIsConstant(a->z))
     1570    {
     1571      return nacIsOne(pGetCoeff(a->z));
    15701572    }
    15711573    else                 return FALSE;
    … …  
    15831585      if (!nacIsZero(t))
    15841586      {
    1585         nacDelete(&t,nacRing);
     1587        n_Delete(&t,nacRing);
    15861588        return FALSE;
    15871589      }
    15881590      else
    1589         nacDelete(&t,nacRing);
     1591        n_Delete(&t,nacRing);
    15901592    }
    15911593    pIter(x);
    … …  
    16521654  if (a==NULL)  return naCopy(b);
    16531655  if (b==NULL)  return naCopy(a);
    1654  
     1656
    16551657  lnumber x, y;
    16561658  lnumber result = (lnumber)omAlloc0Bin(rnumber_bin);
    … …  
    16761678    napoly rz=napGcd(x->z, y->z);
    16771679    CanonicalForm F, G, R;
    1678     R=convSingPFactoryP(rz,r->algring); 
     1680    R=convSingPFactoryP(rz,r->algring);
    16791681    p_Normalize(x->z,nacRing);
    1680     F=convSingPFactoryP(x->z,r->algring)/R; 
     1682    F=convSingPFactoryP(x->z,r->algring)/R;
    16811683    p_Normalize(y->z,nacRing);
    1682     G=convSingPFactoryP(y->z,r->algring)/R; 
     1684    G=convSingPFactoryP(y->z,r->algring)/R;
    16831685    F = gcd( F, G );
    1684     if (F.isOne()) 
     1686    if (F.isOne())
    16851687      result->z= rz;
    16861688    else
    … …  
    17111713*/
    17121714//#define FACTORY_GCD_TEST
     1715void naCoefNormalize(number pp)
     1716{
     1717  if (pp==NULL) return;
     1718  lnumber p = (lnumber)pp;
     1719  number nz; // all denom. of the numerator
     1720  nz=p_GetAllDenom(p->z,nacRing);
     1721  number nn;
     1722  nn=p_GetAllDenom(p->n,nacRing);
     1723  BOOLEAN norm=FALSE;
     1724  if (!n_IsOne(nz,nacRing))
     1725  {
     1726    norm=TRUE;
     1727    p->z=p_Mult_nn(p->z,nz,nacRing);
     1728    if (p->n==NULL)
     1729    {
     1730      p->n=p_NSet(nz,nacRing);
     1731    }
     1732    else
     1733    {
     1734      p->n=p_Mult_nn(p->n,nz,nacRing);
     1735      n_Delete(&nz, nacRing);
     1736    }
     1737  }
     1738  else
     1739  {
     1740    n_Delete(&nz, nacRing);
     1741  }
     1742  if (!n_IsOne(nn,nacRing))
     1743  {
     1744    norm=TRUE;
     1745    p->n=p_Mult_nn(p->n,nn,nacRing);
     1746    p->z=p_Mult_nn(p->z,nn,nacRing);
     1747    n_Delete(&nn, nacRing);
     1748  }
     1749  else
     1750  {
     1751    n_Delete(&nn, nacRing);
     1752  }
     1753  if (norm)
     1754  {
     1755    p_Normalize(p->z,nacRing);
     1756    p_Normalize(p->n,nacRing);
     1757  }
     1758  if ((p->n!=NULL)
     1759  && (p_IsConstant(p->n,nacRing))
     1760  && (n_IsOne(pGetCoeff(p->n),nacRing)))
     1761  {
     1762    p_Delete(&(p->n), nacRing);
     1763    p->n = NULL;
     1764  }
     1765}
    17131766void naNormalize(number &pp)
    17141767{
    … …  
    17191772  if ((p==NULL) /*|| (p->s==2)*/)
    17201773    return;
     1774  naCoefNormalize(pp);
    17211775  p->s = 2;
    17221776  napoly x = p->z;
    17231777  napoly y = p->n;
     1778
     1779  BOOLEAN norm=FALSE;
     1780
    17241781  if ((y!=NULL) && (naMinimalPoly!=NULL))
    17251782  {
    17261783    y = napInvers(y, naMinimalPoly);
    1727     x = napMult(x, y);
    1728     if (napGetExp(x,1) >= napGetExp(naMinimalPoly,1))
     1784    x = p_Mult_q(x, y,nacRing);
     1785    if (p_GetExp(x,1,nacRing) >= p_GetExp(naMinimalPoly,1,nacRing))
    17291786      x = napRemainder(x, naMinimalPoly);
    17301787    p->z = x;
    17311788    p->n = y = NULL;
    1732   }
     1789    norm=naIsChar0;
     1790  }
     1791
    17331792  /* check for degree of x too high: */
    17341793  if ((x!=NULL) && (naMinimalPoly!=NULL) && (x!=naMinimalPoly)
    1735   && (napGetExp(x,1)>napGetExp(naMinimalPoly,1)))
     1794  && (p_GetExp(x,1,nacRing)>p_GetExp(naMinimalPoly,1,nacRing)))
    17361795  // DO NOT REDUCE naMinimalPoly with itself
    17371796  {
    17381797    x = napRemainder(x, naMinimalPoly);
    17391798    p->z = x;
     1799    norm=naIsChar0;
    17401800  }
    17411801  /* normalize all coefficients in n and z (if in Q) */
    1742   if (naIsChar0)
    1743   {
    1744     while(x!=NULL)
    1745     {
    1746       nacNormalize(pGetCoeff(x));
    1747       pIter(x);
    1748     }
     1802  if (norm)
     1803  {
     1804    naCoefNormalize(pp);
    17491805    x = p->z;
     1806    y = p->n;
    17501807  }
    17511808  if (y==NULL) return;
    1752   if (naIsChar0)
    1753   {
    1754     while(y!=NULL)
    1755     {
    1756       nacNormalize(pGetCoeff(y));
    1757       pIter(y);
    1758     }
    1759     y = p->n;
    1760   // p->n !=NULL:
    1761   /* collect all denoms from y and multiply x and y by it */
    1762     number n=napLcm(y);
    1763     napMultN(x,n);
    1764     napMultN(y,n);
    1765     nacDelete(&n,nacRing);
    1766     while(x!=NULL)
    1767     {
    1768       nacNormalize(pGetCoeff(x));
    1769       pIter(x);
    1770     }
    1771     x = p->z;
    1772     while(y!=NULL)
    1773     {
    1774       nacNormalize(pGetCoeff(y));
    1775       pIter(y);
    1776     }
    1777     y = p->n;
    1778   }
     1809
    17791810  if ((naMinimalPoly == NULL) && (x!=NULL) && (y!=NULL))
    17801811  {
    … …  
    18121843    nacNormalize(h1);
    18131844    napMultN(x, h1);
    1814     nacDelete(&h1,nacRing);
     1845    n_Delete(&h1,nacRing);
    18151846    napDelete1(&y);
    18161847    p->n = NULL;
    … …  
    18221853  {
    18231854    napoly x1,y1;
    1824     if (napGetExp(x,1) >= napGetExp(y,1))
     1855    if (p_GetExp(x,1,nacRing) >= p_GetExp(y,1,nacRing))
    18251856    {
    18261857      x1 = napCopy(x);
    … …  
    18591890      napMultN(x,n);
    18601891      napMultN(y,n);
    1861       nacDelete(&n,nacRing);
     1892      n_Delete(&n,nacRing);
    18621893      while(x!=NULL)
    18631894      {
    … …  
    18771908      if (nacIsOne(pGetCoeff(y)))
    18781909      {
    1879         if (napGetExp(y,1)==0)
     1910        if (p_GetExp(y,1,nacRing)==0)
    18801911        {
    18811912          napDelete1(&y);
    … …  
    19191950    if(nacIsOne(d))
    19201951    {
    1921       nacDelete(&g,nacRing);
    1922       nacDelete(&d,nacRing);
     1952      n_Delete(&g,nacRing);
     1953      n_Delete(&d,nacRing);
    19231954      naTest(pp);
    19241955      return;
    19251956    }
    1926     nacDelete(&g,nacRing);
     1957    n_Delete(&g,nacRing);
    19271958    g = d;
    19281959    pIter(x);
    … …  
    19331964    if(nacIsOne(d))
    19341965    {
    1935       nacDelete(&g,nacRing);
    1936       nacDelete(&d,nacRing);
     1966      n_Delete(&g,nacRing);
     1967      n_Delete(&d,nacRing);
    19371968      naTest(pp);
    19381969      return;
    19391970    }
    1940     nacDelete(&g,nacRing);
     1971    n_Delete(&g,nacRing);
    19411972    g = d;
    19421973    pIter(y);
    … …  
    19561987    pIter(y);
    19571988  }
    1958   nacDelete(&g,nacRing);
     1989  n_Delete(&g,nacRing);
    19591990  naTest(pp);
    19601991}
    … …  
    19882019      bt = nacGcd(t, pGetCoeff(xx), r->algring);
    19892020      rr = nacMult(t, pGetCoeff(xx));
    1990       nacDelete(&pGetCoeff(xx),r->algring);
     2021      n_Delete(&pGetCoeff(xx),r->algring);
    19912022      pGetCoeff(xx) = nacDiv(rr, bt);
    19922023      nacNormalize(pGetCoeff(xx));
    1993       nacDelete(&bt,r->algring);
    1994       nacDelete(&rr,r->algring);
     2024      n_Delete(&bt,r->algring);
     2025      n_Delete(&rr,r->algring);
    19952026      pIter(xx);
    19962027    }
    19972028  }
    1998   nacDelete(&t,r->algring);
     2029  n_Delete(&t,r->algring);
    19992030  result->z = x;
    20002031#ifdef HAVE_FACTORY
    … …  
    20472078        a=nacCopy(pGetCoeff(x));
    20482079        number aa=nacInvers(a);
    2049         nacDelete(&a,nacRing);
     2080        n_Delete(&a,nacRing);
    20502081        napMultN(x,aa);
    2051         nacDelete(&aa,nacRing);
     2082        n_Delete(&aa,nacRing);
    20522083      }
    20532084    }
    … …  
    21942225      }
    21952226      /* else continue*/
    2196       nacDelete(&(pGetCoeff(w)),nacRing);
     2227      n_Delete(&(pGetCoeff(w)),nacRing);
    21972228    }
    21982229    else
    … …  
    22212252  if (naMinimalPoly!=NULL)
    22222253  {
    2223     if (napGetExp(erg->z,1) >= napGetExp(naMinimalPoly,1))
     2254    if (p_GetExp(erg->z,1,nacRing) >= p_GetExp(naMinimalPoly,1,nacRing))
    22242255    {
    22252256      erg->z = napRemainder(erg->z, naMinimalPoly);
    … …  
    22332264    if (erg->n!=NULL)
    22342265    {
    2235       if (napGetExp(erg->n,1) >= napGetExp(naMinimalPoly,1))
     2266      if (p_GetExp(erg->n,1,nacRing) >= p_GetExp(naMinimalPoly,1,nacRing))
    22362267        erg->n = napRemainder(erg->n, naMinimalPoly);
    22372268      if ((napIsConstant(erg->n)) && nacIsOne(pGetCoeff(erg->n)))
    … …  
    24562487      return FALSE;
    24572488    }
    2458     if((naMinimalPoly!=NULL)&&(napGetExp(p,1)>napGetExp(naMinimalPoly,1))
     2489    if((naMinimalPoly!=NULL)
     2490    &&(p_GetExp(p,1,nacRing)>p_GetExp(naMinimalPoly,1,nacRing))
    24592491    &&(p!=naMinimalPoly))
    24602492    {
    … …  
    24812513}
    24822514#endif
    2483 
Note: See TracChangeset for help on using the changeset viewer.