Changeset b3af93 in git


Ignore:
Timestamp:
Aug 21, 2009, 12:55:46 PM (15 years ago)
Author:
Hans Schönemann <hannes@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', '648d28f488f6ff08f5607ff229b9ad9e4a5b93c2')
Children:
355201433267f3df667ea913a9d3487335c99191
Parents:
43c57185bbe2457782485ecda44d8025a86ca320
Message:
*hannes: longalg.cc: 1.38


git-svn-id: file:///usr/local/Singular/svn/trunk@12082 2c84dea3-7e68-4137-9b89-c4e89433aadc
Location:
kernel
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • kernel/longalg.cc

    r43c5718 rb3af93  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: longalg.cc,v 1.47 2009-08-14 17:14:30 Singular Exp $ */
     4/* $Id: longalg.cc,v 1.48 2009-08-21 10:55:46 Singular Exp $ */
    55/*
    66* ABSTRACT:   algebraic numbers
    7 * convention: A) minpoly==0: n->z, n->n are from Z[a] resp. Z/p[a],
    8 *                no common div., L(n->n) >0 (or n->n==NULL)
    9 *             B) minpoly!=NULL: n->z from k[a], n->n==NULL
    107*/
    118
     
    3128naIdeal naI=NULL;
    3229
     30int naNumbOfPar;
    3331napoly naMinimalPoly;
    3432#define naParNames (currRing->parameter)
     33#define napNormalize(p) p_Normalize(p,nacRing)
    3534static int naIsChar0;
    3635static int naPrimeM;
     
    4948static number   (*nacGcd)(number a, number b, const ring r);
    5049static number   (*nacLcm)(number a, number b, const ring r);
     50static void     (*nacDelete)(number *a, const ring r);
    5151       number   (*nacInit)(int i);
    5252static int      (*nacInt)(number &n);
     
    6666static int napExpi(int i, napoly a, napoly b);
    6767       ring nacRing;
     68static inline void naNormalize0(number &pp)
     69{
     70  lnumber p = (lnumber)pp;
     71  if ((p!=NULL) && (p->z!=NULL))
     72  {
     73      naNormalize(pp);
     74  }
     75}
    6876
    6977#define napCopy(p)       (napoly)p_Copy((poly)p,nacRing)
     
    106114  }
    107115
     116  naNumbOfPar=rPar(r);
    108117  if (i == 1)
    109118  {
     
    137146  nacGcd         = nacRing->cf->nGcd;
    138147  nacLcm         = nacRing->cf->nLcm;
     148  nacDelete      = nacRing->cf->cfDelete;
    139149  nacMult        = nacRing->cf->nMult;
    140150  nacDiv         = nacRing->cf->nDiv;
     
    153163  {
    154164    if (naIsChar0)
    155       nlDBTest(napGetCoeff(p), "", 0);
     165      nlDBTest(pGetCoeff(p), "", 0);
    156166    pIter(p);
    157167  }
     
    162172
    163173#define napInit(i)       (napoly)p_ISet(i,nacRing)
    164 #define napSetCoeff(p,n) p_SetCoeff(p,n,nacRing);
     174#define napSetCoeff(p,n) {nacDelete(&pGetCoeff(p),nacRing);pGetCoeff(p)=n;}
    165175#define napDelete1(p)    p_LmDelete((poly *)p, nacRing)
    166176#define nap_Copy(p,r)       (napoly)p_Copy((poly)p,r->algring)
     
    178188{
    179189  napoly a = (napoly)p_Init(nacRing);
    180   napGetCoeff(a) = z;
     190  pGetCoeff(a) = z;
    181191  return a;
    182192}
     
    193203
    194204/*3
     205* returns ph * z
     206*/
     207static void napMultN(napoly p, number z)
     208{
     209  number t;
     210
     211  while (p!=NULL)
     212  {
     213    t = nacMult(pGetCoeff(p), z);
     214    nacNormalize(t);
     215    nacDelete(&pGetCoeff(p),nacRing);
     216    pGetCoeff(p) = t;
     217    pIter(p);
     218  }
     219}
     220
     221/*3
    195222*  division with rest; f = g*q + r, returns r and destroy f
    196223*/
     
    201228  qq = (napoly)p_Init(nacRing);
    202229  pNext(qq) = NULL;
    203   p_Normalize(g,nacRing);
    204   p_Normalize(f,nacRing);
     230  napNormalize(g);
     231  napNormalize(f);
    205232  a = f;
    206233  do
     
    208235    napSetExp(qq,1, napGetExp(a,1) - napGetExp(g,1));
    209236    napSetm(qq);
    210     napGetCoeff(qq) = nacDiv(napGetCoeff(a), napGetCoeff(g));
    211     napGetCoeff(qq) = nacNeg(napGetCoeff(qq));
    212     nacNormalize(napGetCoeff(qq));
     237    pGetCoeff(qq) = nacDiv(pGetCoeff(a), pGetCoeff(g));
     238    pGetCoeff(qq) = nacNeg(pGetCoeff(qq));
     239    nacNormalize(pGetCoeff(qq));
    213240    h = napCopy(g);
    214241    napMultT(h, qq);
    215     p_Normalize(h,nacRing);
    216     n_Delete(&napGetCoeff(qq),nacRing);
     242    napNormalize(h);
     243    nacDelete(&pGetCoeff(qq),nacRing);
    217244    a = napAdd(a, h);
    218245  }
     
    231258  qq = (napoly)p_Init(nacRing);
    232259  pNext(qq) = b = NULL;
    233   p_Normalize(g,nacRing);
    234   p_Normalize(f,nacRing);
     260  napNormalize(g);
     261  napNormalize(f);
    235262  a = f;
    236263  do
     
    238265    napSetExp(qq,1, napGetExp(a,1) - napGetExp(g,1));
    239266    p_Setm(qq,nacRing);
    240     napGetCoeff(qq) = nacDiv(napGetCoeff(a), napGetCoeff(g));
    241     nacNormalize(napGetCoeff(qq));
     267    pGetCoeff(qq) = nacDiv(pGetCoeff(a), pGetCoeff(g));
     268    nacNormalize(pGetCoeff(qq));
    242269    b = napAdd(b, napCopy(qq));
    243     napGetCoeff(qq) = nacNeg(napGetCoeff(qq));
     270    pGetCoeff(qq) = nacNeg(pGetCoeff(qq));
    244271    h = napCopy(g);
    245272    napMultT(h, qq);
    246     p_Normalize(h,nacRing);
    247     n_Delete(&napGetCoeff(qq),nacRing);
     273    napNormalize(h);
     274    nacDelete(&pGetCoeff(qq),nacRing);
    248275    a = napAdd(a, h);
    249276  }
     
    270297  if (napGetExp(x,1)==0)
    271298  {
    272     if (!nacIsOne(napGetCoeff(x)))
    273     {
    274       nacNormalize(napGetCoeff(x));
    275       t = nacInvers(napGetCoeff(x));
     299    if (!nacIsOne(pGetCoeff(x)))
     300    {
     301      nacNormalize(pGetCoeff(x));
     302      t = nacInvers(pGetCoeff(x));
    276303      nacNormalize(t);
    277       n_Delete(&napGetCoeff(x),nacRing);
    278       napGetCoeff(x) = t;
     304      nacDelete(&pGetCoeff(x),nacRing);
     305      pGetCoeff(x) = t;
    279306    }
    280307    return x;
     
    288315  if (napGetExp(r,1)==0)
    289316  {
    290     nacNormalize(napGetCoeff(r));
    291     t = nacInvers(napGetCoeff(r));
     317    nacNormalize(pGetCoeff(r));
     318    t = nacInvers(pGetCoeff(r));
    292319    nacNormalize(t);
    293320    t = nacNeg(t);
    294     qa=p_Mult_nn(qa,t,nacRing); p_Normalize(qa,nacRing);
    295     n_Delete(&t,nacRing);
    296     p_Normalize(qa,nacRing);
     321    napMultN(qa, t);
     322    nacDelete(&t,nacRing);
     323    napNormalize(qa);
    297324    p_Delete(&x,nacRing);
    298325    p_Delete(&r,nacRing);
     
    310337    q = napMult(q, qa);
    311338    q = napAdd(q, napInit(1));
    312     nacNormalize(napGetCoeff(r));
    313     t = nacInvers(napGetCoeff(r));
    314     q=p_Mult_nn(q,t,nacRing); p_Normalize(q,nacRing);
    315     p_Normalize(q,nacRing);
    316     n_Delete(&t,nacRing);
     339    nacNormalize(pGetCoeff(r));
     340    t = nacInvers(pGetCoeff(r));
     341    napMultN(q, t);
     342    napNormalize(q);
     343    nacDelete(&t,nacRing);
    317344    p_Delete(&x,nacRing);
    318345    p_Delete(&r,nacRing);
     
    338365      q = napNeg(q);
    339366      q = napAdd(q, qa);
    340       nacNormalize(napGetCoeff(r));
    341       t = nacInvers(napGetCoeff(r));
     367      nacNormalize(pGetCoeff(r));
     368      t = nacInvers(pGetCoeff(r));
    342369      //nacNormalize(t);
    343       q=p_Mult_nn(q,t,nacRing); p_Normalize(q,nacRing);
    344       p_Normalize(q,nacRing);
    345       n_Delete(&t,nacRing);
     370      napMultN(q, t);
     371      napNormalize(q);
     372      nacDelete(&t,nacRing);
    346373      p_Delete(&x,nacRing);
    347374      p_Delete(&r,nacRing);
     
    406433    if (has_denom)
    407434    {
    408       number den=n_GetDenom(napGetCoeff(p), nacRing);
     435      number den=nacRing->cf->cfGetDenom(pGetCoeff(p), nacRing);
    409436      kl=!n_IsOne(den,nacRing);
    410437      n_Delete(&den, nacRing);
     
    412439    if (kl) StringAppendS("(");
    413440    //StringAppendS("-1");
    414     nacWrite(napGetCoeff(p));
     441    nacWrite(pGetCoeff(p));
    415442    if (kl) StringAppendS(")");
    416443  }
     
    422449      BOOLEAN wroteCoeff=FALSE;
    423450      if ((napIsConstant(p))
    424       || ((!nacIsOne(napGetCoeff(p)))
    425         && (!nacIsMOne(napGetCoeff(p)))))
     451      || ((!nacIsOne(pGetCoeff(p)))
     452        && (!nacIsMOne(pGetCoeff(p)))))
    426453      {
    427         nacWrite(napGetCoeff(p));
     454        nacWrite(pGetCoeff(p));
    428455        wroteCoeff=(currRing->ShortOut==0);
    429456      }
    430       else if (nacIsMOne(napGetCoeff(p)))
     457      else if (nacIsMOne(pGetCoeff(p)))
    431458      {
    432459        StringAppendS("-");
    433460      }
    434461      int  i;
    435       for (i = 0; i < rPar(currRing); i++)
     462      for (i = 0; i < naNumbOfPar; i++)
    436463      {
    437464        if (napGetExp(p,i+1) > 0)
     
    453480      if (p==NULL)
    454481        break;
    455       if (nacGreaterZero(napGetCoeff(p)))
     482      if (nacGreaterZero(pGetCoeff(p)))
    456483        StringAppendS("+");
    457484    }
     
    496523  if ((*s >= '0') && (*s <= '9'))
    497524  {
    498     s = nacRead(s, &napGetCoeff(a));
    499     if (nacIsZero(napGetCoeff(a)))
     525    s = nacRead(s, &pGetCoeff(a));
     526    if (nacIsZero(pGetCoeff(a)))
    500527    {
    501528      napDelete1(&a);
     
    505532  }
    506533  else
    507     napGetCoeff(a) = nacInit(1);
     534    pGetCoeff(a) = nacInit(1);
    508535  i = 0;
    509536  const char  *olds=s;
     
    513540    if (olds == s)
    514541      i++;
    515     else if (*s == '\0')
     542    else if (*s == '\0') 
    516543    {
    517544      *b = a;
    518545      return s;
    519546    }
    520     if (i >= rPar(currRing))
     547    if (i >= naNumbOfPar)
    521548      break;
    522549  }
     
    530557    else
    531558      i = 0;
    532     if ((*s == '\0') || (i >= rPar(currRing)))
     559    if ((*s == '\0') || (i >= naNumbOfPar))
    533560      break;
    534561  }
     
    585612
    586613  p = ph;
    587   if (nacIsOne(napGetCoeff(p)))
     614  if (nacIsOne(pGetCoeff(p)))
    588615    return;
    589   h = nacCopy(napGetCoeff(p));
     616  h = nacCopy(pGetCoeff(p));
    590617  pIter(p);
    591618  do
    592619  {
    593     d=nacGcd(napGetCoeff(p), h, nacRing);
     620    d=nacGcd(pGetCoeff(p), h, nacRing);
    594621    if(nacIsOne(d))
    595622    {
    596       n_Delete(&h,nacRing);
    597       n_Delete(&d,nacRing);
     623      nacDelete(&h,nacRing);
     624      nacDelete(&d,nacRing);
    598625      return;
    599626    }
    600     n_Delete(&h,nacRing);
     627    nacDelete(&h,nacRing);
    601628    h = d;
    602629    pIter(p);
     
    604631  while (p!=NULL);
    605632  h = nacInvers(d);
    606   n_Delete(&d,nacRing);
     633  nacDelete(&d,nacRing);
    607634  p = ph;
    608635  while (p!=NULL)
    609636  {
    610     d = nacMult(napGetCoeff(p), h);
    611     n_Delete(&napGetCoeff(p),nacRing);
    612     napGetCoeff(p) = d;
     637    d = nacMult(pGetCoeff(p), h);
     638    nacDelete(&pGetCoeff(p),nacRing);
     639    pGetCoeff(p) = d;
    613640    pIter(p);
    614641  }
    615   n_Delete(&h,nacRing);
     642  nacDelete(&h,nacRing);
    616643}
    617644
     
    627654  while (p!=NULL)
    628655  {
    629     d = nacLcm(h, napGetCoeff(p), nacRing);
    630     n_Delete(&h,nacRing);
     656    d = nacLcm(h, pGetCoeff(p), nacRing);
     657    nacDelete(&h,nacRing);
    631658    h = d;
    632659    pIter(p);
     
    635662  {
    636663    p = ph;
    637     p=p_Mult_nn(p,h,nacRing);p_Normalize(p,nacRing);
    638     n_Delete(&h,nacRing);
     664    while (p!=NULL)
     665    {
     666      d=nacMult(h, pGetCoeff(p));
     667      nacDelete(&pGetCoeff(p),nacRing);
     668      nacNormalize(d);
     669      pGetCoeff(p) = d;
     670      pIter(p);
     671    }
     672    nacDelete(&h,nacRing);
    639673  }
    640674  napContent(ph);
     
    646680  if (!naIsChar0)
    647681    return napInit(1);
    648   x = nacCopy(napGetCoeff(a));
     682  x = nacCopy(pGetCoeff(a));
    649683  if (nacIsOne(x))
    650684    return napInitz(x);
     
    652686  {
    653687    pIter(a);
    654     y = nacGcd(x, napGetCoeff(a), nacRing);
    655     n_Delete(&x,nacRing);
     688    y = nacGcd(x, pGetCoeff(a), nacRing);
     689    nacDelete(&x,nacRing);
    656690    x = y;
    657691    if (nacIsOne(x))
     
    660694  do
    661695  {
    662     y = nacGcd(x, napGetCoeff(b), nacRing);
    663     n_Delete(&x,nacRing);
     696    y = nacGcd(x, pGetCoeff(b), nacRing);
     697    nacDelete(&x,nacRing);
    664698    x = y;
    665699    if (nacIsOne(x))
     
    679713  napoly g, x, y, h;
    680714  if ((a==NULL)
    681   || ((pNext(a)==NULL)&&(nacIsZero(napGetCoeff(a)))))
     715  || ((pNext(a)==NULL)&&(nacIsZero(pGetCoeff(a)))))
    682716  {
    683717    if ((b==NULL)
    684     || ((pNext(b)==NULL)&&(nacIsZero(napGetCoeff(b)))))
     718    || ((pNext(b)==NULL)&&(nacIsZero(pGetCoeff(b)))))
    685719    {
    686720      return napInit(1);
     
    690724  else
    691725  if ((b==NULL)
    692   || ((pNext(b)==NULL)&&(nacIsZero(napGetCoeff(b)))))
     726  || ((pNext(b)==NULL)&&(nacIsZero(pGetCoeff(b)))))
    693727  {
    694728    return napCopy(a);
     
    722756      {
    723757        napCleardenom(y);
    724         if (!nacIsOne(napGetCoeff(g)))
    725         {
    726           y=p_Mult_nn(y,napGetCoeff(g),nacRing);
    727           p_Normalize(y,nacRing);
    728         }
     758        if (!nacIsOne(pGetCoeff(g)))
     759          napMultN(y, pGetCoeff(g));
    729760        napDelete1(&g);
    730761        return y;
     
    747778  if (!naIsChar0) x = napInit(1);
    748779  else            x = napGcd0(g,h);
    749   for (i=(rPar(currRing)-1); i>=0; i--)
     780  for (i=(naNumbOfPar-1); i>=0; i--)
    750781  {
    751782    napSetExp(x,i+1, napExpi(i,a,b));
     
    767798    while (b!=NULL)
    768799    {
    769       d = nacLcm(h, napGetCoeff(b), nacRing);
    770       n_Delete(&h,nacRing);
     800      d = nacLcm(h, pGetCoeff(b), nacRing);
     801      nacDelete(&h,nacRing);
    771802      h = d;
    772803      pIter(b);
     
    789820  {
    790821    j++;
    791     if (j > rPar(currRing))
     822    if (j > naNumbOfPar)
    792823      return 1;
    793824  }
     
    811842    {
    812843      /* h = lt(q)/lt(naI->liste[i])*/
    813       napGetCoeff(h) = nacCopy(napGetCoeff(q));
    814       for (j=rPar(currRing); j>0; j--)
     844      pGetCoeff(h) = nacCopy(pGetCoeff(q));
     845      for (j=naNumbOfPar; j>0; j--)
    815846        napSetExp(h,j, napGetExp(q,j) - napGetExp(naI->liste[i],j));
    816847      p_Setm(h,nacRing);
     
    929960  if ((l!=NULL)&&(l->n==NULL)&&(napIsConstant(l->z)))
    930961  {
    931     return nacInt(napGetCoeff(l->z));
     962    return nacInt(pGetCoeff(l->z));
    932963  }
    933964  return 0;
     
    9871018
    9881019/*2
     1020*  addition; lu:= la + lb
     1021*/
     1022number naAdd(number la, number lb)
     1023{
     1024  napoly x, y;
     1025  lnumber lu;
     1026  lnumber a = (lnumber)la;
     1027  lnumber b = (lnumber)lb;
     1028  if (a==NULL) return naCopy(lb);
     1029  if (b==NULL) return naCopy(la);
     1030  omCheckAddrSize(a,sizeof(snumber));
     1031  omCheckAddrSize(b,sizeof(snumber));
     1032  lu = (lnumber)omAllocBin(rnumber_bin);
     1033  if (b->n!=NULL) x = napMultCopy(a->z, b->n);
     1034  else            x = napCopy(a->z);
     1035  if (a->n!=NULL) y = napMultCopy(b->z, a->n);
     1036  else            y = napCopy(b->z);
     1037  lu->z = napAdd(x, y);
     1038  if (lu->z==NULL)
     1039  {
     1040    omFreeBin((ADDRESS)lu,  rnumber_bin);
     1041    return (number)NULL;
     1042  }
     1043  if (a->n!=NULL)
     1044  {
     1045    if (b->n!=NULL) x = napMultCopy(a->n, b->n);
     1046    else            x = napCopy(a->n);
     1047  }
     1048  else
     1049  {
     1050    if (b->n!=NULL) x = napCopy(b->n);
     1051    else            x = NULL;
     1052  }
     1053  //if (x!=NULL)
     1054  //{
     1055  //  if (napIsConstant(x))
     1056  //  {
     1057  //    number inv=nacInvers(pGetCoeff(x));
     1058  //    napMultN(lu->z,inv);
     1059  //    nacDelete(&inv,nacRing);
     1060  //    napDelete(&x);
     1061  //  }
     1062  //}
     1063  lu->n = x;
     1064  lu->s = FALSE;
     1065  if (lu->n!=NULL)
     1066  {
     1067     number luu=(number)lu;
     1068     naNormalize0(luu);
     1069     lu=(lnumber)luu;
     1070  }
     1071  naTest((number)lu);
     1072  return (number)lu;
     1073}
     1074
     1075/*2
     1076*  subtraction; r:= la - lb
     1077*/
     1078number naSub(number la, number lb)
     1079{
     1080  lnumber lu;
     1081
     1082  if (lb==NULL) return naCopy(la);
     1083  if (la==NULL)
     1084  {
     1085    lu = (lnumber)naCopy(lb);
     1086    lu->z = napNeg(lu->z);
     1087    return (number)lu;
     1088  }
     1089
     1090  lnumber a = (lnumber)la;
     1091  lnumber b = (lnumber)lb;
     1092
     1093  omCheckAddrSize(a,sizeof(snumber));
     1094  omCheckAddrSize(b,sizeof(snumber));
     1095
     1096  napoly x, y;
     1097  lu = (lnumber)omAllocBin(rnumber_bin);
     1098  if (b->n!=NULL) x = napMultCopy(a->z, b->n);
     1099  else            x = napCopy(a->z);
     1100  if (a->n!=NULL) y = napMult(napCopy(b->z), napCopyNeg(a->n));
     1101  else            y = napCopyNeg(b->z);
     1102  lu->z = napAdd(x, y);
     1103  if (lu->z==NULL)
     1104  {
     1105    omFreeBin((ADDRESS)lu,  rnumber_bin);
     1106    return (number)NULL;
     1107  }
     1108  if (a->n!=NULL)
     1109  {
     1110    if (b->n!=NULL) x = napMultCopy(a->n, b->n);
     1111    else            x = napCopy(a->n);
     1112  }
     1113  else
     1114  {
     1115    if (b->n!=NULL) x = napCopy(b->n);
     1116    else            x = NULL;
     1117  }
     1118  //if (x!=NULL)
     1119  //{
     1120  //  if (napIsConstant(x))
     1121  //  {
     1122  //    number inv=nacInvers(pGetCoeff(x));
     1123  //    napMultN(lu->z,inv);
     1124  //    nacDelete(&inv,nacRing);
     1125  //    napDelete(&x);
     1126  //  }
     1127  //}
     1128  lu->n = x;
     1129  lu->s = FALSE;
     1130  if (lu->n!=NULL)
     1131  {
     1132     number luu=(number)lu;
     1133     naNormalize0(luu);
     1134     lu=(lnumber)luu;
     1135  }
     1136  naTest((number)lu);
     1137  return (number)lu;
     1138}
     1139
     1140/*2
    9891141*  multiplication; r:= la * lb
    9901142*/
     
    10441196    }
    10451197  }
    1046   if ((x!=NULL) && (napIsConstant(x)) && nacIsOne(napGetCoeff(x)))
     1198  if ((x!=NULL) && (napIsConstant(x)) && nacIsOne(pGetCoeff(x)))
    10471199    p_Delete(&x,nacRing);
    10481200  lo->n = x;
     
    10571209    lo->s = 0;
    10581210    number luu=(number)lo;
    1059     naNormalize(luu);
     1211    naNormalize0(luu);
    10601212    lo=(lnumber)luu;
    10611213  }
     
    10911243  naNormalize(nres);
    10921244
    1093   //p_Delete(&res->n,nacRing);
     1245  //napDelete(&res->n);
    10941246  naTest(nres);
    10951247  return nres;
     
    11441296    }
    11451297  }
    1146   if ((napIsConstant(x)) && nacIsOne(napGetCoeff(x)))
     1298  if ((napIsConstant(x)) && nacIsOne(pGetCoeff(x)))
    11471299    p_Delete(&x,nacRing);
    11481300  lo->n = x;
     
    11961348    lo->z = napInit(1);
    11971349  x = b->z;
    1198   if ((!napIsConstant(x)) || !nacIsOne(napGetCoeff(x)))
     1350  if ((!napIsConstant(x)) || !nacIsOne(pGetCoeff(x)))
    11991351    x = napCopy(x);
    12001352  else
     
    12151367    while (x!=NULL)
    12161368    {
    1217       nacNormalize(napGetCoeff(x));
     1369      nacNormalize(pGetCoeff(x));
    12181370      pIter(x);
    12191371    }
     
    12241376  {
    12251377     number luu=(number)lo;
    1226      naNormalize(luu);
     1378     naNormalize0(luu);
    12271379     lo=(lnumber)luu;
    12281380  }
     
    12521404  if ((zb!=NULL) && (zb->z!=NULL))
    12531405  {
    1254     return (nacGreaterZero(napGetCoeff(zb->z))||(!napIsConstant(zb->z)));
     1406    return (nacGreaterZero(pGetCoeff(zb->z))||(!napIsConstant(zb->z)));
    12551407  }
    12561408  /* else */ return FALSE;
     
    13531505    return NULL;
    13541506  int i;
    1355   char *s=(char *)omAlloc(4* rPar(currRing));
     1507  char *s=(char *)omAlloc(4* naNumbOfPar);
    13561508  char *t=(char *)omAlloc(8);
    13571509  s[0]='\0';
    1358   for (i = 0; i <= rPar(currRing) - 1; i++)
     1510  for (i = 0; i <= naNumbOfPar - 1; i++)
    13591511  {
    13601512    if (napGetExp(ph->z,i+1) > 0)
     
    14171569  if (a->n==NULL)
    14181570  {
    1419     if (napIsConstant(a->z))
     1571    if (napIsConstant(a->z)) 
    14201572    {
    14211573#ifdef LDEBUG
    14221574       if (a->z==NULL) return FALSE;
    1423        else
    1424 #endif
    1425          return nacIsOne(napGetCoeff(a->z));
     1575       else 
     1576#endif 
     1577         return nacIsOne(pGetCoeff(a->z));
    14261578    }
    14271579    else                 return FALSE;
     
    14351587    else
    14361588    {
    1437       t = nacSub(napGetCoeff(x), napGetCoeff(y));
     1589      t = nacSub(pGetCoeff(x), pGetCoeff(y));
    14381590      if (!nacIsZero(t))
    14391591      {
    1440         n_Delete(&t,nacRing);
     1592        nacDelete(&t,nacRing);
    14411593        return FALSE;
    14421594      }
    14431595      else
    1444         n_Delete(&t,nacRing);
     1596        nacDelete(&t,nacRing);
    14451597    }
    14461598    pIter(x);
     
    14761628  if (a->n==NULL)
    14771629  {
    1478     if (napIsConstant(a->z)) return nacIsMOne(napGetCoeff(a->z));
     1630    if (napIsConstant(a->z)) return nacIsMOne(pGetCoeff(a->z));
    14791631    /*else                   return FALSE;*/
    14801632  }
     
    15041656  if (a==NULL)  return naCopy(b);
    15051657  if (b==NULL)  return naCopy(a);
    1506 
     1658 
    15071659  lnumber x, y;
    15081660  lnumber result = (lnumber)omAlloc0Bin(rnumber_bin);
     
    15101662  x = (lnumber)a;
    15111663  y = (lnumber)b;
    1512   if ((rPar(currRing) == 1) && (naMinimalPoly!=NULL))
     1664  if ((naNumbOfPar == 1) && (naMinimalPoly!=NULL))
    15131665  {
    15141666    if (pNext(x->z)!=NULL)
     
    15281680    napoly rz=napGcd(x->z, y->z);
    15291681    CanonicalForm F, G, R;
    1530     R=convSingPFactoryP(rz,nacRing);
    1531     p_Normalize(x->z,nacRing);
    1532     F=convSingPFactoryP(x->z,nacRing)/R;
    1533     p_Normalize(y->z,nacRing);
    1534     G=convSingPFactoryP(y->z,nacRing)/R;
     1682    R=convSingPFactoryP(rz,nacRing); 
     1683    napNormalize(x->z);
     1684    F=convSingPFactoryP(x->z,nacRing)/R; 
     1685    napNormalize(y->z);
     1686    G=convSingPFactoryP(y->z,nacRing)/R; 
    15351687    F = gcd( F, G );
    1536     if (F.isOne())
     1688    if (F.isOne()) 
    15371689      result->z= rz;
    15381690    else
    15391691    {
    15401692      p_Delete(&rz,nacRing);
    1541       result->z=convFactoryPSingP( F*R, nacRing );
    1542       p_Normalize(result->z,nacRing);
     1693      result->z=convFactoryPSingP( F*R,nacRing );
     1694      napNormalize(result->z);
    15431695    }
    15441696  }
     
    15501702
    15511703/*2
    1552 * rPar(currRing) = 1:
     1704* naNumbOfPar = 1:
    15531705* clears denominator         algebraic case;
    15541706* tries to simplify ratio    transcendental case;
     
    15561708* cancels monomials
    15571709* occuring in denominator
    1558 * and enumerator  ?          rPar(currRing) != 1;
     1710* and enumerator  ?          naNumbOfPar != 1;
    15591711*
    1560 */
     1712* #defines for Factory:
     1713* FACTORY_GCD_TEST: do not apply built in gcd for
     1714*   univariate polynomials, always use Factory
     1715*/
     1716//#define FACTORY_GCD_TEST
    15611717void naNormalize(number &pp)
    15621718{
     
    15921748    while(x!=NULL)
    15931749    {
    1594       nacNormalize(napGetCoeff(x));
     1750      nacNormalize(pGetCoeff(x));
    15951751      pIter(x);
    15961752    }
     
    16021758    while(y!=NULL)
    16031759    {
    1604       nacNormalize(napGetCoeff(y));
     1760      nacNormalize(pGetCoeff(y));
    16051761      pIter(y);
    16061762    }
     
    16091765  /* collect all denoms from y and multiply x and y by it */
    16101766    number n=napLcm(y);
    1611     x=p_Mult_nn(x,n,nacRing);p_Normalize(x,nacRing);
    1612     y=p_Mult_nn(y,n,nacRing);p_Normalize(y,nacRing);
    1613     n_Delete(&n,nacRing);
     1767    napMultN(x,n);
     1768    napMultN(y,n);
     1769    nacDelete(&n,nacRing);
    16141770    while(x!=NULL)
    16151771    {
    1616       nacNormalize(napGetCoeff(x));
     1772      nacNormalize(pGetCoeff(x));
    16171773      pIter(x);
    16181774    }
     
    16201776    while(y!=NULL)
    16211777    {
    1622       nacNormalize(napGetCoeff(y));
     1778      nacNormalize(pGetCoeff(y));
    16231779      pIter(y);
    16241780    }
     
    16281784  {
    16291785    int i;
    1630     for (i=rPar(currRing)-1; i>=0; i--)
     1786    for (i=naNumbOfPar-1; i>=0; i--)
    16311787    {
    16321788      napoly xx=x;
     
    16501806  if (napIsConstant(y)) /* i.e. => simplify to (1/c)*z / monom */
    16511807  {
    1652     if (nacIsOne(napGetCoeff(y)))
     1808    if (nacIsOne(pGetCoeff(y)))
    16531809    {
    16541810      napDelete1(&y);
     
    16571813      return;
    16581814    }
    1659     number h1 = nacInvers(napGetCoeff(y));
     1815    number h1 = nacInvers(pGetCoeff(y));
    16601816    nacNormalize(h1);
    1661     x=p_Mult_nn(x,h1,nacRing);p_Normalize(x,nacRing);
    1662     n_Delete(&h1,nacRing);
     1817    napMultN(x, h1);
     1818    nacDelete(&h1,nacRing);
    16631819    napDelete1(&y);
    16641820    p->n = NULL;
     
    16661822    return;
    16671823  }
    1668   if (rPar(currRing) == 1) /* apply built-in gcd */
     1824#ifndef FACTORY_GCD_TEST
     1825  if (naNumbOfPar == 1) /* apply built-in gcd */
    16691826  {
    16701827    napoly x1,y1;
     
    17041861    {
    17051862      number n=napLcm(y);
    1706       x=p_Mult_nn(x,n,nacRing);p_Normalize(x,nacRing);
    1707       y=p_Mult_nn(y,n,nacRing);p_Normalize(y,nacRing);
    1708       n_Delete(&n,nacRing);
     1863      napMultN(x,n);
     1864      napMultN(y,n);
     1865      nacDelete(&n,nacRing);
    17091866      while(x!=NULL)
    17101867      {
    1711         nacNormalize(napGetCoeff(x));
     1868        nacNormalize(pGetCoeff(x));
    17121869        pIter(x);
    17131870      }
     
    17151872      while(y!=NULL)
    17161873      {
    1717         nacNormalize(napGetCoeff(y));
     1874        nacNormalize(pGetCoeff(y));
    17181875        pIter(y);
    17191876      }
     
    17221879    if (pNext(y)==NULL)
    17231880    {
    1724       if (nacIsOne(napGetCoeff(y)))
     1881      if (nacIsOne(pGetCoeff(y)))
    17251882      {
    17261883        if (napGetExp(y,1)==0)
     
    17341891    }
    17351892  }
     1893#endif /* FACTORY_GCD_TEST */
    17361894#ifdef HAVE_FACTORY
     1895#ifndef FACTORY_GCD_TEST
    17371896  else
     1897#endif
    17381898  {
    17391899    napoly xx,yy;
     
    17511911  x=p->z;
    17521912  y=p->n;
    1753   if(!nacGreaterZero(napGetCoeff(y)))
     1913  if(!nacGreaterZero(pGetCoeff(y)))
    17541914  {
    17551915    x=napNeg(x);
    17561916    y=napNeg(y);
    17571917  }
    1758   number g=nacCopy(napGetCoeff(x));
     1918  number g=nacCopy(pGetCoeff(x));
    17591919  pIter(x);
    17601920  while (x!=NULL)
    17611921  {
    1762     number d=nacGcd(g,napGetCoeff(x), nacRing);
     1922    number d=nacGcd(g,pGetCoeff(x), nacRing);
    17631923    if(nacIsOne(d))
    17641924    {
    1765       n_Delete(&g,nacRing);
    1766       n_Delete(&d,nacRing);
     1925      nacDelete(&g,nacRing);
     1926      nacDelete(&d,nacRing);
    17671927      naTest(pp);
    17681928      return;
    17691929    }
    1770     n_Delete(&g,nacRing);
     1930    nacDelete(&g,nacRing);
    17711931    g = d;
    17721932    pIter(x);
     
    17741934  while (y!=NULL)
    17751935  {
    1776     number d=nacGcd(g,napGetCoeff(y), nacRing);
     1936    number d=nacGcd(g,pGetCoeff(y), nacRing);
    17771937    if(nacIsOne(d))
    17781938    {
    1779       n_Delete(&g,nacRing);
    1780       n_Delete(&d,nacRing);
     1939      nacDelete(&g,nacRing);
     1940      nacDelete(&d,nacRing);
    17811941      naTest(pp);
    17821942      return;
    17831943    }
    1784     n_Delete(&g,nacRing);
     1944    nacDelete(&g,nacRing);
    17851945    g = d;
    17861946    pIter(y);
     
    17901950  while (x!=NULL)
    17911951  {
    1792     number d = nacIntDiv(napGetCoeff(x),g);
     1952    number d = nacIntDiv(pGetCoeff(x),g);
    17931953    napSetCoeff(x,d);
    17941954    pIter(x);
     
    17961956  while (y!=NULL)
    17971957  {
    1798     number d = nacIntDiv(napGetCoeff(y),g);
     1958    number d = nacIntDiv(pGetCoeff(y),g);
    17991959    napSetCoeff(y,d);
    18001960    pIter(y);
    18011961  }
    1802   n_Delete(&g,nacRing);
     1962  nacDelete(&g,nacRing);
    18031963  naTest(pp);
    18041964}
     
    18301990    while (xx!=NULL)
    18311991    {
    1832       bt = nacGcd(t, napGetCoeff(xx), nacRing);
    1833       r = nacMult(t, napGetCoeff(xx));
    1834       n_Delete(&napGetCoeff(xx),nacRing);
    1835       napGetCoeff(xx) = nacDiv(r, bt);
    1836       nacNormalize(napGetCoeff(xx));
    1837       n_Delete(&bt,nacRing);
    1838       n_Delete(&r,nacRing);
     1992      bt = nacGcd(t, pGetCoeff(xx), nacRing);
     1993      r = nacMult(t, pGetCoeff(xx));
     1994      nacDelete(&pGetCoeff(xx),nacRing);
     1995      pGetCoeff(xx) = nacDiv(r, bt);
     1996      nacNormalize(pGetCoeff(xx));
     1997      nacDelete(&bt,nacRing);
     1998      nacDelete(&r,nacRing);
    18391999      pIter(xx);
    18402000    }
    18412001  }
    1842   n_Delete(&t,nacRing);
     2002  nacDelete(&t,nacRing);
    18432003  result->z = x;
    18442004#ifdef HAVE_FACTORY
     
    18852045      naI->liste[i]=napCopy(h->z);
    18862046      /* If it isn't normalized (lc = 1) do this */
    1887       if (!nacIsOne(napGetCoeff(naI->liste[i])))
     2047      if (!nacIsOne(pGetCoeff(naI->liste[i])))
    18882048      {
    18892049        x=naI->liste[i];
    1890         nacNormalize(napGetCoeff(x));
    1891         a=nacCopy(napGetCoeff(x));
     2050        nacNormalize(pGetCoeff(x));
     2051        a=nacCopy(pGetCoeff(x));
    18922052        number aa=nacInvers(a);
    1893         n_Delete(&a,nacRing);
    1894         x=p_Mult_nn(x,aa,nacRing);p_Normalize(x,nacRing);
    1895         n_Delete(&aa,nacRing);
     2053        nacDelete(&a,nacRing);
     2054        napMultN(x,aa);
     2055        nacDelete(&aa,nacRing);
    18962056      }
    18972057    }
     
    19102070  int i=(int)((long)c);
    19112071  if (i>(naPrimeM>>2)) i-=naPrimeM;
    1912   napGetCoeff(l->z)=nlInit(i);
     2072  pGetCoeff(l->z)=nlInit(i);
    19132073  l->n=NULL;
    19142074  return (number)l;
     
    19242084  l->s=0;
    19252085  l->z=(napoly)p_Init(nacRing);
    1926   napGetCoeff(l->z)=nlCopy(c);
     2086  pGetCoeff(l->z)=nlCopy(c);
    19272087  l->n=NULL;
    19282088  return (number)l;
     
    19382098  l->s=2;
    19392099  l->z=(napoly)p_Init(nacRing);
    1940   napGetCoeff(l->z)=c; /* omit npCopy, because npCopy is a no-op */
     2100  pGetCoeff(l->z)=c; /* omit npCopy, because npCopy is a no-op */
    19412101  l->n=NULL;
    19422102  return (number)l;
     
    19562116  l->s=2;
    19572117  l->z=(napoly)p_Init(nacRing);
    1958   napGetCoeff(l->z)=n;
     2118  pGetCoeff(l->z)=n;
    19592119  l->n=NULL;
    19602120  return (number)l;
     
    19732133  l->s=2;
    19742134  l->z=(napoly)p_Init(nacRing);
    1975   napGetCoeff(l->z)=n;
     2135  pGetCoeff(l->z)=n;
    19762136  l->n=NULL;
    19772137  return (number)l;
     
    19912151    napSetExp(a,i,napGetExpFrom(p,i,napMapRing));
    19922152  p_Setm(a,nacRing);
    1993   napGetCoeff(w) = nacMap(napGetCoeff(p));
     2153  pGetCoeff(w) = nacMap(pGetCoeff(p));
    19942154  loop
    19952155  {
     
    20012161      napSetExp(a,i,napGetExpFrom(p,i,napMapRing));
    20022162    p_Setm(a,nacRing);
    2003     napGetCoeff(a) = nacMap(napGetCoeff(p));
     2163    pGetCoeff(a) = nacMap(pGetCoeff(p));
    20042164  }
    20052165  pNext(a) = NULL;
     
    20282188        not_null=FALSE;
    20292189    }
    2030     napGetCoeff(w) = nMap(napGetCoeff(p));
     2190    pGetCoeff(w) = nMap(pGetCoeff(p));
    20312191    p_Setm(w,nacRing);
    20322192    pIter(p);
     
    20392199      }
    20402200      /* else continue*/
    2041       n_Delete(&(napGetCoeff(w)),nacRing);
     2201      nacDelete(&(pGetCoeff(w)),nacRing);
    20422202    }
    20432203    else
     
    20802240      if (napGetExp(erg->n,1) >= napGetExp(naMinimalPoly,1))
    20812241        erg->n = napRemainder(erg->n, naMinimalPoly);
    2082       if ((napIsConstant(erg->n)) && nacIsOne(napGetCoeff(erg->n)))
     2242      if ((napIsConstant(erg->n)) && nacIsOne(pGetCoeff(erg->n)))
    20832243        p_Delete(&(erg->n),nacRing);
    20842244    }
     
    22012361      pan=(lnumber)pGetCoeff(p);
    22022362      pan->s=2;
    2203       pan->z=napInitz(nMap(napGetCoeff(za)));
     2363      pan->z=napInitz(nMap(pGetCoeff(za)));
    22042364      pa=pan->z;
    22052365    }
    22062366    else
    22072367    {
    2208       pGetCoeff(p)=nMap(napGetCoeff(za));
     2368      pGetCoeff(p)=nMap(pGetCoeff(za));
    22092369    }
    22102370    for(i=0;i<P;i++)
     
    22702430  {
    22712431    lnumber rr=(lnumber)omAlloc0Bin(rnumber_bin);
    2272     rr->z=nap_Copy(naGetDenom0(x),r);
     2432    rr->z=nap_Copy(x->n,r);
    22732433    rr->s = 2;
    22742434    return (number)rr;
     
    22762436  return r->cf->nInit(1);
    22772437}
    2278 number   naGetNumerator(number &n, const ring r)
     2438
     2439number   naNumerator(number &n, const ring r)
    22792440{
    22802441  if (r==currRing) naNormalize(n);
    22812442  lnumber x=(lnumber)n;
    2282   if (x!=NULL)
    2283   {
    2284     lnumber rr=(lnumber)omAlloc0Bin(rnumber_bin);
    2285     rr->z=nap_Copy(naGetNom0(x),r);
    2286     rr->s = 2;
    2287     return (number)rr;
    2288   }
    2289   return NULL;
     2443  lnumber rr=(lnumber)omAlloc0Bin(rnumber_bin);
     2444  rr->z=nap_Copy(x->z,r);
     2445  rr->s = 2;
     2446  return (number)rr;
    22902447}
    22912448
     
    23052462  while(p!=NULL)
    23062463  {
    2307     if ((naIsChar0 && nlIsZero(napGetCoeff(p)))
    2308     || ((!naIsChar0) && npIsZero(napGetCoeff(p))))
     2464    if ((naIsChar0 && nlIsZero(pGetCoeff(p)))
     2465    || ((!naIsChar0) && npIsZero(pGetCoeff(p))))
    23092466    {
    23102467      Print("coeff 0 in %s:%d\n",f,l);
     
    23222479    //  return FALSE;
    23232480    //}
    2324     if (naIsChar0 && !(nlDBTest(napGetCoeff(p),f,l)))
     2481    if (naIsChar0 && !(nlDBTest(pGetCoeff(p),f,l)))
    23252482      return FALSE;
    23262483    pIter(p);
    23272484  }
    2328   p = naGetDenom0(x);
     2485  p = x->n;
    23292486  while(p!=NULL)
    23302487  {
    2331     if (naIsChar0 && !(nlDBTest(napGetCoeff(p),f,l)))
     2488    if (naIsChar0 && !(nlDBTest(pGetCoeff(p),f,l)))
    23322489      return FALSE;
    23332490    pIter(p);
     
    23362493}
    23372494#endif
    2338 //-------------------------------------------------------------------------
    2339 /// static: Normalize: case mipo==0, result: n->z, n->n integer
    2340 static void naNormalize_0(number n)
    2341 {
    2342   lnumber p = (lnumber) n;
    2343   napoly x = p->z;
    2344   napoly y = p->n;
    2345   if (nacRing->cf->nNormalize!=nDummy2)
    2346   {
    2347     /* collect all denoms from x and multiply x and y by it */
    2348     number n;
    2349     if (y!=NULL)
    2350     {
    2351       n=napLcm(y);
    2352       x=p_Mult_nn(x,n,nacRing); p_Normalize(x,nacRing);
    2353       y=p_Mult_nn(y,n,nacRing); p_Normalize(y,nacRing);
    2354       n_Delete(&n,nacRing);
    2355     }
    2356     /* collect all denoms from x and multiply x and y by it */
    2357     n=napLcm(y);
    2358     x=p_Mult_nn(x,n,nacRing);
    2359     if (y!=NULL)   { y=p_Mult_nn(y,n,nacRing); n_Delete(&n,nacRing); }
    2360     else           y=p_NSet(n,nacRing);
    2361     p->n=y;
    2362     // normalize all coeffs in x
    2363     p_Normalize(x,nacRing);
    2364     // normalize all coeffs in y
    2365     p_Normalize(y,nacRing);
    2366   }
    2367 }
    2368 /// return la+li
    2369 number  naAdd(number la, number lb)               /* lu := la+lb */
    2370 {
    2371   napoly x, y;
    2372   lnumber lu;
    2373   lnumber a = (lnumber)la;
    2374   lnumber b = (lnumber)lb;
    2375   if (a==NULL) return naCopy(lb);
    2376   if (b==NULL) return naCopy(la);
    2377   omCheckAddrSize(a,sizeof(snumber));
    2378   omCheckAddrSize(b,sizeof(snumber));
    2379   lu = (lnumber)omAllocBin(rnumber_bin);
    2380   if (b->n!=NULL) x = pp_Mult_qq(a->z, b->n, nacRing);
    2381   else            x = p_Copy(a->z,nacRing);
    2382   if (a->n!=NULL) y = pp_Mult_qq(b->z, a->n,nacRing);
    2383   else            y = p_Copy(b->z,nacRing);
    2384   lu->z = p_Add_q(x, y,nacRing);
    2385   if (lu->z==NULL)
    2386   {
    2387     omFreeBin((ADDRESS)lu,  rnumber_bin);
    2388     return (number)NULL;
    2389   }
    2390   if (a->n!=NULL)
    2391   {
    2392     if (b->n!=NULL) x = pp_Mult_qq(a->n, b->n,nacRing);
    2393     else            x = p_Copy(a->n,nacRing);
    2394   }
    2395   else
    2396   {
    2397     if (b->n!=NULL) x = p_Copy(b->n,nacRing);
    2398     else            x = NULL;
    2399   }
    2400   lu->n = x;
    2401   lu->s = FALSE;
    2402   if (lu->n!=NULL)
    2403   {
    2404      number luu=(number)lu;
    2405      naNormalize_0(luu);
    2406      lu=(lnumber)luu;
    2407   }
    2408   naTest((number)lu);
    2409   return (number)lu;
    2410 }
    2411 
    2412 /// return la -lb
    2413 number  naSub(number la, number lb)               /* lu := la-lb */
    2414 {
    2415   number llb=naCopy(lb);
    2416   llb=naNeg(llb);
    2417   number res=naAdd(la,llb);
    2418   naDelete(&llb,currRing);
    2419   return res;
    2420 }
     2495
  • kernel/longalg.h

    r43c5718 rb3af93  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: longalg.h,v 1.15 2009-08-14 17:14:30 Singular Exp $ */
     6/* $Id: longalg.h,v 1.16 2009-08-21 10:55:46 Singular Exp $ */
    77/*
    88* ABSTRACT:   algebraic numbers
     
    8080#define napSetm(p)             p_Setm(p,currRing->algring)
    8181#define nanumber               lnumber
    82 #define naGetNom0(na)          (((nanumber)(na))->z)
    83 #define naGetDenom0(na)        (((nanumber)(na))->n)
    8482napoly napRemainder(napoly f, const napoly  g);
    8583void napWrite(napoly l,const BOOLEAN denom=TRUE);
Note: See TracChangeset for help on using the changeset viewer.