Changeset c85b30 in git for libpolys


Ignore:
Timestamp:
May 18, 2015, 4:07:27 PM (9 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'spielwiese', '6e5adcba05493683b94648c659a729c189812c77')
Children:
888b7927c89b5d09691595ac2815d18b05ae93cd
Parents:
2329e7bd2c4ad25ed85b80547b94644b22ef85d5
Message:
use coeffs instead of ring for number-operations
Location:
libpolys/polys/templates
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • libpolys/polys/templates/p_Add_q__T.cc

    r2329e7 rc85b30  
    4343  n2 = pGetCoeff(q);
    4444  #if 0
    45   t = n_Add__T(n1,n2, r);
    46   n_Delete__T(&n1, r);
     45  t = n_Add__T(n1,n2, r->cf);
     46  n_Delete__T(&n1, r->cf);
    4747  #else
    48   n_InpAdd__T(n1,n2,r);
     48  n_InpAdd__T(n1,n2,r->cf);
    4949  t = n1;
    5050  #endif
    51   n_Delete__T(&n2, r);
     51  n_Delete__T(&n2, r->cf);
    5252  q = p_LmFreeAndNext(q, r);
    5353
    54   if (n_IsZero__T(t, r))
     54  if (n_IsZero__T(t, r->cf))
    5555  {
    5656    shorter += 2;
    57     n_Delete__T(&t, r);
     57    n_Delete__T(&t, r->cf);
    5858    p = p_LmFreeAndNext(p, r);
    5959  }

  • libpolys/polys/templates/p_Copy__T.cc

    r2329e7 rc85b30  
    2424    p_AllocBin(pNext(d_p), bin, r);
    2525    pIter(d_p);
    26     pSetCoeff0(d_p, n_Copy__T(pGetCoeff(s_p), r));
     26    pSetCoeff0(d_p, n_Copy__T(pGetCoeff(s_p), r->cf));
    2727    // it is better to iter here,
    2828    // for MemCopy advances goes from low to high addresses

  • libpolys/polys/templates/p_Delete__T.cc

    r2329e7 rc85b30  
    1515  while (p != NULL)
    1616  {
    17     n_Delete__T(&(p->coef), r);
     17    n_Delete__T(&(p->coef), r->cf);
    1818    p = p_LmFreeAndNext(p, r);
    1919  }

  • libpolys/polys/templates/p_Minus_mm_Mult_qq__T.cc

    r2329e7 rc85b30  
    3737
    3838  number tm = pGetCoeff(m),           // coefficient of m
    39     tneg = n_Neg__T(n_Copy__T(tm, r), r),    // - (coefficient of m)
     39    tneg = n_Neg__T(n_Copy__T(tm, r->cf), r->cf),    // - (coefficient of m)
    4040    tb,                            // used for tm*coeff(a1)
    4141    tc;                            // used as intermediate number
    … …  
    6464
    6565  Equal:   // qm equals p
    66   tb = n_Mult__T(pGetCoeff(q), tm, r);
     66  tb = n_Mult__T(pGetCoeff(q), tm, r->cf);
    6767#ifdef HAVE_ZERODIVISORS
    68   if (!n_IsZero__T(tb,r)) {
     68  if (!n_IsZero__T(tb,r->cf)) {
    6969#endif
    7070  tc = pGetCoeff(p);
    71   if (!n_Equal__T(tc, tb, r))
     71  if (!n_Equal__T(tc, tb, r->cf))
    7272  {
    7373    shorter++;
    74     tc = n_Sub__T(tc, tb, r);
    75     n_Delete__T(&(pGetCoeff(p)), r);
     74    tc = n_Sub__T(tc, tb, r->cf);
     75    n_Delete__T(&(pGetCoeff(p)), r->cf);
    7676    pSetCoeff0(p,tc); // adjust coeff of p
    7777    a = pNext(a) = p; // append p to result and advance p
    … …  
    8181  { // coeffs are equal, so their difference is 0:
    8282    shorter += 2;
    83     n_Delete__T(&tc, r);
     83    n_Delete__T(&tc, r->cf);
    8484    p = p_LmFreeAndNext(p, r);
    8585  }
    … …  
    9191  }
    9292#endif
    93   n_Delete__T(&tb, r);
     93  n_Delete__T(&tb, r->cf);
    9494  pIter(q);
    9595  if (q == NULL || p == NULL) goto Finish; // are we done ?
    … …  
    100100  Greater:
    101101#ifdef HAVE_ZERODIVISORS
    102   tb = n_Mult__T(pGetCoeff(q), tneg, r);
    103   if (!n_IsZero__T(tb,r))
     102  tb = n_Mult__T(pGetCoeff(q), tneg, r->cf);
     103  if (!n_IsZero__T(tb,r->cf))
    104104  {
    105105#endif
    106     pSetCoeff0(qm, n_Mult__T(pGetCoeff(q), tneg, r));
     106    pSetCoeff0(qm, n_Mult__T(pGetCoeff(q), tneg, r->cf));
    107107    a = pNext(a) = qm;       // append qm to result and advance q
    108108#ifdef HAVE_ZERODIVISORS
    … …  
    112112    shorter++;
    113113  }
    114   n_Delete__T(&tb, r);
     114  n_Delete__T(&tb, r->cf);
    115115#endif
    116116  pIter(q);
    … …  
    157157  }
    158158
    159   n_Delete__T(&tneg, r);
     159  n_Delete__T(&tneg, r->cf);
    160160  if (qm != NULL) p_FreeBinAddr(qm, r);
    161161  Shorter = shorter;

  • libpolys/polys/templates/p_Mult_mm__T.cc

    r2329e7 rc85b30  
    2727  DECLARE_LENGTH(const unsigned long length = ri->ExpL_Size);
    2828  const unsigned long* m_e = m->exp;
    29   pAssume(!n_IsZero__T(ln,ri));
     29  pAssume(!n_IsZero__T(ln,ri->cf));
    3030
    3131#ifdef HAVE_ZERODIVISORS
    … …  
    3535  {
    3636    pn = pGetCoeff(p);
    37     number tmp = n_Mult__T(ln, pn, ri);
     37    number tmp = n_Mult__T(ln, pn, ri->cf);
    3838#ifdef HAVE_ZERODIVISORS
    39     if (n_IsZero__T(tmp, ri))
     39    if (n_IsZero__T(tmp, ri->cf))
    4040    {
    41       n_Delete__T(&tmp, ri);
     41      n_Delete__T(&tmp, ri->cf);
    4242      if (before == p)
    4343      {
    … …  
    5656    {
    5757      pSetCoeff0(p, tmp);
    58       n_Delete__T(&pn, ri);
     58      n_Delete__T(&pn, ri->cf);
    5959      p_MemAdd__T(p->exp, m_e, length);
    6060      p_MemAddAdjust__T(p, ri);

  • libpolys/polys/templates/p_Mult_nn__T.cc

    r2329e7 rc85b30  
    1818LINKAGE poly p_Mult_nn__T(poly p, const number n, const ring r)
    1919{
    20   pAssume(!n_IsZero__T(n,r));
     20  pAssume(!n_IsZero__T(n,r->cf));
    2121  p_Test(p, r);
    2222
    … …  
    2828  {
    2929#ifndef HAVE_ZERODIVISORS
    30     n_InpMult__T(pGetCoeff(p), n, r);
     30    n_InpMult__T(pGetCoeff(p), n, r->cf);
    3131    pIter(p);
    3232#else
    33     number tmp = n_Mult__T(n, pGetCoeff(p), r);
    34     if (!n_IsZero__T(tmp,r))
     33    number tmp = n_Mult__T(n, pGetCoeff(p), r->cf);
     34    if (!n_IsZero__T(tmp,r->cf))
    3535    {
    3636       number nc = pGetCoeff(p);
    3737       p_SetCoeff0(p, tmp, r);
    38        n_Delete__T(&nc, r);
     38       n_Delete__T(&nc, r->cf);
    3939       old = p;
    4040       pIter(p);
    … …  
    4242    else
    4343    {
    44       n_Delete__T(&tmp, r);
     44      n_Delete__T(&tmp, r->cf);
    4545      if (old == NULL)
    4646      {

  • libpolys/polys/templates/p_Neg__T.cc

    r2329e7 rc85b30  
    2020  while (p != NULL)
    2121  {
    22     pSetCoeff0(p, n_Neg__T(pGetCoeff(p), r));
     22    pSetCoeff0(p, n_Neg__T(pGetCoeff(p), r->cf));
    2323    pIter(p);
    2424  }

  • libpolys/polys/templates/p_Numbers.h

    r2329e7 rc85b30  
    1616#include <polys/monomials/ring.h>
    1717
    18 static FORCE_INLINE number n_Copy_FieldGeneral(number n,    const ring r)
    19 { return n_Copy(n,r->cf); }
     18static FORCE_INLINE number n_Copy_FieldGeneral(number n,  const coeffs r)
     19{ return n_Copy(n,r); }
    2020
    21 static FORCE_INLINE void   n_Delete_FieldGeneral(number* p, const ring r)
    22 { n_Delete(p,r->cf); }
     21static FORCE_INLINE void   n_Delete_FieldGeneral(number* p, const coeffs r)
     22{ n_Delete(p,r); }
    2323
    24 static FORCE_INLINE number n_Mult_FieldGeneral(number n1, number n2, const ring r)
    25 { return n_Mult(n1, n2, r->cf); }
     24static FORCE_INLINE number n_Mult_FieldGeneral(number n1, number n2, const coeffs r)
     25{ return n_Mult(n1, n2, r); }
    2626
    27 static FORCE_INLINE number n_Add_FieldGeneral(number n1, number n2, const ring r)
    28 { return n_Add(n1, n2, r->cf); }
     27static FORCE_INLINE number n_Add_FieldGeneral(number n1, number n2, const coeffs r)
     28{ return n_Add(n1, n2, r); }
    2929
    30 static FORCE_INLINE BOOLEAN n_IsZero_FieldGeneral(number n, const ring r)
    31 { return n_IsZero(n, r->cf); }
     30static FORCE_INLINE BOOLEAN n_IsZero_FieldGeneral(number n, const coeffs r)
     31{ return n_IsZero(n, r); }
    3232
    33 static FORCE_INLINE BOOLEAN n_Equal_FieldGeneral(number n1, number n2, const ring r)
    34 { return n_Equal(n1, n2, r->cf); }
     33static FORCE_INLINE BOOLEAN n_Equal_FieldGeneral(number n1, number n2, const coeffs r)
     34{ return n_Equal(n1, n2, r); }
    3535
    36 static FORCE_INLINE number n_Neg_FieldGeneral(number n,     const ring r)
    37 { return n_InpNeg(n, r->cf); }
     36static FORCE_INLINE number n_Neg_FieldGeneral(number n, const coeffs r)
     37{ return n_InpNeg(n, r); }
    3838
    39 static FORCE_INLINE number n_Sub_FieldGeneral(number n1, number n2, const ring r)
    40 { return n_Sub(n1, n2, r->cf); }
     39static FORCE_INLINE number n_Sub_FieldGeneral(number n1, number n2, const coeffs r)
     40{ return n_Sub(n1, n2, r); }
    4141
    42 static FORCE_INLINE void n_InpMult_FieldGeneral(number &n1, number n2, const ring r)
    43 { n_InpMult(n1, n2, r->cf); }
     42static FORCE_INLINE void n_InpMult_FieldGeneral(number &n1, number n2, const coeffs r)
     43{ n_InpMult(n1, n2, r); }
    4444
    45 static FORCE_INLINE void n_InpAdd_FieldGeneral(number &n1, number n2, const ring r)
    46 { n_InpAdd(n1, n2, r->cf); }
     45static FORCE_INLINE void n_InpAdd_FieldGeneral(number &n1, number n2, const coeffs r)
     46{ n_InpAdd(n1, n2, r); }
    4747
    4848#ifdef HAVE_RINGS
    … …  
    5858#define n_InpMult_RingGeneral(n1, n2, r)   n_InpMult_FieldGeneral(n1, n2, r)
    5959
    60 static FORCE_INLINE void n_InpAdd_RingGeneral(number &n1, number n2, const ring r)
    61 {  assume(rField_is_Ring(r)); n_InpAdd(n1, n2, r->cf); }
     60static FORCE_INLINE void n_InpAdd_RingGeneral(number &n1, number n2, const coeffs r)
     61{  assume(nCoeff_is_Ring(r)); n_InpAdd(n1, n2, r); }
    6262#endif
    6363
    … …  
    6767#define n_Delete_FieldZp(n, r)      do {} while (0)
    6868
    69 static FORCE_INLINE number n_Mult_FieldZp(number n1, number n2, const ring r)
    70 { STATISTIC(n_Mult); return npMultM(n1, n2, r->cf); }
     69static FORCE_INLINE number n_Mult_FieldZp(number n1, number n2, const coeffs r)
     70{ STATISTIC(n_Mult); return npMultM(n1, n2, r); }
    7171
    7272#ifdef HAVE_NUMSTATS
    73 static FORCE_INLINE number n_Add_FieldZp(number n1, number n2, const ring r)
    74 { STATISTIC(n_Add); const number sum = npAddM(n1, n2, r->cf);
     73static FORCE_INLINE number n_Add_FieldZp(number n1, number n2, const coeffs r)
     74{ STATISTIC(n_Add); const number sum = npAddM(n1, n2, r);
    7575  // avoid double counting
    76   if( npIsZeroM(sum,r->cf) ) STATISTIC(n_CancelOut);
    77  return sum;
     76  if( npIsZeroM(sum,r) ) STATISTIC(n_CancelOut);
     77  return sum;
    7878}
    7979#else
    80 static FORCE_INLINE number n_Add_FieldZp(number n1, number n2, const ring r)
    81 { return npAddM(n1, n2, r->cf); }
     80static FORCE_INLINE number n_Add_FieldZp(number n1, number n2, const coeffs r)
     81{ return npAddM(n1, n2, r); }
    8282#endif
    8383
    8484#ifdef HAVE_NUMSTATS
    85 static FORCE_INLINE number n_Sub_FieldZp(number n1, number n2, const ring r)
    86 { STATISTIC(n_Sub); const number d = npSubM(n1, n2, r->cf);
     85static FORCE_INLINE number n_Sub_FieldZp(number n1, number n2, const coeffs r)
     86{ STATISTIC(n_Sub); const number d = npSubM(n1, n2, r);
    8787  // avoid double counting
    88   if( npIsZeroM(d,r->cf) ) STATISTIC(n_CancelOut);
     88  if( npIsZeroM(d,r) ) STATISTIC(n_CancelOut);
    8989  return d;
    9090}
    9191#else
    92 static FORCE_INLINE number n_Sub_FieldZp(number n1, number n2, const ring r)
    93 { return npSubM(n1, n2, r->cf); }
     92static FORCE_INLINE number n_Sub_FieldZp(number n1, number n2, const coeffs r)
     93{ return npSubM(n1, n2, r); }
    9494#endif
    9595
    96 static FORCE_INLINE BOOLEAN n_IsZero_FieldZp(number n, const ring r)
    97 { STATISTIC(n_IsZero); return npIsZeroM(n, r->cf); }
     96static FORCE_INLINE BOOLEAN n_IsZero_FieldZp(number n, const coeffs r)
     97{ STATISTIC(n_IsZero); return npIsZeroM(n, r); }
    9898
    99 static FORCE_INLINE BOOLEAN n_Equal_FieldZp(number n1, number n2, const ring r)
    100 { STATISTIC(n_Equal); return  npEqualM(n1, n2, r->cf); }
     99static FORCE_INLINE BOOLEAN n_Equal_FieldZp(number n1, number n2, const coeffs r)
     100{ STATISTIC(n_Equal); return  npEqualM(n1, n2, r); }
    101101
    102 static FORCE_INLINE number n_Neg_FieldZp(number n,     const ring r)
    103 { STATISTIC(n_InpNeg); return npNegM(n, r->cf); }
     102static FORCE_INLINE number n_Neg_FieldZp(number n, const coeffs r)
     103{ STATISTIC(n_InpNeg); return npNegM(n, r); }
    104104
    105 static FORCE_INLINE void n_InpMult_FieldZp(number &n1, number n2, const ring r)
    106 { STATISTIC(n_InpMult); n1=npMultM(n1, n2, r->cf);  }
     105static FORCE_INLINE void n_InpMult_FieldZp(number &n1, number n2, const coeffs r)
     106{ STATISTIC(n_InpMult); n1=npMultM(n1, n2, r);  }
    107107
    108108#ifdef HAVE_NUMSTATS
    109 static FORCE_INLINE void n_InpAdd_FieldZp(number &n1, number n2, const ring r)
     109static FORCE_INLINE void n_InpAdd_FieldZp(number &n1, number n2, const coeffs r)
    110110{
    111   STATISTIC(n_InpAdd); n1=npAddM(n1, n2, r->cf);
     111  STATISTIC(n_InpAdd); n1=npAddM(n1, n2, r);
    112112  // avoid double counting
    113   if( npIsZeroM(n1,r->cf) ) STATISTIC(n_CancelOut);
     113  if( npIsZeroM(n1,r) ) STATISTIC(n_CancelOut);
    114114}
    115115#else
    116 static FORCE_INLINE void n_InpAdd_FieldZp(number &n1, number n2, const ring r)
    117 { n1=npAddM(n1, n2, r->cf); }
     116static FORCE_INLINE void n_InpAdd_FieldZp(number &n1, number n2, const coeffs r)
     117{ n1=npAddM(n1, n2, r); }
    118118#endif
    119119
    … …  
    121121#include <coeffs/longrat.cc> // for inlining... TODO: fix this Uglyness?!!!
    122122
    123 static FORCE_INLINE number n_Copy_FieldQ(number n,    const ring r)
    124 { STATISTIC(n_Copy); return nlCopy(n, r->cf); }
     123static FORCE_INLINE number n_Copy_FieldQ(number n, const coeffs r)
     124{ STATISTIC(n_Copy); return nlCopy(n, r); }
    125125
    126 static FORCE_INLINE void   n_Delete_FieldQ(number* n, const ring r)
    127 { STATISTIC(n_Delete); nlDelete(n,r->cf); }
     126static FORCE_INLINE void   n_Delete_FieldQ(number* n, const coeffs r)
     127{ STATISTIC(n_Delete); nlDelete(n,r); }
    128128
    129 static FORCE_INLINE number n_Mult_FieldQ(number n1, number n2, const ring r)
    130 { STATISTIC(n_Mult); return nlMult(n1,n2, r->cf); }
     129static FORCE_INLINE number n_Mult_FieldQ(number n1, number n2, const coeffs r)
     130{ STATISTIC(n_Mult); return nlMult(n1,n2, r); }
    131131
    132132#ifdef HAVE_NUMSTATS
    133 static FORCE_INLINE number n_Add_FieldQ(number n1, number n2, const ring r)
    134 { STATISTIC(n_Add); const number sum = nlAdd(n1, n2, r->cf);
     133static FORCE_INLINE number n_Add_FieldQ(number n1, number n2, const coeffs r)
     134{ STATISTIC(n_Add); const number sum = nlAdd(n1, n2, r);
    135135  // avoid double counting
    136   if( nlIsZero(sum,r->cf) ) STATISTIC(n_CancelOut);
    137  return sum;
     136  if( nlIsZero(sum,r) ) STATISTIC(n_CancelOut);
     137  return sum;
    138138}
    139139#else
    140 static FORCE_INLINE number n_Add_FieldQ(number n1, number n2, const ring r)
    141 { return nlAdd(n1, n2, r->cf); }
     140static FORCE_INLINE number n_Add_FieldQ(number n1, number n2, const coeffs r)
     141{ return nlAdd(n1, n2, r); }
    142142#endif
    143143
    144144#ifdef HAVE_NUMSTATS
    145 static FORCE_INLINE number n_Sub_FieldQ(number n1, number n2, const ring r)
    146 { STATISTIC(n_Sub); const number d = nlSub(n1, n2, r->cf);
     145static FORCE_INLINE number n_Sub_FieldQ(number n1, number n2, const coeffs r)
     146{ STATISTIC(n_Sub); const number d = nlSub(n1, n2, r);
    147147  // avoid double counting
    148   if( nlIsZero(d,r->cf) ) STATISTIC(n_CancelOut);
     148  if( nlIsZero(d,r) ) STATISTIC(n_CancelOut);
    149149  return d;
    150150}
    151151#else
    152 static FORCE_INLINE number n_Sub_FieldQ(number n1, number n2, const ring r)
    153 { return nlSub(n1, n2, r->cf); }
     152static FORCE_INLINE number n_Sub_FieldQ(number n1, number n2, const coeffs r)
     153{ return nlSub(n1, n2, r); }
    154154#endif
    155155
    156 static FORCE_INLINE BOOLEAN n_IsZero_FieldQ(number n, const ring r)
    157 { STATISTIC(n_IsZero); return nlIsZero(n, r->cf); }
     156static FORCE_INLINE BOOLEAN n_IsZero_FieldQ(number n, const coeffs r)
     157{ STATISTIC(n_IsZero); return nlIsZero(n, r); }
    158158
    159 static FORCE_INLINE BOOLEAN n_Equal_FieldQ(number n1, number n2, const ring r)
    160 { STATISTIC(n_Equal); return  nlEqual(n1, n2, r->cf); }
     159static FORCE_INLINE BOOLEAN n_Equal_FieldQ(number n1, number n2, const coeffs r)
     160{ STATISTIC(n_Equal); return  nlEqual(n1, n2, r); }
    161161
    162 static FORCE_INLINE number n_Neg_FieldQ(number n,     const ring r)
    163 { STATISTIC(n_InpNeg); return nlNeg(n, r->cf); }
     162static FORCE_INLINE number n_Neg_FieldQ(number n, const coeffs r)
     163{ STATISTIC(n_InpNeg); return nlNeg(n, r); }
    164164
    165 static FORCE_INLINE void n_InpMult_FieldQ(number &n1, number n2, const ring r)
    166 { STATISTIC(n_InpMult); nlInpMult(n1, n2, r->cf); }
     165static FORCE_INLINE void n_InpMult_FieldQ(number &n1, number n2, const coeffs r)
     166{ STATISTIC(n_InpMult); nlInpMult(n1, n2, r); }
    167167
    168168#ifdef HAVE_NUMSTATS
    169 static FORCE_INLINE void n_InpAdd_FieldQ(number &n1, number n2, const ring r)
    170 { STATISTIC(n_InpAdd); assume(rField_is_Q(r)); nlInpAdd(n1, n2, r->cf);
    171 
     169static FORCE_INLINE void n_InpAdd_FieldQ(number &n1, number n2, const coeffs r)
     170{ STATISTIC(n_InpAdd); assume(nCoeff_is_Q(r)); nlInpAdd(n1, n2, r);
    172171  // avoid double counting
    173   if( nlIsZero(n1,r->cf) ) STATISTIC(n_CancelOut);
     172  if( nlIsZero(n1,r) ) STATISTIC(n_CancelOut);
    174173}
    175174#else
    176 static FORCE_INLINE void n_InpAdd_FieldQ(number &n1, number n2, const ring r)
    177 { nlInpAdd(n1, n2, r->cf); }
     175static FORCE_INLINE void n_InpAdd_FieldQ(number &n1, number n2, const coeffs r)
     176{ nlInpAdd(n1, n2, r); }
    178177#endif
    179178

  • libpolys/polys/templates/p_kBucketSetLm__T.cc

    r2329e7 rc85b30  
    5555        Greater:
    5656        {
    57           if (n_IsZero__T(pGetCoeff(p), r))
     57          if (n_IsZero__T(pGetCoeff(p), r->cf))
    5858          {
    59             n_Delete__T(&pGetCoeff(p), r);
     59            n_Delete__T(&pGetCoeff(p), r->cf);
    6060            pIter(bucket->buckets[j]);
    6161            p_FreeBinAddr(p, r);
    … …  
    7171          number tn = pGetCoeff(p);
    7272          #if 0
    73           pSetCoeff0(p, n_Add__T(pGetCoeff(bucket->buckets[i]), tn, r));
    74           n_Delete__T(&tn, r);
     73          pSetCoeff0(p, n_Add__T(pGetCoeff(bucket->buckets[i]), tn, r->cf));
     74          n_Delete__T(&tn, r->cf);
    7575          #else
    76           n_InpAdd__T(tn,pGetCoeff(bucket->buckets[i]), r);
     76          n_InpAdd__T(tn,pGetCoeff(bucket->buckets[i]), r->cf);
    7777          pSetCoeff0(p, tn);
    7878          #endif
    7979          p = bucket->buckets[i];
    8080          pIter(bucket->buckets[i]);
    81           n_Delete__T(&pGetCoeff(p), r);
     81          n_Delete__T(&pGetCoeff(p), r->cf);
    8282          p_FreeBinAddr(p, r);
    8383          (bucket->buckets_length[i])--;
    … …  
    8888    }
    8989    p = bucket->buckets[j];
    90     if (j > 0 && n_IsZero__T(pGetCoeff(p), r))
     90    if (j > 0 && n_IsZero__T(pGetCoeff(p), r->cf))
    9191    {
    92       n_Delete__T(&pGetCoeff(p), r);
     92      n_Delete__T(&pGetCoeff(p), r->cf);
    9393      pIter(bucket->buckets[j]);
    9494      p_FreeBinAddr(p, r);

  • libpolys/polys/templates/pp_Mult_Coeff_mm_DivSelectMult__T.cc

    r2329e7 rc85b30  
    2525  number n = pGetCoeff(m);
    2626  number nc;
    27   pAssume(!n_IsZero__T(n,r));
     27  pAssume(!n_IsZero__T(n,r->cf));
    2828
    2929  spolyrec rp;
    … …  
    5959    q = pNext(q);
    6060    nc = pGetCoeff(p);
    61     pSetCoeff0(q, n_Mult__T(n, nc, r));
     61    pSetCoeff0(q, n_Mult__T(n, nc, r->cf));
    6262    p_MemSum__T(q->exp, p->exp, ab_e, length);
    6363

  • libpolys/polys/templates/pp_Mult_Coeff_mm_DivSelect__T.cc

    r2329e7 rc85b30  
    2020{
    2121  number n = pGetCoeff(m);
    22   pAssume(!n_IsZero__T(n,r));
     22  pAssume(!n_IsZero__T(n,r->cf));
    2323  p_Test(p, r);
    2424  if (p == NULL) return NULL;
    … …  
    3636      q = pNext(q);
    3737      number nc = pGetCoeff(p);
    38       pSetCoeff0(q, n_Mult__T(n, nc, r));
     38      pSetCoeff0(q, n_Mult__T(n, nc, r->cf));
    3939      p_MemCopy__T(q->exp, p->exp, length);
    4040    }

  • libpolys/polys/templates/pp_Mult_mm_Noether__T.cc

    r2329e7 rc85b30  
    3636  DECLARE_ORDSGN(const long* ordsgn = ri->ordsgn);
    3737  const unsigned long* m_e = m->exp;
    38   pAssume(!n_IsZero__T(ln,ri));
     38  pAssume(!n_IsZero__T(ln,ri->cf));
    3939  pAssume1(p_GetComp(m, ri) == 0 || p_MaxComp(p, ri) == 0);
    4040  int l = 0;
    … …  
    5454    Continue:
    5555
    56     n = n_Mult__T(ln, pGetCoeff(p), ri);
     56    n = n_Mult__T(ln, pGetCoeff(p), ri->cf);
    5757
    5858    #ifdef HAVE_RINGS
    59     if(n_IsZero__T(n, ri))
     59    if(n_IsZero__T(n, ri->cf))
    6060    {
    61       n_Delete__T(&n, ri);
     61      n_Delete__T(&n, ri->cf);
    6262      p_FreeBinAddr(r, ri);
    6363    } else

  • libpolys/polys/templates/pp_Mult_mm__T.cc

    r2329e7 rc85b30  
    3232  DECLARE_LENGTH(const unsigned long length = ri->ExpL_Size);
    3333  const unsigned long* m_e = m->exp;
    34   pAssume(!n_IsZero__T(ln,ri));
     34  pAssume(!n_IsZero__T(ln,ri->cf));
    3535  pAssume1(p_GetComp(m, ri) == 0 || p_MaxComp(p, ri) == 0);
    3636  number tmp;
    … …  
    3838  do
    3939  {
    40     tmp = n_Mult__T(ln, pGetCoeff(p), ri);
     40    tmp = n_Mult__T(ln, pGetCoeff(p), ri->cf);
    4141#ifdef HAVE_ZERODIVISORS
    42     if (! n_IsZero__T(tmp, ri))
     42    if (! n_IsZero__T(tmp, ri->cf))
    4343    {
    4444#endif
    … …  
    5050#ifdef HAVE_ZERODIVISORS
    5151    }
    52     else n_Delete__T(&tmp, ri);
     52    else n_Delete__T(&tmp, ri->cf);
    5353#endif
    5454    p = pNext(p);

  • libpolys/polys/templates/pp_Mult_nn__T.cc

    r2329e7 rc85b30  
    1717LINKAGE poly pp_Mult_nn__T(poly p, const number n, const ring r)
    1818{
    19   pAssume(!n_IsZero__T(n,r));
     19  pAssume(!n_IsZero__T(n,r->cf));
    2020  p_Test(p, r);
    2121  if (p == NULL) return NULL;
    … …  
    3434    pIter(q);
    3535    number nc = pGetCoeff(p);
    36     pSetCoeff0(q, n_Mult__T(n, nc, r));
     36    pSetCoeff0(q, n_Mult__T(n, nc, r->cf));
    3737    p_MemCopy__T(q->exp, p->exp, length);
    3838#else
    3939    number nc = pGetCoeff(p);
    40     number tmp = n_Mult__T(n, nc, r);
    41     if (! n_IsZero__T(tmp,r))
     40    number tmp = n_Mult__T(n, nc, r->cf);
     41    if (! n_IsZero__T(tmp,r->cf))
    4242    {
    4343      p_AllocBin(pNext(q), bin, r);
    … …  
    4747    }
    4848    else
    49       n_Delete__T(&tmp,r);
     49      n_Delete__T(&tmp,r->cf);
    5050#endif
    5151    pIter(p);
Note: See TracChangeset for help on using the changeset viewer.