Changeset a9a5cf8 in git


Ignore:
Timestamp:
Jan 30, 2003, 3:53:42 PM (21 years ago)
Author:
Hans Schönemann <hannes@…>
Branches:
(u'spielwiese', '8e0ad00ce244dfd0756200662572aef8402f13d5')
Children:
73c183e64c399fcc250e8964df3457cc5be93544
Parents:
f49ee6feb3fddafcdda5d98c40b25f3f82a38afa
Message:
* hannes: now in sync with V-2-0patches branch:
          * nacRing is a new variable for currRing->algring
          * fixes for the correct ring in nacDelete etc.
	  * nac* routine come now from r->algring->cf
	  (preparation for NV_OPS)


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

Legend:

Unmodified
Added
Removed

  • Singular/longalg.cc

    rf49ee6 ra9a5cf8  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: longalg.cc,v 1.68 2002-07-23 13:09:35 Singular Exp $ */
     4/* $Id: longalg.cc,v 1.69 2003-01-30 14:53:42 Singular Exp $ */
    55/*
    66* ABSTRACT:   algebraic numbers
    … …  
    3535#else /* LONGALGNEW */
    3636#define naParNames (currRing->parameter)
     37#define napNormalize(p) p_Normalize(p,nacRing)
    3738#endif /* LONGALGNEW */
    3839static int naIsChar0;
    … …  
    7273static BOOLEAN napDivPoly(napoly p, napoly q);
    7374static int napExpi(int i, napoly a, napoly b);
     75static ring nacRing;
    7476
    7577static number nadGcd( number a, number b, const ring r) { return nacInit(1); }
    … …  
    102104  {
    103105    naIsChar0 = 1;
    104     nacDelete      = nlDelete;
    105     nacInit        = nlInit;
    106     nacInt         = nlInt;
    107     nacCopy        = nlCopy;
    108     nacAdd         = nlAdd;
    109     nacSub         = nlSub;
    110     nacMult        = nlMult;
    111     nacDiv         = nlDiv;
    112     nacIntDiv      = nlIntDiv;
    113     nacInvers      = nlInvers;
    114     nacNormalize   = nlNormalize;
    115     nacNeg         = nlNeg;
    116     nacIsZero      = nlIsZero;
    117     nacRead        = nlRead;
    118     nacWrite       = nlWrite;
    119     nacGreaterZero = nlGreaterZero;
    120     nacIsOne       = nlIsOne;
    121     nacIsMOne      = nlIsMOne;
    122     nacGcd         = nlGcd;
    123     nacLcm         = nlLcm;
    124106  }
    125107  else if (i < 0)
    126108  {
    127109    naIsChar0 = 0;
    128     nacDelete      = ndDelete;
    129     npSetChar(-i, r->algring); // to be changes HS
    130     nacInit        = npInit;
    131     nacInt         = npInt;
    132     nacCopy        = ndCopy;
    133     nacAdd         = npAdd;
    134     nacSub         = npSub;
    135     nacMult        = npMult;
    136     nacDiv         = npDiv;
    137     nacIntDiv      = npDiv;
    138     nacInvers      = npInvers;
    139     nacNormalize   = nDummy2;
    140     nacNeg         = npNeg;
    141     nacIsZero      = npIsZero;
    142     nacRead        = npRead;
    143     nacWrite       = npWrite;
    144     nacGreaterZero = npGreaterZero;
    145     nacIsOne       = npIsOne;
    146     nacIsMOne      = npIsMOne;
    147     nacGcd         = nadGcd;
    148     nacLcm         = nadGcd;
     110    npSetChar(-i, r->algring); // to be changed HS
    149111  }
    150112#ifdef TEST
    … …  
    154116  }
    155117#endif
     118  nacRing        = r->algring;
     119  nacInit        = nacRing->cf->nInit;
     120  nacInt         = nacRing->cf->nInt;
     121  nacCopy        = nacRing->cf->nCopy;
     122  nacAdd         = nacRing->cf->nAdd;
     123  nacSub         = nacRing->cf->nSub;
     124  nacNormalize   = nacRing->cf->nNormalize;
     125  nacNeg         = nacRing->cf->nNeg;
     126  nacIsZero      = nacRing->cf->nIsZero;
     127  nacRead        = nacRing->cf->nRead;
     128  nacWrite       = nacRing->cf->nWrite;
     129  nacGreaterZero = nacRing->cf->nGreaterZero;
     130  nacIsOne       = nacRing->cf->nIsOne;
     131  nacIsMOne      = nacRing->cf->nIsMOne;
     132  nacGcd         = nacRing->cf->nGcd;
     133  nacLcm         = nacRing->cf->nLcm;
     134  nacDelete      = nacRing->cf->cfDelete;
     135  nacMult        = nacRing->cf->nMult;
     136  nacDiv         = nacRing->cf->nDiv;
     137  nacIntDiv      = nacRing->cf->nIntDiv;
     138  nacInvers      = nacRing->cf->nInvers;
    156139}
    157140
    … …  
    195178#define napMultCopy(p,q)  napMult(napCopy(p),napCopy(q))
    196179#define napIsConstant(p)  (napDeg(p)==0)
    197 #define napSetCoeff(p,n) {nacDelete(&((p)->ko),currRing);(p)->ko=n;}
    198 #else /* LONGALGNEW */
    199 #define napInit(i)       (napoly)p_ISet(i,currRing->algring)
    200 #define napSetCoeff(p,n) {nacDelete(&napGetCoeff(p),currRing);napGetCoeff(p)=n;}
    201 #define napDelete1(p)    p_LmDelete((poly *)p, currRing->algring)
    202 #define napCopy(p)       (napoly)p_Copy((poly)p,currRing->algring)
     180#define napSetCoeff(p,n) {nacDelete(&((p)->ko),nacRing);(p)->ko=n;}
     181#else /* LONGALGNEW */
     182#define napInit(i)       (napoly)p_ISet(i,nacRing)
     183#define napSetCoeff(p,n) {nacDelete(&napGetCoeff(p),nacRing);napGetCoeff(p)=n;}
     184#define napDelete1(p)    p_LmDelete((poly *)p, nacRing)
     185#define napCopy(p)       (napoly)p_Copy((poly)p,nacRing)
    203186#define nap_Copy(p,r)       (napoly)p_Copy((poly)p,r->algring)
    204 #define napComp(p,q)     p_LmCmp((poly)p,(poly)q, currRing->algring)
    205 #define napMultT(A,E)    A=(napoly)p_Mult_mm((poly)A,(poly)E,currRing->algring)
    206 #define napMult(A,B)     (napoly)p_Mult_q((poly)A,(poly)B,currRing->algring)
    207 #define napMultCopy(A,B)   (napoly)pp_Mult_qq((poly)A,(poly)B,currRing->algring)
    208 #define napIsConstant(p) p_LmIsConstant(p,currRing->algring)
    209 #define napDeg(p)        (int)p_ExpVectorQuerSum(p, currRing->algring)
     187#define napComp(p,q)     p_LmCmp((poly)p,(poly)q, nacRing)
     188#define napMultT(A,E)    A=(napoly)p_Mult_mm((poly)A,(poly)E,nacRing)
     189#define napMult(A,B)     (napoly)p_Mult_q((poly)A,(poly)B,nacRing)
     190#define napMultCopy(A,B)   (napoly)pp_Mult_qq((poly)A,(poly)B,nacRing)
     191#define napIsConstant(p) p_LmIsConstant(p,nacRing)
     192#define napDeg(p)        (int)p_ExpVectorQuerSum(p, nacRing)
    210193#endif /* LONGALGNEW */
    211194
    … …  
    218201  napoly a = (napoly)omAlloc0(napMonomSize);
    219202#else /* LONGALGNEW */
    220   napoly a = (napoly)p_Init(currRing->algring);
     203  napoly a = (napoly)p_Init(nacRing);
    221204#endif /* LONGALGNEW */
    222205  napGetCoeff(a) = z;
    … …  
    235218  {
    236219    *p = h->ne;
    237     nacDelete(&(h->ko),currRing);
     220    nacDelete(&(h->ko),nacRing);
    238221    omFreeSize((ADDRESS)h, napMonomSize);
    239222  }
    … …  
    251234    w = h;
    252235    h = h->ne;
    253     nacDelete(&(w->ko),currRing);
     236    nacDelete(&(w->ko),nacRing);
    254237    omFreeSize((ADDRESS)w, napMonomSize);
    255238  }
    … …  
    265248    w = h;
    266249    h = h->ne;
    267     n_Delete(&(w->ko),currRing->algring);
     250    n_Delete(&(w->ko),r->algring);
    268251    omFree((ADDRESS)w);
    269252  }
    … …  
    283266  omCheckAddrSize(p,napMonomSize);
    284267  a = w = (napoly)omAlloc(napMonomSize);
    285   memcpy(w->e, p->e, naNumbOfPar * SIZEOF_PARAMETER);
     268  memcpy4(w->e, p->e, naNumbOfPar * SIZEOF_PARAMETER);
    286269  w->ko = nacCopy(p->ko);
    287270  loop
    … …  
    292275    a->ne = (napoly)omAlloc(napMonomSize);
    293276    a = a->ne;
    294     memcpy(a->e, p->e, naNumbOfPar * SIZEOF_PARAMETER);
     277    memcpy4(a->e, p->e, naNumbOfPar * SIZEOF_PARAMETER);
    295278    a->ko = nacCopy(p->ko);
    296279  }
    … …  
    311294  omCheckAddrSize(p,napMonomSize);
    312295  a = w = (napoly)omAlloc(napMonomSize);
    313   memcpy(w->e, p->e, naNumbOfPar * SIZEOF_PARAMETER);
     296  memcpy4(w->e, p->e, naNumbOfPar * SIZEOF_PARAMETER);
    314297  w->ko = nacNeg(nacCopy(p->ko));
    315298  loop
    … …  
    320303    a->ne = (napoly)omAlloc(napMonomSize);
    321304    a = a->ne;
    322     memcpy(a->e, p->e, naNumbOfPar * SIZEOF_PARAMETER);
     305    memcpy4(a->e, p->e, naNumbOfPar * SIZEOF_PARAMETER);
    323306    a->ko = nacNeg(nacCopy(p->ko));
    324307  }
    … …  
    327310#else /* LONGALGNEW */
    328311  napoly r=napCopy(p);
    329   r=(napoly)p_Neg((poly)r, currRing->algring);
     312  r=(napoly)p_Neg((poly)r, nacRing);
    330313  return r;
    331314#endif /* LONGALGNEW */
    … …  
    400383      if (nacIsZero(t))
    401384      {
    402         nacDelete(&t,currRing);
     385        nacDelete(&t,nacRing);
    403386        napDelete1(&a1);
    404387      }
    405388      else
    406389      {
    407         nacDelete(&(a1->ko),currRing);
     390        nacDelete(&(a1->ko),nacRing);
    408391        a1->ko = t;
    409392        a = a->ne = a1;
    … …  
    458441    t = nacMult(napGetCoeff(p), z);
    459442    nacNormalize(t);
    460     nacDelete(&napGetCoeff(p),currRing);
     443    nacDelete(&napGetCoeff(p),nacRing);
    461444    napGetCoeff(p) = t;
    462445    napIter(p);
    … …  
    508491      {
    509492        t = nacMult(a->ko, h);
    510         nacDelete(&(a->ko),currRing);
     493        nacDelete(&(a->ko),nacRing);
    511494        a->ko = t;
    512495        for (i = naNumbOfPar - 1; i >= 0; i--)
    … …  
    602585  qq = (napoly)omAlloc(napMonomSize);
    603586#else /* LONGALGNEW */
    604   qq = (napoly)p_Init(currRing->algring);
     587  qq = (napoly)p_Init(nacRing);
    605588#endif /* LONGALGNEW */
    606589  napNext(qq) = NULL;
     590  napNormalize(g);
     591  napNormalize(f);
    607592  a = f;
    608593  do
    609594  {
    610595    napSetExp(qq,1, napGetExp(a,1) - napGetExp(g,1));
     596    p_Setm(qq,nacRing);
    611597    napGetCoeff(qq) = nacDiv(napGetCoeff(a), napGetCoeff(g));
    612598    napGetCoeff(qq) = nacNeg(napGetCoeff(qq));
     599    nacNormalize(napGetCoeff(qq));
    613600    h = napCopy(g);
    614601    napMultT(h, qq);
    615     nacDelete(&napGetCoeff(qq),currRing);
     602    napNormalize(h);
     603    nacDelete(&napGetCoeff(qq),nacRing);
    616604    a = napAdd(a, h);
    617605  }
    … …  
    635623  qq = (napoly)omAlloc(napMonomSize);
    636624#else /* LONGALGNEW */
    637   qq = (napoly)p_Init(currRing->algring);
     625  qq = (napoly)p_Init(nacRing);
    638626#endif /* LONGALGNEW */
    639627  napNext(qq) = b = NULL;
     628  napNormalize(g);
     629  napNormalize(f);
    640630  a = f;
    641631  do
    642632  {
    643633    napSetExp(qq,1, napGetExp(a,1) - napGetExp(g,1));
     634    p_Setm(qq,nacRing);
    644635    napGetCoeff(qq) = nacDiv(napGetCoeff(a), napGetCoeff(g));
     636    nacNormalize(napGetCoeff(qq));
    645637    b = napAdd(b, napCopy(qq));
    646638    napGetCoeff(qq) = nacNeg(napGetCoeff(qq));
    647639    h = napCopy(g);
    648640    napMultT(h, qq);
    649     nacDelete(&napGetCoeff(qq),currRing);
     641    napNormalize(h);
     642    nacDelete(&napGetCoeff(qq),nacRing);
    650643    a = napAdd(a, h);
    651644  }
    … …  
    678671    if (!nacIsOne(napGetCoeff(x)))
    679672    {
    680       h = nacInit(1);
    681       t = nacDiv(h, napGetCoeff(x));
    682       nacDelete(&napGetCoeff(x),currRing);
    683       nacDelete(&h,currRing);
     673      nacNormalize(napGetCoeff(x));
     674      t = nacInvers(napGetCoeff(x));
     675      nacNormalize(t);
     676      nacDelete(&napGetCoeff(x),nacRing);
    684677      napGetCoeff(x) = t;
    685678    }
    … …  
    694687  if (napGetExp(r,1)==0)
    695688  {
    696     h = nacInit(-1);
    697     t = nacDiv(h, napGetCoeff(r));
     689    nacNormalize(napGetCoeff(r));
     690    t = nacInvers(napGetCoeff(r));
    698691    nacNormalize(t);
     692    t = nacNeg(t);
    699693    napMultN(qa, t);
    700     nacDelete(&h,currRing);
    701     nacDelete(&t,currRing);
     694    nacDelete(&t,nacRing);
     695    napNormalize(qa);
    702696    napDelete(&x);
    703697    napDelete(&r);
    … …  
    715709    q = napMult(q, qa);
    716710    q = napAdd(q, napInit(1));
    717     h = nacInit(1);
    718     t = nacDiv(h, napGetCoeff(r));
     711    nacNormalize(napGetCoeff(r));
     712    t = nacInvers(napGetCoeff(r));
    719713    napMultN(q, t);
    720     nacDelete(&h,currRing);
    721     nacDelete(&t,currRing);
     714    napNormalize(q);
     715    nacDelete(&t,nacRing);
    722716    napDelete(&x);
    723717    napDelete(&r);
    … …  
    743737      q = napNeg(q);
    744738      q = napAdd(q, qa);
    745       h = nacInit(1);
    746       t = nacDiv(h, napGetCoeff(r));
     739      nacNormalize(napGetCoeff(r));
     740      t = nacInvers(napGetCoeff(r));
     741      //nacNormalize(t);
    747742      napMultN(q, t);
    748       nacDelete(&h,currRing);
    749       nacDelete(&t,currRing);
     743      napNormalize(q);
     744      nacDelete(&t,nacRing);
    750745      napDelete(&x);
    751746      napDelete(&r);
    … …  
    816811*writes a polynomial number
    817812*/
    818 void napWrite(napoly p)
     813void napWrite(napoly p,const BOOLEAN has_denom)
    819814{
    820815  if (p==NULL)
    … …  
    822817  else if (napIsConstant(p))
    823818  {
     819    BOOLEAN kl=FALSE;
     820    if (has_denom)
     821    {
     822      number den=nacRing->cf->n_GetDenom(napGetCoeff(p), nacRing);
     823      kl=!n_IsOne(den,nacRing);
     824      n_Delete(&den, nacRing);
     825    }
     826    if (kl) StringAppendS("(");
    824827    //StringAppendS("-1");
    825828    nacWrite(napGetCoeff(p));
     829    if (kl) StringAppendS(")");
    826830  }
    827831  else
    … …  
    859863          }
    860864        }
    861       }
     865      } /*for*/
    862866      napIter(p);
    863867      if (p==NULL)
    … …  
    908912  a = (napoly)omAlloc0(napMonomSize);
    909913#else /* LONGALGNEW */
    910   a = (napoly)p_Init(currRing->algring);
     914  a = (napoly)p_Init(nacRing);
    911915#endif /* LONGALGNEW */
    912916  if ((*s >= '0') && (*s <= '9'))
    … …  
    9971001  do
    9981002  {
    999     d=nacGcd(napGetCoeff(p), h, currRing);
     1003    d=nacGcd(napGetCoeff(p), h, nacRing);
    10001004    if(nacIsOne(d))
    10011005    {
    1002       nacDelete(&h,currRing);
    1003       nacDelete(&d,currRing);
     1006      nacDelete(&h,nacRing);
     1007      nacDelete(&d,nacRing);
    10041008      return;
    10051009    }
    1006     nacDelete(&h,currRing);
     1010    nacDelete(&h,nacRing);
    10071011    h = d;
    10081012    napIter(p);
    … …  
    10101014  while (p!=NULL);
    10111015  h = nacInvers(d);
    1012   nacDelete(&d,currRing);
     1016  nacDelete(&d,nacRing);
    10131017  p = ph;
    10141018  while (p!=NULL)
    10151019  {
    10161020    d = nacMult(napGetCoeff(p), h);
    1017     nacDelete(&napGetCoeff(p),currRing);
     1021    nacDelete(&napGetCoeff(p),nacRing);
    10181022    napGetCoeff(p) = d;
    10191023    napIter(p);
    10201024  }
    1021   nacDelete(&h,currRing);
     1025  nacDelete(&h,nacRing);
    10221026}
    10231027
    … …  
    10331037  while (p!=NULL)
    10341038  {
    1035     d = nacLcm(h, napGetCoeff(p), currRing);
    1036     nacDelete(&h,currRing);
     1039    d = nacLcm(h, napGetCoeff(p), nacRing);
     1040    nacDelete(&h,nacRing);
    10371041    h = d;
    10381042    napIter(p);
    … …  
    10441048    {
    10451049      d=nacMult(h, napGetCoeff(p));
    1046       nacDelete(&napGetCoeff(p),currRing);
     1050      nacDelete(&napGetCoeff(p),nacRing);
    10471051      nacNormalize(d);
    10481052      napGetCoeff(p) = d;
    10491053      napIter(p);
    10501054    }
    1051     nacDelete(&h,currRing);
     1055    nacDelete(&h,nacRing);
    10521056  }
    10531057  napContent(ph);
    … …  
    10651069  {
    10661070    napIter(a);
    1067     y = nacGcd(x, napGetCoeff(a), currRing);
    1068     nacDelete(&x,currRing);
     1071    y = nacGcd(x, napGetCoeff(a), nacRing);
     1072    nacDelete(&x,nacRing);
    10691073    x = y;
    10701074    if (nacIsOne(x))
    … …  
    10731077  do
    10741078  {
    1075     y = nacGcd(x, napGetCoeff(b), currRing);
    1076     nacDelete(&x,currRing);
     1079    y = nacGcd(x, napGetCoeff(b), nacRing);
     1080    nacDelete(&x,nacRing);
    10771081    x = y;
    10781082    if (nacIsOne(x))
    … …  
    11241128    {
    11251129      napSetExp(g,1, napExp(x, y));
     1130      p_Setm(g,nacRing);
    11261131      return g;
    11271132    }
    … …  
    11471152    napDelete1(&h);
    11481153    napSetExp(g,1, napExp(a, b));
     1154    p_Setm(g,nacRing);
    11491155    return g;
    11501156  }
    … …  
    11531159  // x = (napoly)omAlloc0(napMonomSize);
    11541160#else /* LONGALGNEW */
    1155   // x = (napoly)p_Init(currRing->algring);
     1161  // x = (napoly)p_Init(nacRing);
    11561162#endif /* LONGALGNEW */
    11571163  g=a;
    … …  
    11621168  {
    11631169    napSetExp(x,i+1, napExpi(i,a,b));
     1170    p_Setm(x,nacRing);
    11641171  }
    11651172  return x;
    … …  
    11781185    while (b!=NULL)
    11791186    {
    1180       d = nacLcm(h, napGetCoeff(b), currRing);
    1181       nacDelete(&h,currRing);
     1187      d = nacLcm(h, napGetCoeff(b), nacRing);
     1188      nacDelete(&h,nacRing);
    11821189      h = d;
    11831190      napIter(b);
    … …  
    12291236  napoly h = (napoly)omAlloc0(napMonomSize);
    12301237#else /* LONGALGNEW */
    1231   napoly h = (napoly)p_Init(currRing->algring);
     1238  napoly h = (napoly)p_Init(nacRing);
    12321239#endif /* LONGALGNEW */
    12331240  int i=0,j;
    … …  
    12411248      for (j=naNumbOfPar; j>0; j--)
    12421249        napSetExp(h,j, napGetExp(q,j) - napGetExp(naI->liste[i],j));
     1250      p_Setm(h,nacRing);
    12431251      h = napMult (h, napCopy(naI->liste[i]));
    12441252      h = napNeg (h);
    … …  
    13301338  l->z = napInit(1);
    13311339  napSetExp(l->z,i,1);
     1340  p_Setm(l->z,nacRing);
    13321341  l->n = NULL;
    13331342  return (number)l;
    … …  
    19651974    phn->s = 0;
    19661975    naNormalize(phn);
    1967     napWrite(ph->z);
    1968     if (ph->n!=NULL)
     1976    BOOLEAN has_denom=(ph->n!=NULL);
     1977    napWrite(ph->z,has_denom/*(ph->n!=NULL)*/);
     1978    if (has_denom/*(ph->n!=NULL)*/)
    19691979    {
    19701980      StringAppendS("/");
    1971       napWrite(ph->n);
     1981      napWrite(ph->n,TRUE);
    19721982    }
    19731983  }
    … …  
    20032013      if (!nacIsZero(t))
    20042014      {
    2005         nacDelete(&t,currRing);
     2015        nacDelete(&t,nacRing);
    20062016        return FALSE;
    20072017      }
    20082018      else
    2009         nacDelete(&t,currRing);
     2019        nacDelete(&t,nacRing);
    20102020    }
    20112021    napIter(x);
    … …  
    21582168    napMultN(x,n);
    21592169    napMultN(y,n);
    2160     nacDelete(&n,currRing);
     2170    nacDelete(&n,nacRing);
    21612171    while(x!=NULL)
    21622172    {
    … …  
    22072217    nacNormalize(h1);
    22082218    napMultN(x, h1);
    2209     nacDelete(&h1,currRing);
     2219    nacDelete(&h1,nacRing);
    22102220    napDelete1(&y);
    22112221    p->n = NULL;
    … …  
    22542264      napMultN(x,n);
    22552265      napMultN(y,n);
    2256       nacDelete(&n,currRing);
     2266      nacDelete(&n,nacRing);
    22572267      while(x!=NULL)
    22582268      {
    … …  
    23112321  while (x!=NULL)
    23122322  {
    2313     number d=nacGcd(g,napGetCoeff(x), currRing);
     2323    number d=nacGcd(g,napGetCoeff(x), nacRing);
    23142324    if(nacIsOne(d))
    23152325    {
    2316       nacDelete(&g,currRing);
    2317       nacDelete(&d,currRing);
     2326      nacDelete(&g,nacRing);
     2327      nacDelete(&d,nacRing);
    23182328      naTest(pp);
    23192329      return;
    23202330    }
    2321     nacDelete(&g,currRing);
     2331    nacDelete(&g,nacRing);
    23222332    g = d;
    23232333    napIter(x);
    … …  
    23252335  while (y!=NULL)
    23262336  {
    2327     number d=nacGcd(g,napGetCoeff(y), currRing);
     2337    number d=nacGcd(g,napGetCoeff(y), nacRing);
    23282338    if(nacIsOne(d))
    23292339    {
    2330       nacDelete(&g,currRing);
    2331       nacDelete(&d,currRing);
     2340      nacDelete(&g,nacRing);
     2341      nacDelete(&d,nacRing);
    23322342      naTest(pp);
    23332343      return;
    23342344    }
    2335     nacDelete(&g,currRing);
     2345    nacDelete(&g,nacRing);
    23362346    g = d;
    23372347    napIter(y);
    … …  
    23512361    napIter(y);
    23522362  }
    2353   nacDelete(&g,currRing);
     2363  nacDelete(&g,nacRing);
    23542364  naTest(pp);
    23552365}
    … …  
    23812391    while (xx!=NULL)
    23822392    {
    2383       bt = nacGcd(t, napGetCoeff(xx), currRing);
     2393      bt = nacGcd(t, napGetCoeff(xx), nacRing);
    23842394      r = nacMult(t, napGetCoeff(xx));
    2385       nacDelete(&napGetCoeff(xx),currRing);
     2395      nacDelete(&napGetCoeff(xx),nacRing);
    23862396      napGetCoeff(xx) = nacDiv(r, bt);
    23872397      nacNormalize(napGetCoeff(xx));
    2388       nacDelete(&bt,currRing);
    2389       nacDelete(&r,currRing);
     2398      nacDelete(&bt,nacRing);
     2399      nacDelete(&r,nacRing);
    23902400      napIter(xx);
    23912401    }
    23922402  }
    2393   nacDelete(&t,currRing);
     2403  nacDelete(&t,nacRing);
    23942404  result->z = x;
    23952405#ifdef HAVE_FACTORY
    … …  
    24392449      {
    24402450        x=naI->liste[i];
     2451        nacNormalize(napGetCoeff(x));
    24412452        a=nacCopy(napGetCoeff(x));
    2442         a=nacDiv(nacInit(1),a);
    2443         napMultN(x,a);
    2444         nacDelete(&a,currRing);
     2453        number aa=nacInvers(a);
     2454        nacDelete(&a,nacRing);
     2455        napMultN(x,aa);
     2456        nacDelete(&aa,nacRing);
    24452457      }
    24462458    }
    … …  
    24592471  l->z=(napoly)omAlloc0(napMonomSize);
    24602472#else /* LONGALGNEW */
    2461   l->z=(napoly)p_Init(currRing->algring);
     2473  l->z=(napoly)p_Init(nacRing);
    24622474#endif /* LONGALGNEW */
    24632475  int i=(int)c;
    … …  
    24792491  l->z=(napoly)omAlloc0(napMonomSize);
    24802492#else /* LONGALGNEW */
    2481   l->z=(napoly)p_Init(currRing->algring);
     2493  l->z=(napoly)p_Init(nacRing);
    24822494#endif /* LONGALGNEW */
    24832495  napGetCoeff(l->z)=nlCopy(c);
    … …  
    24972509  l->z=(napoly)omAlloc0(napMonomSize);
    24982510#else /* LONGALGNEW */
    2499   l->z=(napoly)p_Init(currRing->algring);
     2511  l->z=(napoly)p_Init(nacRing);
    25002512#endif /* LONGALGNEW */
    25012513  napGetCoeff(l->z)=c; /* omit npCopy, because npCopy is a no-op */
    … …  
    25192531  l->z=(napoly)omAlloc0(napMonomSize);
    25202532#else /* LONGALGNEW */
    2521   l->z=(napoly)p_Init(currRing->algring);
     2533  l->z=(napoly)p_Init(nacRing);
    25222534#endif /* LONGALGNEW */
    25232535  napGetCoeff(l->z)=n;
    … …  
    25392551  l->z=(napoly)omAlloc0(napMonomSize);
    25402552#else /* LONGALGNEW */
    2541   l->z=(napoly)p_Init(currRing->algring);
     2553  l->z=(napoly)p_Init(nacRing);
    25422554#endif /* LONGALGNEW */
    25432555  napGetCoeff(l->z)=n;
    … …  
    25582570#ifndef LONGALGNEW
    25592571  a = w = (napoly)omAlloc0(napMonomSize);
    2560   memcpy(a->e, p->e, naParsToCopy * SIZEOF_PARAMETER);
     2572  memcpy4(a->e, p->e, naParsToCopy * SIZEOF_PARAMETER);
    25612573  w->ko = nacMap(p->ko);
    25622574#else /* LONGALGNEW */
    2563   a = w = (napoly)p_Init(currRing->algring);
     2575  a = w = (napoly)p_Init(nacRing);
    25642576  int i;
    25652577  for(i=1;i<=naParsToCopy;i++)
    25662578    napSetExp(a,i,napGetExpFrom(p,i,napMapRing));
     2579  p_Setm(a,nacRing);
    25672580  napGetCoeff(w) = nacMap(napGetCoeff(p));
    25682581#endif /* LONGALGNEW */
    … …  
    25742587    a->ne = (napoly)omAlloc0(napMonomSize);
    25752588    a = a->ne;
    2576     memcpy(a->e, p->e, naParsToCopy * SIZEOF_PARAMETER);
    2577 #else /* LONGALGNEW */
    2578     napNext(a) = (napoly)p_Init(currRing->algring);
     2589    memcpy4(a->e, p->e, naParsToCopy * SIZEOF_PARAMETER);
     2590#else /* LONGALGNEW */
     2591    napNext(a) = (napoly)p_Init(nacRing);
    25792592    napIter(a);
    25802593    for(i=1;i<=naParsToCopy;i++)
    25812594      napSetExp(a,i,napGetExpFrom(p,i,napMapRing));
     2595    p_Setm(a,nacRing);
    25822596#endif /* LONGALGNEW */
    25832597    napGetCoeff(a) = nacMap(napGetCoeff(p));
    … …  
    27162730  nMapFunc nMap=NULL;
    27172731  if (currRing->parameter!=NULL)
    2718     nMap=currRing->algring->cf->cfSetMap(r->algring, currRing->algring);
     2732    nMap=currRing->algring->cf->cfSetMap(r->algring, nacRing);
    27192733  else
    27202734    nMap=currRing->cf->cfSetMap(r->algring, currRing);
    … …  
    27492763        {
    27502764          if ((rPar(currRing)>=i) && (pa!=NULL))
     2765          {
    27512766            napSetExp(pa,i+1,napGetExpFrom(za,i+1,r));
     2767            p_Setm(pa,nacRing);
     2768          }
    27522769          else
    27532770          {
    … …  
    27592776          pSetExp(p,par_perm[i],napGetExpFrom(za,i+1,r));
    27602777        else if((par_perm[i]<0)&&(pa!=NULL))
     2778        {
    27612779          napSetExp(pa,-par_perm[i], napGetExpFrom(za,i+1,r));
     2780          p_Setm(pa,nacRing);
     2781        }
    27622782        else
    27632783        {
Note: See TracChangeset for help on using the changeset viewer.