Changeset 3d1222a in git


Ignore:
Timestamp:
Sep 8, 2017, 2:27:07 PM (6 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'spielwiese', '60097d763e0b541617a3b864b5310c523edaf81d')
Children:
810c580a69838f4221fec238512e8d28b5fe23fe
Parents:
8890e6d10190a2c7861853d061d8b82a40dc70d6
Message:
(p)p_Mult_nn: test args for 0,1, __(p)p_Mult_nn: no tests
Files:
14 edited

Legend:

Unmodified
Added
Removed
  • Singular/dyn_modules/gfanlib/ppinitialReduction.cc

    r8890e6 r3d1222a  
    221221  // now a*leadcoef(g)+b*p = gcd with gcd being a unit
    222222  // so a*g+b*(p-t)*leadmonom(g) should have a unit as leading coefficient
    223   // but first check whether b is 0,
    224   // since p_Mult_nn doesn't allow 0 as number input
    225   if (n_IsZero(b,r->cf))
    226   {
    227     n_Delete(&a,r->cf);
    228     n_Delete(&b,r->cf);
    229     n_Delete(&gcd,r->cf);
    230     p_Delete(&pt,r);
    231     return;
    232   }
    233223  poly m = p_Head(g,r);
    234224  p_SetCoeff(m,n_Init(1,r->cf),r);
  • kernel/GBEngine/kInline.h

    r8890e6 r3d1222a  
    310310{
    311311  if (t_p != NULL)
    312   {    t_p = p_Mult_nn(t_p, n, tailRing);
     312  {
     313    t_p = p_Mult_nn(t_p, n, tailRing);
    313314    if (p != NULL) pSetCoeff0(p, pGetCoeff(t_p));
    314315  }
     
    564565    poly _p = (t_p != NULL ? t_p : p);
    565566    assume(_p != NULL);
    566     pNext(_p) = p_Mult_nn(pNext(_p), n, tailRing);
     567    pNext(_p) = __p_Mult_nn(pNext(_p), n, tailRing);
    567568  }
    568569}
  • kernel/GBEngine/kutil.cc

    r8890e6 r3d1222a  
    46694669    }
    46704670    p_Test(p,strat->tailRing);
    4671     p = pp_Mult_nn(p, gcd, strat->tailRing);
     4671    p = __pp_Mult_nn(p, gcd, strat->tailRing);
    46724672    nDelete(&gcd);
    46734673
     
    47524752    }
    47534753    p_Test(p,strat->tailRing);
    4754     p = pp_Mult_nn(p, gcd, strat->tailRing);
     4754    p = __pp_Mult_nn(p, gcd, strat->tailRing);
    47554755
    47564756    if (p != NULL)
     
    47864786      //printf("\nOld\n");pWrite(h);pWrite(hSig);
    47874787      #if EXT_POLY_NEW
    4788       Lp.sig = pp_Mult_nn(hSig, gcd, currRing);
     4788      Lp.sig = __pp_Mult_nn(hSig, gcd, currRing);
    47894789      if(Lp.sig == NULL || nIsZero(pGetCoeff(Lp.sig)))
    47904790      {
  • kernel/GBEngine/ringgb.cc

    r8890e6 r3d1222a  
    192192    number tmp=n_Ann(gcd,currRing->cf);
    193193    p = p_Copy(h->next, currRing);
    194     p = p_Mult_nn(p, tmp, currRing);
     194    p = __p_Mult_nn(p, tmp, currRing);
    195195    n_Delete(&tmp,currRing->cf);
    196196  }
  • kernel/GBEngine/tgb.cc

    r8890e6 r3d1222a  
    25262526        }
    25272527        else
    2528           t = pp_Mult_nn (red.p, red.coef, currRing);
     2528          t = __pp_Mult_nn (red.p, red.coef, currRing);
    25292529      }
    25302530      else
     
    25332533          t = red.p;
    25342534        else
    2535           t = p_Mult_nn (red.p, red.coef, currRing);
     2535          t = __p_Mult_nn (red.p, red.coef, currRing);
    25362536      }
    25372537      kBucket_Add_q (bucket, t, &red.len);
  • kernel/maps/fast_maps.cc

    r8890e6 r3d1222a  
    444444  {
    445445    done++;
    446     poly t=pp_Mult_nn(p,c->n,dest_r);
     446    poly t=__pp_Mult_nn(p,c->n,dest_r);
    447447    #ifdef HAVE_RINGS
    448448    if (zero_div) len=pLength(t);
  • libpolys/polys/clapsing.cc

    r8890e6 r3d1222a  
    347347        while(eg>0)
    348348        {
    349           res=p_Mult_nn(res,n,r);
     349          res=__p_Mult_nn(res,n,r);
    350350          eg--;
    351351        }
     
    358358        while(ef>0)
    359359        {
    360           res=p_Mult_nn(res,n,r);
     360          res=__p_Mult_nn(res,n,r);
    361361          ef--;
    362362        }
     
    11311131    if (N!=NULL)
    11321132    {
    1133       p_Mult_nn(res->m[0],N,r);
     1133      __p_Mult_nn(res->m[0],N,r);
    11341134      n_Delete(&N,r->cf);
    11351135      N=NULL;
     
    14281428    if (N!=NULL)
    14291429    {
    1430       p_Mult_nn(res->m[0],N,r);
     1430      __p_Mult_nn(res->m[0],N,r);
    14311431      n_Delete(&N,r->cf);
    14321432      N=NULL;
  • libpolys/polys/ext_fields/algext.cc

    r8890e6 r3d1222a  
    12481248
    12491249  // over alg. ext. of Q // takes over the input number
    1250   c = (number) p_Mult_nn( (poly)c, cc, R);
     1250  c = (number) __p_Mult_nn( (poly)c, cc, R);
    12511251//      p_Mult_q(p_NSet(cc, R), , R);
    12521252
  • libpolys/polys/ext_fields/transext.cc

    r8890e6 r3d1222a  
    430430    if (!n_IsOne(lcmOfDenominators, ntCoeffs))
    431431    { /* multiply NUM(f) and DEN(f) with lcmOfDenominators */
    432       NUM(f) = p_Mult_nn(NUM(f), lcmOfDenominators, ntRing);
     432      NUM(f) = __p_Mult_nn(NUM(f), lcmOfDenominators, ntRing);
    433433      p_Normalize(NUM(f), ntRing);
    434       DEN(f) = p_Mult_nn(DEN(f), lcmOfDenominators, ntRing);
     434      DEN(f) = __p_Mult_nn(DEN(f), lcmOfDenominators, ntRing);
    435435      p_Normalize(DEN(f), ntRing);
    436436    }
     
    462462        number inverseOfGcdOfCoefficients = n_Invers(gcdOfCoefficients,
    463463                                                     ntCoeffs);
    464         NUM(f) = p_Mult_nn(NUM(f), inverseOfGcdOfCoefficients, ntRing);
     464        NUM(f) = __p_Mult_nn(NUM(f), inverseOfGcdOfCoefficients, ntRing);
    465465        p_Normalize(NUM(f), ntRing);
    466         DEN(f) = p_Mult_nn(DEN(f), inverseOfGcdOfCoefficients, ntRing);
     466        DEN(f) = __p_Mult_nn(DEN(f), inverseOfGcdOfCoefficients, ntRing);
    467467        p_Normalize(DEN(f), ntRing);
    468468        n_Delete(&inverseOfGcdOfCoefficients, ntCoeffs);
     
    11011101    {
    11021102      number inv=n_Invers(pGetCoeff(n),R->cf);
    1103       DEN(result)=p_Mult_nn(n,inv,R);
    1104       NUM(result)=p_Mult_nn(NUM(result),inv,R);
     1103      DEN(result)=__p_Mult_nn(n,inv,R);
     1104      NUM(result)=__p_Mult_nn(NUM(result),inv,R);
    11051105      n_Delete(&inv,R->cf);
    11061106      if (p_IsOne(DEN(result), R))
     
    13271327        {
    13281328          number inv=n_Invers(pGetCoeff(DEN(f)),ntCoeffs);
    1329           DEN(f)=p_Mult_nn(DEN(f),inv,ntRing);
    1330           NUM(f)=p_Mult_nn(NUM(f),inv,ntRing);
     1329          DEN(f)=__p_Mult_nn(DEN(f),inv,ntRing);
     1330          NUM(f)=__p_Mult_nn(NUM(f),inv,ntRing);
    13311331        }
    13321332        if(p_LmIsConstant(DEN(f),ntRing))
     
    16811681      /* singclap_gcd destroys its arguments; we hence need copies: */
    16821682      pGcd = singclap_gcd(p_Copy(NUM(fa),ntRing), p_Copy(DEN(fb),ntRing), ntRing);
    1683       pGcd= p_Mult_nn (pGcd, contentpa, ntRing);
     1683      pGcd= __p_Mult_nn (pGcd, contentpa, ntRing);
    16841684      n_Delete(&contentpa, ntCoeffs);
    16851685    }
     
    17701770      /* singclap_gcd destroys its arguments; we hence need copies: */
    17711771      pGcd = singclap_gcd(p_Copy(NUM(fa),ntRing), p_Copy(NUM(fb),ntRing), ntRing);
    1772       pGcd= p_Mult_nn (pGcd, contentpa, ntRing);
     1772      pGcd= __p_Mult_nn (pGcd, contentpa, ntRing);
    17731773      n_Delete(&contentpa, ntCoeffs);
    17741774    }
     
    23582358      {
    23592359        number LcGcd= n_SubringGcd (p_GetCoeff (cand, R), p_GetCoeff(den, R), Q);
    2360         gcd = p_Mult_nn(gcd, LcGcd, R);
     2360        gcd = __p_Mult_nn(gcd, LcGcd, R);
    23612361        n_Delete(&LcGcd,Q);
    23622362      }
     
    24252425
    24262426      if( den == NULL ) // ?? / 1 ?
    2427         NUM(f) = p_Mult_nn(NUM(f), d, R);
     2427        NUM(f) = __p_Mult_nn(NUM(f), d, R);
    24282428      else
    24292429      {
     
    24322432
    24332433        number ddd = n_Div(d, pGetCoeff(den), Q); // but be an integer now!!!
    2434         NUM(f) = p_Mult_nn(NUM(f), ddd, R);
     2434        NUM(f) = __p_Mult_nn(NUM(f), ddd, R);
    24352435        n_Delete(&ddd, Q);
    24362436
     
    24422442    }
    24432443
    2444     NUM((fraction)c) = p_Mult_nn(NUM((fraction)c), d, R);
     2444    NUM((fraction)c) = __p_Mult_nn(NUM((fraction)c), d, R);
    24452445    n_Delete(&d, Q);
    24462446  }
  • libpolys/polys/kbuckets.cc

    r8890e6 r3d1222a  
    594594#ifdef USE_COEF_BUCKETS
    595595      if (i<coef_start)
    596         bucket->buckets[i] = p_Mult_nn(bucket->buckets[i], n, r);
     596        bucket->buckets[i] = __p_Mult_nn(bucket->buckets[i], n, r);
    597597        /* Frank Seelisch on March 11, 2010:
    598598           This looks a bit strange: The following "if" is indented
     
    610610      if (bucket->coef[i]!=NULL)
    611611      {
    612         bucket->coef[i] = p_Mult_nn(bucket->coef[i],n,r);
     612        bucket->coef[i] = __p_Mult_nn(bucket->coef[i],n,r);
    613613      }
    614614      else
     
    617617      }
    618618#else
    619       bucket->buckets[i] = p_Mult_nn(bucket->buckets[i], n, r);
     619      bucket->buckets[i] = __p_Mult_nn(bucket->buckets[i], n, r);
    620620      if (rField_is_Ring(r) && !(rField_is_Domain(r)))
    621621      {
     
    628628  kbTest(bucket);
    629629#else
    630   bucket->p = p_Mult_nn(bucket->p, n, bucket->bucket_ring);
     630  bucket->p = __p_Mult_nn(bucket->p, n, bucket->bucket_ring);
    631631#endif
    632632}
     
    858858
    859859      p_SetCoeff0(m,add_coef,r);
    860       bucket->buckets[i]=p_Mult_nn(bucket->buckets[i],orig_coef,r);
     860      bucket->buckets[i]=__p_Mult_nn(bucket->buckets[i],orig_coef,r);
    861861
    862862      n_Delete(&orig_coef,r);
     
    928928      }
    929929      //assume(n_IsOne(n,r));
    930       bucket->buckets[i]=p_Mult_nn(bucket->buckets[i],orig_coef,r);
    931       p1=p_Mult_nn(p1,add_coef,r);
     930      bucket->buckets[i]=__p_Mult_nn(bucket->buckets[i],orig_coef,r);
     931      p1=__p_Mult_nn(p1,add_coef,r);
    932932
    933933      p1 = p_Add_q(p1, bucket->buckets[i],r);
     
    947947      if(!(n_IsOne(n,r)))
    948948      {
    949         p1=p_Mult_nn(p1, n, r);
     949        p1=__p_Mult_nn(p1, n, r);
    950950        n_Delete(&n,r);
    951951        n=n_Init(1,r);
     
    11061106      /* correct factor for cancelation by changing sign if an=-1 */
    11071107      if (rField_is_Ring(r))
    1108         lm = p_Mult_nn(lm, an, r);
     1108        lm = __p_Mult_nn(lm, an, r);
    11091109      else
    11101110        kBucket_Mult_n(bucket, an);
     
    12811281      number c=p_GetCoeff(bucket->coef[i],r);
    12821282      pNext(p)=NULL;
    1283       p=p_Mult_nn(p,c,r);
     1283      p=__p_Mult_nn(p,c,r);
    12841284      assume(p!=NULL);
    12851285      return p;
  • libpolys/polys/monomials/p_polys.cc

    r8890e6 r3d1222a  
    15721572  {
    15731573    inv = n_Invers(inv,r->cf);
    1574     p_Mult_nn(result,inv,r);
     1574    __p_Mult_nn(result,inv,r);
    15751575  }
    15761576  else
     
    24322432          { // each monom: coeff in Q_a (Z_a)
    24332433            fraction f=(fraction)pGetCoeff(p);
    2434             NUM(f)=p_Mult_nn(NUM(f),h,r->cf->extRing);
     2434            NUM(f)=__p_Mult_nn(NUM(f),h,r->cf->extRing);
    24352435            p_Normalize(NUM(f),r->cf->extRing);
    24362436            pIter(p);
     
    31323132        nMap= n_SetMap (C->extRing->cf, C);
    31333133        number ninv= nMap (n,C->extRing->cf, C);
    3134         p=p_Mult_nn (p, ninv, r);
     3134        p=__p_Mult_nn (p, ninv, r);
    31353135        n_Delete (&ninv, C);
    31363136        n_Delete (&n, C->extRing->cf);
     
    43134313    return v;
    43144314  short *ww=iv2array(w,R);
    4315   poly u1=p_JetW(p_Sub(p_One(R),p_Mult_nn(u,u0,R),R),n,ww,R);
     4315  poly u1=p_JetW(p_Sub(p_One(R),__p_Mult_nn(u,u0,R),R),n,ww,R);
    43164316  if(u1==NULL)
    43174317  {
     
    43194319    return v;
    43204320  }
    4321   poly v1=p_Mult_nn(p_Copy(u1,R),u0,R);
     4321  poly v1=__p_Mult_nn(p_Copy(u1,R),u0,R);
    43224322  v=p_Add_q(v,p_Copy(v1,R),R);
    43234323  for(int i=n/p_MinDeg(u1,w,R);i>1;i--)
  • libpolys/polys/monomials/p_polys.h

    r8890e6 r3d1222a  
    905905    return r->p_Procs->p_Mult_nn(p, n, r);
    906906}
     907#define __p_Mult_nn(p,n,r) r->p_Procs->p_Mult_nn(p, n, r)
    907908
    908909static inline poly p_Mult_nn(poly p, number n, const ring lmRing,
     
    925926  if (n_IsOne(n, r->cf))
    926927    return p_Copy(p, r);
     928  else if (n_IsZero(n, r->cf))
     929    return NULL;
    927930  else
    928931    return r->p_Procs->pp_Mult_nn(p, n, r);
    929932}
     933#define __pp_Mult_nn(p,n,r) r->p_Procs->pp_Mult_nn(p, n, r)
    930934
    931935// test if the monomial is a constant as a vector component
     
    959963{
    960964  if (p_LmIsConstant(m, r))
    961     return pp_Mult_nn(p, pGetCoeff(m), r);
     965    return __pp_Mult_nn(p, pGetCoeff(m), r);
    962966  else
    963   {
    964967    return r->p_Procs->pp_Mult_mm(p, m, r);
    965   }
    966968}
    967969
     
    970972{
    971973  if (p_LmIsConstant(m, r))
    972     return p_Mult_nn(p, pGetCoeff(m), r);
     974    return __p_Mult_nn(p, pGetCoeff(m), r);
    973975  else
    974976    return r->p_Procs->p_Mult_mm(p, m, r);
  • libpolys/polys/nc/ncSAMult.cc

    r8890e6 r3d1222a  
    6767
    6868  if (p_IsConstant(m, r))
    69     pResult = pp_Mult_nn(p, p_GetCoeff(m,r),r);
     69    pResult = __pp_Mult_nn(p, p_GetCoeff(m,r),r);
    7070  else
    7171  {
     
    7777    p_Delete(&pMonom, r);
    7878    p_Test(pResult, r);
    79     pResult = p_Mult_nn(pResult, p_GetCoeff(m, r), r);
     79    pResult = __p_Mult_nn(pResult, p_GetCoeff(m, r), r);
    8080  }
    8181
     
    116116
    117117  if (p_IsConstant(m, r))
    118     pResult = p_Mult_nn(p, p_GetCoeff(m,r),r);
     118    pResult = __p_Mult_nn(p, p_GetCoeff(m,r),r);
    119119  else
    120120  {
     
    126126    p_Delete(&pMonom, r);
    127127    p_Test(pResult, r);
    128     pResult = p_Mult_nn(pResult, p_GetCoeff(m, r), r);
     128    pResult = __p_Mult_nn(pResult, p_GetCoeff(m, r), r);
    129129  }
    130130
     
    166166
    167167  if (p_IsConstant(m, r))
    168     pResult = p_Mult_nn(p, p_GetCoeff(m,r),r);
     168    pResult = __p_Mult_nn(p, p_GetCoeff(m,r),r);
    169169  else
    170170  {
     
    176176    p_Delete(&pMonom, r);
    177177    p_Test(pResult, r);
    178     pResult = p_Mult_nn(pResult, p_GetCoeff(m, r), r);
     178    pResult = __p_Mult_nn(pResult, p_GetCoeff(m, r), r);
    179179  }
    180180
     
    214214
    215215  if (p_IsConstant(m, r))
    216     pResult = pp_Mult_nn(p, p_GetCoeff(m,r),r);
     216    pResult = __pp_Mult_nn(p, p_GetCoeff(m,r),r);
    217217  else
    218218  {
     
    224224    p_Delete(&pMonom, r);
    225225    p_Test(pResult, r);
    226     pResult = p_Mult_nn(pResult, p_GetCoeff(m, r), r);
     226    pResult = __p_Mult_nn(pResult, p_GetCoeff(m, r), r);
    227227  }
    228228
  • libpolys/polys/nc/old.gring.cc

    r8890e6 r3d1222a  
    306306  /*  if (pNext(p)==NULL) return(nc_mm_Mult_nn(p,pCopy(m),r)); */
    307307  /* excluded  - the cycle will do it anyway - OK. */
    308   if (p_IsConstant(m,r)) return(p_Mult_nn(p,p_GetCoeff(m,r),r));
     308  if (p_IsConstant(m,r)) return(__p_Mult_nn(p,p_GetCoeff(m,r),r));
    309309
    310310#ifdef PDEBUG
     
    375375      v = gnc_mm_Mult_nn(M, P, r);
    376376    }
    377     v = p_Mult_nn(v,cOut,r);
     377    v = __p_Mult_nn(v,cOut,r);
    378378    n_Delete(&cOut,r->cf);
    379379    p_SetCompP(v,expOut,r);
     
    629629     if (Rout!=NULL)
    630630     {
    631        Rout=p_Mult_nn(Rout,c[cnt-1],r); /* Rest is ready */
     631       Rout=__p_Mult_nn(Rout,c[cnt-1],r); /* Rest is ready */
    632632       out=p_Add_q(out,Rout,r);
    633633       Rout=NULL;
     
    887887     n_Delete(&c[cnt],r->cf);
    888888     c[cnt]=num;
    889      Rout=p_Mult_nn(Rout,c[cnt+1],r); /* Rest is ready */
     889     Rout=__p_Mult_nn(Rout,c[cnt+1],r); /* Rest is ready */
    890890     out=p_Add_q(out,Rout,r);
    891891     Pp=NULL;
     
    13761376  }
    13771377  n_Delete(&cG,r->cf);
    1378   p2 = p_Mult_nn(p2, C, r);
     1378  p2 = __p_Mult_nn(p2, C, r);
    13791379  poly out = nc_mm_Mult_pp(m, pNext(p1), r);
    13801380  N = p_Add_q(N, out, r);
     
    13841384  {
    13851385    cF = n_InpNeg(cF,r->cf);
    1386     N  = p_Mult_nn(N, cF, r);
     1386    N  = __p_Mult_nn(N, cF, r);
    13871387    p_Test(N,r);
    13881388  }
     
    14391439  n_Delete(&cG,r->cf);
    14401440
    1441   p2 = p_Mult_nn(p2, C, r); // p2 !!!
     1441  p2 = __p_Mult_nn(p2, C, r); // p2 !!!
    14421442  p_Test(p2,r);
    14431443  n_Delete(&C,r->cf);
     
    14531453  {
    14541454    cF = n_InpNeg(cF,r->cf);
    1455     N  = p_Mult_nn(N, cF, r);
     1455    N  = __p_Mult_nn(N, cF, r);
    14561456    p_Test(N,r);
    14571457  }
     
    15231523  }
    15241524  n_Delete(&C,r->cf);
    1525   M1=p_Mult_nn(M1,C2,r);
     1525  M1=__p_Mult_nn(M1,C2,r);
    15261526  p_SetCoeff(m1,C2,r);
    15271527  if (n_IsMOne(C1,r->cf))
     
    15321532  {
    15331533    C1=n_InpNeg(C1,r->cf);
    1534     M2=p_Mult_nn(M2,C1,r);
     1534    M2=__p_Mult_nn(M2,C1,r);
    15351535    M2=p_Add_q(M1,M2,r);
    15361536    p_SetCoeff(m2,C1,r);
     
    17171717//   else
    17181718//   {
    1719   M1=p_Mult_nn(M1,C2,r);                           // M1 = (C2*lc(p1)) * (lcm(lm(p1),lm(p2)) / lm(p1)) * lm(p1)
     1719  M1=__p_Mult_nn(M1,C2,r);                           // M1 = (C2*lc(p1)) * (lcm(lm(p1),lm(p2)) / lm(p1)) * lm(p1)
    17201720
    17211721#ifdef PDEBUG
     
    17231723#endif
    17241724
    1725   M2=p_Mult_nn(M2,C1,r);                           // M2 =(-C1*lc(p2)) * (lcm(lm(p1),lm(p2)) / lm(p2)) * lm(p2)
     1725  M2=__p_Mult_nn(M2,C1,r);                           // M2 =(-C1*lc(p2)) * (lcm(lm(p1),lm(p2)) / lm(p2)) * lm(p2)
    17261726
    17271727
     
    18551855  number C=p_GetCoeff(M,r);
    18561856  M=p_Add_q(M,nc_mm_Mult_p(m,p_LmDeleteAndNext(p_Copy(p1,r),r),r),r); // _pp?
    1857   q=p_Mult_nn(q,C,r);
     1857  q=__p_Mult_nn(q,C,r);
    18581858  number MinusOne=n_Init(-1,r->cf);
    18591859  if (!n_Equal(cQ,MinusOne,r->cf))
    18601860  {
    18611861    cQ=nInpNeg(cQ);
    1862     M=p_Mult_nn(M,cQ,r);
     1862    M=__p_Mult_nn(M,cQ,r);
    18631863  }
    18641864  Q=p_Add_q(Q,M,r);
     
    19411941    n= n_Mult(nn,pGetCoeff(kBucketGetLm(b)), r->cf);
    19421942    n_Delete(&nn, r->cf);
    1943     pp=p_Mult_nn(pp,n,r);
     1943    pp=__p_Mult_nn(pp,n,r);
    19441944    n_Delete(&n, r->cf);
    19451945  }
    19461946  else
    19471947  {
    1948     pp=p_Mult_nn(pp,p_GetCoeff(kBucketGetLm(b), r),r);
     1948    pp=__p_Mult_nn(pp,p_GetCoeff(kBucketGetLm(b), r),r);
    19491949  }
    19501950  int l=pLength(pp);
     
    20082008    number t = n_Mult(nn,pGetCoeff(pLmB), r->cf);
    20092009    n_Delete(&nn, r->cf);
    2010     pp = p_Mult_nn(pp,t,r);
     2010    pp = __p_Mult_nn(pp,t,r);
    20112011    n_Delete(&t, r->cf);
    20122012  }
    20132013  else
    20142014  {
    2015     pp = p_Mult_nn(pp,p_GetCoeff(pLmB, r), r);
     2015    pp = __p_Mult_nn(pp,p_GetCoeff(pLmB, r), r);
    20162016  }
    20172017
     
    21232123    n =n_Mult(nn,pGetCoeff(b), r->cf);
    21242124    n_Delete(&nn, r->cf);
    2125     pp=p_Mult_nn(pp,n,r);
     2125    pp=__p_Mult_nn(pp,n,r);
    21262126    n_Delete(&n, r->cf);
    21272127  }
    21282128  else
    21292129  {
    2130     pp=p_Mult_nn(pp,p_GetCoeff(b, r),r);
     2130    pp=__p_Mult_nn(pp,p_GetCoeff(b, r),r);
    21312131  }
    21322132  b=p_Add_q(b,pp,r);
     
    22212221    number t = n_Mult(nn, pGetCoeff(b), r->cf);
    22222222    n_Delete(&nn, r->cf);
    2223     pp=p_Mult_nn(pp, t, r);
     2223    pp=__p_Mult_nn(pp, t, r);
    22242224    n_Delete(&t, r->cf);
    22252225  }
    22262226  else
    22272227  {
    2228     pp=p_Mult_nn(pp, pGetCoeff(b), r);
     2228    pp=__p_Mult_nn(pp, pGetCoeff(b), r);
    22292229  }
    22302230
     
    22742274      {
    22752275        coef = n_Mult(pGetCoeff(p),pGetCoeff(Q), r->cf);
    2276         pres = p_Mult_nn(pres,coef,r);
     2276        pres = __p_Mult_nn(pres,coef,r);
    22772277
    22782278        sum += pres;
     
    32613261      p_Setm(suf, r);
    32623262      res = p_Mult_mm(res,suf, r);
    3263       res = p_Mult_nn(res,C, r);
     3263      res = __p_Mult_nn(res,C, r);
    32643264      p_SetComp(res,PRE[0], r);
    32653265    }
Note: See TracChangeset for help on using the changeset viewer.