Changeset d249822 in git


Ignore:
Timestamp:
Jul 21, 2016, 11:11:08 AM (8 years ago)
Author:
Adi Popescu <adi_popescum@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'b4f17ed1d25f93d46dbe29e4b499baecc2fd51bb')
Children:
ef27298cfb747d136e3418af99edf58c03b12a05
Parents:
b6f42a8c2492312d1dd4f0c4c917fcf054636416
Message:
rem: HAVE_RINGS in several places
fix: sba over Z_m
Location:
kernel/GBEngine
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • kernel/GBEngine/kspoly.cc

    rb6f42a8 rd249822  
    246246    {
    247247      pSetCoeff(sigMult,nMult(nDiv(pGetCoeff(PR->p),pGetCoeff(PW->p)), pGetCoeff(sigMult)));
     248      if(nIsZero(pGetCoeff(sigMult)))
     249      {
     250        sigMult = NULL;
     251      }
    248252    }
    249253//#if 1
    … …  
    270274      // Set the sig
    271275      poly origsig = pCopy(PR->sig);
    272       PR->sig = pHead(pSub(PR->sig, sigMult));
     276      if(sigMult != NULL)
     277        PR->sig = pHead(pSub(PR->sig, sigMult));
    273278      //The sigs have the same lm, have to substract
    274279      //It may happen that now the signature is 0 (drop)

  • kernel/GBEngine/kstd1.cc

    rb6f42a8 rd249822  
    153153                                                       strat->tailRing));
    154154    }
    155     #ifdef HAVE_RINGS
    156155    if(redMoraNF && (rField_is_Ring(currRing)))
    157156      enterT_strong(*h,strat);
    158157    else
    159     #endif
    160158      enterT(*h,strat);
    161159    *h = L;
    … …  
    11561154      if (pNext(strat->L[j].p) == strat->tail)
    11571155      {
    1158 #ifdef HAVE_RINGS
    11591156        if (rField_is_Ring(currRing))
    11601157          pLmDelete(strat->L[j].p);    /*deletes the short spoly and computes*/
    11611158        else
    1162 #else
    11631159          pLmFree(strat->L[j].p);    /*deletes the short spoly and computes*/
    1164 #endif
    11651160        strat->L[j].p = NULL;
    11661161        poly m1 = NULL, m2 = NULL;
    … …  
    12171212      if (pLmCmp(strat->L[i].p,strat->kNoether) == -1)
    12181213      {
    1219         #ifdef HAVE_RINGS
    12201214        if (rField_is_Ring(currRing))
    12211215          pLmDelete(strat->L[i].p);
    12221216        else
    1223         #endif
    12241217          pLmFree(strat->L[i].p);
    12251218        strat->L[i].p = NULL;
    … …  
    12271220      else
    12281221      {
    1229         #ifdef HAVE_RINGS
    12301222        if (rField_is_Ring(currRing))
    12311223          pLmDelete(strat->L[i].p);
    12321224        else
    1233         #endif
    12341225          pLmFree(strat->L[i].p);
    12351226        strat->L[i].p = NULL;
    … …  
    13391330      return;
    13401331
    1341 #ifdef HAVE_RINGS
    13421332    if ( (!rField_is_Ring(currRing)) || (rHasGlobalOrdering(currRing)))
    1343 #endif
    13441333    {
    13451334      strat->red = redFirst;
    … …  
    13481337    updateT(strat);
    13491338
    1350 #ifdef HAVE_RINGS
    13511339    if ( (!rField_is_Ring(currRing)) || (rHasGlobalOrdering(currRing)))
    1352 #endif
    13531340    {
    13541341      strat->posInT = posInT2;
    … …  
    14511438    strat->red = redHomog;
    14521439  }
    1453 #ifdef HAVE_RINGS  //TODO Oliver
    14541440  if (rField_is_Ring(currRing))
    14551441  {
    14561442    strat->red = redRing;
    14571443  }
    1458 #endif
    14591444  if (currRing->pLexOrder && strat->honey)
    14601445    strat->initEcart = initEcartNormal;
    … …  
    15871572  }
    15881573
    1589 #ifdef HAVE_RINGS
    15901574  if (rField_is_Ring(currRing))
    15911575    strat->red = redRiloc;
    1592 #endif
    15931576
    15941577  /*reads the ecartWeights used for Graebes method from the
    … …  
    17391722    {
    17401723      /*- deletes the short spoly and computes -*/
    1741 #ifdef HAVE_RINGS
    17421724      if (rField_is_Ring(currRing))
    17431725        pLmDelete(strat->P.p);
    17441726      else
    1745 #endif
    1746       pLmFree(strat->P.p);
     1727        pLmFree(strat->P.p);
    17471728      strat->P.p = NULL;
    17481729      poly m1 = NULL, m2 = NULL;
    … …  
    17791760      printf("\nBefore Ll = %i\n", strat->Ll);
    17801761      #endif
    1781       #ifdef HAVE_RINGS
    17821762      if(rField_is_Ring(strat->tailRing) && rHasLocalOrMixedOrdering(currRing))
    1783       {
    17841763        red_result = strat->red(&strat->P,strat);
    1785       }
    17861764      else
    1787       #endif
    17881765        red_result = strat->red(&strat->P,strat);
    17891766      #if ADIDEBUG
    … …  
    18231800      enterT(strat->P,strat);
    18241801      // build new pairs
    1825 #ifdef HAVE_RINGS
    18261802      if (rField_is_Ring(currRing))
    1827       {
    18281803        superenterpairs(strat->P.p,strat->sl,strat->P.ecart,0,strat, strat->tl);
    1829       }
    18301804      else
    1831 #endif
    1832       enterpairs(strat->P.p,strat->sl,strat->P.ecart,0,strat, strat->tl);
     1805        enterpairs(strat->P.p,strat->sl,strat->P.ecart,0,strat, strat->tl);
    18331806      // put in S
    18341807
    … …  
    18651838      if (strat->P.lcm!=NULL)
    18661839      {
    1867 #ifdef HAVE_RINGS
    1868         if (rField_is_Ring(currRing)) pLmDelete(strat->P.lcm);
     1840        if (rField_is_Ring(currRing))
     1841          pLmDelete(strat->P.lcm);
    18691842        else
    1870 #else
    18711843          pLmFree(strat->P.lcm);
    1872 #endif
    18731844        strat->P.lcm=NULL;
    18741845      }
    … …  
    19261897//    }
    19271898//  }
    1928   #ifdef HAVE_RINGS
    19291899  if(nCoeff_is_Ring_Z(currRing->cf))
    19301900    finalReduceByMon(strat);
    1931   #endif
    19321901  if (Q!=NULL) updateResult(strat->Shdl,Q,strat);
    19331902  SI_RESTORE_OPT1(save1);
    … …  
    20322001  if (TEST_OPT_PROT) { PrintS("r"); mflush(); }
    20332002  if (BVERBOSE(23)) kDebugPrint(strat);
    2034   #ifdef HAVE_RINGS
    20352003  if(rField_is_Ring(currRing))
    20362004  {
    … …  
    20382006  }
    20392007  else
    2040   #endif
     2008  {
    20412009    if (p!=NULL) p = redMoraNF(p,strat, lazyReduce & KSTD_NF_ECART);
     2010  }
    20422011  if ((p!=NULL)&&((lazyReduce & KSTD_NF_LAZY)==0))
    20432012  {
    … …  
    21752144          h.sev = strat->sevS[j];
    21762145          h.SetpFDeg();
    2177           #ifdef HAVE_RINGS
    21782146          if(rField_is_Ring(currRing) && rHasLocalOrMixedOrdering(currRing))
    21792147            enterT_strong(h,strat);
    21802148          else
    2181           #endif
    21822149            enterT(h,strat);
    21832150        }
    21842151        if (TEST_OPT_PROT) { PrintS("r"); mflush(); }
    2185         #ifdef HAVE_RINGS
    21862152        if(rField_is_Ring(currRing))
    21872153        {
    … …  
    21892155        }
    21902156        else
    2191         #endif
    21922157          p = redMoraNF(p,strat, lazyReduce & KSTD_NF_ECART);
    21932158        if ((p!=NULL)&&((lazyReduce & KSTD_NF_LAZY)==0))
    … …  
    25892554    #endif
    25902555    //This is how we set the SBA algorithm;
    2591     int totalsbaruns = 1,blockedreductions = 10,blockred = 0,loops = 0;
     2556    int totalsbaruns = 1,blockedreductions = 20,blockred = 0,loops = 0;
    25922557    while(sigdrop && (loops < totalsbaruns || totalsbaruns == -1)
    25932558                  && (blockred <= blockedreductions))
    … …  
    27142679          printf("\nSBA Run %i: %i elements (syzCrit = %i,rewCrit = %i)\n",loops,IDELEMS(r),strat->nrsyzcrit,strat->nrrewcrit);
    27152680          idPrint(r);
    2716           getchar();
     2681          //getchar();
    27172682          #endif
    27182683        }
    … …  
    27432708      #if ADIDEBUG
    27442709      printf("\nWent to std\n");
    2745       //idPrint(r);
    2746       //getchar();
     2710      idPrint(r);
     2711      getchar();
    27472712      #endif
    27482713      r = kStd(r, Q, h, w, hilb, syzComp, newIdeal, vw);

  • kernel/GBEngine/kstd2.cc

    rb6f42a8 rd249822  
    109109        if (p_LmShortDivisibleBy(T[j].p, sevT[j],p, not_sev, r))
    110110        {
    111           if(n_DivBy(pGetCoeff(p), pGetCoeff(T[j].p), r))
     111          if(n_DivBy(p_GetCoeff(p,r), p_GetCoeff(T[j].p,r), r))
    112112            return j;
    113113        }
    … …  
    116116          p_LmDivisibleBy(T[j].p, p, r))
    117117        {
    118           if(n_DivBy(pGetCoeff(p), pGetCoeff(T[j].p), r))
     118          if(n_DivBy(p_GetCoeff(p,r), p_GetCoeff(T[j].p,r), r))
    119119            return j;
    120120        }
    … …  
    212212#endif
    213213  (*max_ind)=ende;
    214 #ifdef HAVE_RINGS
    215214  if(rField_is_Ring(currRing))
    216215  {
    … …  
    237236  }
    238237  else
    239 #endif
    240238  {
    241239    loop
    … …  
    272270  int ende=strat->sl;
    273271#endif
    274 #ifdef HAVE_RINGS
    275272  if(rField_is_Ring(currRing))
    276273  {
    … …  
    297294  }
    298295  else
    299 #endif
    300296  {
    301297    loop
    … …  
    717713  #endif
    718714  #endif
    719   #ifdef HAVE_RINGS
    720715  poly beforeredsig;
    721716  if(rField_is_Ring(currRing))
    722717    beforeredsig = pCopy(h->sig);
    723   #endif
     718   
    724719  if (strat->tl<0) return 1;
    725720  //if (h->GetLmTailRing()==NULL) return 0; // HS: SHOULD NOT BE NEEDED!
    … …  
    794789          return 0;
    795790        }
    796         #ifdef HAVE_RINGS
    797791        if(rField_is_Ring(currRing))
    798792        {
    … …  
    827821          p_Delete(&beforeredsig,currRing);
    828822        }
    829         #endif
    830823        return 1;
    831824      }
    … …  
    18951888      {
    18961889        enterT(strat->P, strat);
    1897         #ifdef HAVE_RINGS
    18981890        if (rField_is_Ring(currRing))
    18991891          superenterpairs(strat->P.p,strat->sl,strat->P.ecart,pos,strat, strat->tl);
    19001892        else
    1901         #endif
    19021893          enterpairs(strat->P.p,strat->sl,strat->P.ecart,pos,strat, strat->tl);
    19031894        // posInS only depends on the leading term
    … …  
    19401931          int pos=posInS(strat,strat->sl,strat->P.p,strat->P.ecart);
    19411932          enterT(strat->P, strat);
    1942           #ifdef HAVE_RINGS
    19431933          if (rField_is_Ring(currRing))
    19441934            superenterpairs(strat->P.p,strat->sl,strat->P.ecart,pos,strat, strat->tl);
    19451935          else
    1946           #endif
    19471936            enterpairs(strat->P.p,strat->sl,strat->P.ecart,pos,strat, strat->tl);
    19481937          strat->enterS(strat->P, pos, strat, strat->tl);
    … …  
    20011990  }
    20021991  else if (TEST_OPT_PROT) PrintLn();
    2003   #ifdef HAVE_RINGS
    20041992  if(nCoeff_is_Ring_Z(currRing->cf))
    20051993    finalReduceByMon(strat);
    … …  
    20142002    }
    20152003  }
    2016   #endif
    20172004  /* release temp data-------------------------------- */
    20182005  exitBuchMora(strat);
    … …  
    23222309    strat->Ll--;
    23232310   
    2324     #ifdef HAVE_RINGS
    23252311    if(rField_is_Ring(currRing))
    23262312      strat->sbaEnterS = pGetComp(strat->P.sig) - 1;
    2327     #endif
    23282313   
    23292314    #if ADIDEBUG
    … …  
    26732658      // posInS only depends on the leading term
    26742659     
    2675       #ifdef HAVE_RINGS
    26762660      if(rField_is_Ring(currRing) && strat->sigdrop)
    26772661        break;
    2678       #endif
    26792662      strat->P.sevSig = p_GetShortExpVector(strat->P.sig,currRing);
    26802663      strat->enterS(strat->P, pos, strat, strat->tl);
    … …  
    28482831        zeroreductions++;
    28492832#endif
    2850         #ifdef HAVE_RINGS
    28512833        if(rField_is_Ring(currRing) && strat->P.p == NULL && strat->P.sig == NULL)
    28522834        {
    … …  
    28542836        }
    28552837        else
    2856         #endif
    28572838        {
    28582839          int pos = posInSyz(strat, strat->P.sig);
    … …  
    28842865  #endif
    28852866// Clean strat->P for the next sba call
    2886 #ifdef HAVE_RINGS
    28872867  if(rField_is_Ring(currRing) && strat->sigdrop)
    28882868  {
    … …  
    28952875    #endif /* KDEBUG */
    28962876  }
    2897 #endif
    28982877#ifdef KDEBUG
    28992878  if (TEST_OPT_DEBUG) messageSets(strat);
    … …  
    30162995    rDelete (sRing);
    30172996  }
    3018   #ifdef HAVE_RINGS
    3019   //if(nCoeff_is_Ring_Z(currRing->cf))
    3020   //  finalReduceByMon(strat);
    30212997  if(rField_is_Ring(currRing) && !strat->sigdrop)
    3022   #endif
    30232998    id_DelDiv(strat->Shdl, currRing);
    30242999  idSkipZeroes(strat->Shdl);
    … …  
    31293104  {
    31303105    if (TEST_OPT_PROT) { PrintS("t"); mflush(); }
    3131     #ifdef HAVE_RINGS
    31323106    if (rField_is_Ring(currRing))
    31333107    {
    … …  
    31353109    }
    31363110    else
    3137     #endif
    31383111    {
    31393112      si_opt_1 &= ~Sy_bit(OPT_INTSTRATEGY);
    … …  
    32023175      {
    32033176        if (TEST_OPT_PROT) { PrintS("t"); mflush(); }
    3204         #ifdef HAVE_RINGS
    32053177        if (rField_is_Ring(currRing))
    32063178        {
    … …  
    32083180        }
    32093181        else
    3210         #endif
    32113182        {
    32123183          p = redtailBba(p,max_ind,strat,(lazyReduce & KSTD_NF_NONORM)==0);

  • kernel/GBEngine/kutil.cc

    rb6f42a8 rd249822  
    363363  h = pNext(p);
    364364
    365 #ifdef HAVE_RINGS
    366365  if(rField_is_Ring(currRing))
    367366  {
    … …  
    425424  }
    426425  else
    427 #endif
    428426  {
    429427    loop
    … …  
    18071805    h.p = pNeg(h.p);
    18081806  }
    1809   #ifdef HAVE_RINGS
    18101807 
    1811     if(rField_is_Ring(currRing) &&
    1812       pLtCmp(h.sig,sig) == -1
    1813       )
     1808    if(rField_is_Ring(currRing) &&  pLtCmp(h.sig,sig) == -1)
    18141809    {
    18151810      #if ADIDEBUG
    … …  
    18451840      }
    18461841    }
    1847     #endif
    18481842  #if ADIDEBUG
    18491843  printf("\nThis strong poly was added to L:\n");pWrite(h.p);pWrite(h.p1);pWrite(h.p2);pWrite(h.sig);
    … …  
    24382432
    24392433  // set coeffs of multipliers m1 and m2
    2440   #ifdef HAVE_RINGS
    24412434  if(rField_is_Ring(currRing))
    24422435  {
    … …  
    24522445  }
    24532446  else
    2454   #endif
    24552447  {
    24562448    pSetCoeff0(m1, nInit(1));
    … …  
    24702462  // get multiplied signatures for testing
    24712463  pSigMult = pp_Mult_mm(pSigMult,m1,currRing);
    2472   pSigMultNegSev = ~p_GetShortExpVector(pSigMult,currRing);
     2464  if(pSigMult != NULL)
     2465    pSigMultNegSev = ~p_GetShortExpVector(pSigMult,currRing);
    24732466  sSigMult = pp_Mult_mm(sSigMult,m2,currRing);
    2474   sSigMultNegSev = ~p_GetShortExpVector(sSigMult,currRing);
     2467  if(sSigMult != NULL)
     2468    sSigMultNegSev = ~p_GetShortExpVector(sSigMult,currRing);
    24752469//#if 1
    24762470#ifdef DEBUGF5
    … …  
    24822476#endif
    24832477  int sigCmp;
    2484   #ifdef HAVE_RINGS
    2485   if(rField_is_Ring(currRing))
    2486     sigCmp = p_LtCmpNoAbs(pSigMult,sSigMult,currRing);
     2478  if(pSigMult != NULL && sSigMult != NULL)
     2479  {
     2480    if(rField_is_Ring(currRing))
     2481      sigCmp = p_LtCmpNoAbs(pSigMult,sSigMult,currRing);
     2482    else
     2483      sigCmp = p_LmCmp(pSigMult,sSigMult,currRing);
     2484  }
    24872485  else
    2488   #endif
    2489     sigCmp = p_LmCmp(pSigMult,sSigMult,currRing);
     2486  {
     2487    if(pSigMult == NULL)
     2488    {
     2489      if(sSigMult == NULL)
     2490        sigCmp = 0;
     2491      else
     2492        sigCmp = -1;
     2493    }
     2494    else
     2495      sigCmp = 1;
     2496  }
    24902497//#if 1
    24912498#if DEBUGF5
    … …  
    24972504  if(rField_is_Ring(currRing))
    24982505  {
    2499     //I have to test it not in absolute value
    25002506    if(sigCmp == 0)
    25012507    {
    … …  
    25422548      }
    25432549    }
    2544     if(p_LmCmp(pSigMult,sSigMult,currRing) == 0)
     2550    if(pSigMult != NULL && sSigMult != NULL && p_LmCmp(pSigMult,sSigMult,currRing) == 0)
    25452551    {
    25462552      //Same lm, have to substract
    … …  
    26632669  // store from which element this pair comes from for further tests
    26642670  //Lp.from = strat->sl+1;
    2665   #ifdef HAVE_RINGS
    26662671  if(rField_is_Ring(currRing))
    26672672  {
    … …  
    26742679  }
    26752680  else
    2676   #endif
    26772681  {
    26782682    if(sigCmp==currRing->OrdSgn)
    … …  
    27482752        (!rIsPluralRing(currRing))
    27492753//      ||  (rIsPluralRing(currRing) && (ncRingType(currRing) != nc_lie))
    2750       #ifdef HAVE_RINGS
    27512754      && !rField_is_Ring(currRing)
    2752       #endif
    27532755       )
    27542756    {
    … …  
    27712773    if (TEST_OPT_INTSTRATEGY)
    27722774    {
    2773       if (!rIsPluralRing(currRing)
    2774       #ifdef HAVE_RINGS
    2775       && !rField_is_Ring(currRing)
    2776       #endif
    2777       )
     2775      if (!rIsPluralRing(currRing) && !rField_is_Ring(currRing))
    27782776        nDelete(&(Lp.p->coef));
    27792777    }
    27802778    // Check for sigdrop
    2781     #ifdef HAVE_RINGS
    2782     if(rField_is_Ring(currRing) &&
    2783       pLtCmp(Lp.sig,pSig) == -1
    2784       )
     2779    if(rField_is_Ring(currRing) && pLtCmp(Lp.sig,pSig) == -1)
    27852780    {
    27862781      #if ADIDEBUG
    … …  
    28152810      }
    28162811    }
    2817     #endif
    28182812    #if ADIDEBUG
    28192813    printf("\nThis spair was added to B:\n");
    … …  
    44974491        }
    44984492#endif
    4499         enterL(&strat->L,&strat->Ll,&strat->Lmax,h,posx);
     4493  //pWrite(h);pWrite(hSig);pWrite(Lp.p);pWrite(Lp.sig);printf("\n------------------\n");getchar();
    45004494        enterL(&strat->L,&strat->Ll,&strat->Lmax,Lp,posx);
    45014495      }
    … …  
    45464540void superenterpairsSig (poly h,poly hSig,int hFrom,int k,int ecart,int pos,kStrategy strat, int atR)
    45474541{
    4548   assume (rField_is_Ring_Z(currRing));
     4542  assume (rField_is_Ring(currRing));
    45494543  // enter also zero divisor * poly, if this is non zero and of smaller degree
    45504544  #if ADIDEBUG
    … …  
    46254619  const int iCompH = pGetComp(h);
    46264620
    4627   #ifdef HAVE_RINGS
    46284621  if (rField_is_Ring(currRing))
    46294622  {
    … …  
    46414634  }
    46424635  else
    4643   #endif
    4644   for (j=0; j<=k; j++)
    4645   {
    4646     const int iCompSj = pGetComp(strat->S[j]);
    4647     if ((iCompH==iCompSj)
    4648         //|| (0==iCompH) // can only happen,if iCompSj==0
    4649         || (0==iCompSj))
    4650     {
    4651       enterOnePairSpecial(j,h,ecart,strat, atR);
     4636  {
     4637    for (j=0; j<=k; j++)
     4638    {
     4639      const int iCompSj = pGetComp(strat->S[j]);
     4640      if ((iCompH==iCompSj)
     4641          //|| (0==iCompH) // can only happen,if iCompSj==0
     4642          || (0==iCompSj))
     4643      {
     4644        enterOnePairSpecial(j,h,ecart,strat, atR);
     4645      }
    46524646    }
    46534647  }
    … …  
    67746768#endif
    67756769    if (p_LmShortDivisibleBy(strat->syz[k], strat->sevSyz[k], sig, not_sevSig, currRing)
    6776     #ifdef HAVE_RINGS
    67776770    && (!rField_is_Ring(currRing) ||
    6778     (n_DivBy(pGetCoeff(sig), pGetCoeff(strat->syz[k]),currRing) && pLtCmp(sig,strat->syz[k]) == 1))
    6779     #endif
    6780     )
     6771    (n_DivBy(pGetCoeff(sig), pGetCoeff(strat->syz[k]),currRing) && pLtCmp(sig,strat->syz[k]) == 1)))
    67816772    {
    67826773//#if 1
    … …  
    68026793{
    68036794//#if 1
     6795  if(sig == NULL)
     6796    return FALSE;
    68046797#ifdef DEBUGF5
    68056798  Print("--- syzygy criterion checks:  ");
    … …  
    68326825#endif
    68336826      if (p_LmShortDivisibleBy(strat->syz[k], strat->sevSyz[k], sig, not_sevSig, currRing)
    6834       #ifdef HAVE_RINGS
    68356827      && (!rField_is_Ring(currRing) ||
    6836       (n_DivBy(pGetCoeff(sig), pGetCoeff(strat->syz[k]),currRing) && pLtCmp(sig,strat->syz[k]) == 1))
    6837     #endif     
    6838       )
     6828      (n_DivBy(pGetCoeff(sig), pGetCoeff(strat->syz[k]),currRing) && pLtCmp(sig,strat->syz[k]) == 1)))
    68396829      {
    68406830        #if ADIDEBUG
    … …  
    68716861#endif
    68726862    if (p_LmShortDivisibleBy(strat->sig[k], strat->sevSig[k], sig, not_sevSig, currRing)
    6873     #ifdef HAVE_RINGS
    6874     && (!rField_is_Ring(currRing) || (n_DivBy(pGetCoeff(sig),pGetCoeff(strat->sig[k]),currRing)  && pLmCmp(sig,strat->sig[k]) == 1 ))
    6875     #endif
    6876     )
     6863    && (!rField_is_Ring(currRing) || (n_DivBy(pGetCoeff(sig),pGetCoeff(strat->sig[k]),currRing)  && pLmCmp(sig,strat->sig[k]) == 1 )))
    68776864    {
    68786865//#if 1
    … …  
    69266913  {
    69276914    if (p_LmShortDivisibleBy(strat->sig[ii], strat->sevSig[ii], strat->P.sig, ~strat->P.sevSig, currRing)
    6928     #ifdef HAVE_RINGS
    6929     && (!(rField_is_Ring(currRing)) || n_DivBy(pGetCoeff(strat->P.sig),pGetCoeff(strat->sig[ii]),currRing))
    6930     #endif
    6931     )
     6915    && (!(rField_is_Ring(currRing)) || n_DivBy(pGetCoeff(strat->P.sig),pGetCoeff(strat->sig[ii]),currRing)))
    69326916    {
    69336917      p_ExpVectorSum(p1,strat->P.sig,strat->S[ii],currRing);
    … …  
    69576941BOOLEAN arriRewCriterionPre(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int /*start=0*/)
    69586942{
    6959   #ifdef HAVE_RINGS
    69606943  //Over Rings, there are still some changes to do: considering coeffs
    69616944  if(rField_is_Ring(currRing))
    69626945    return FALSE;
    6963   #endif
    69646946  int found = -1;
    69656947  for (int i=strat->Bl; i>-1; i--) {
    69666948    if (pLmEqual(strat->B[i].sig,sig)
    6967     #ifdef HAVE_RINGS
    69686949    && (rField_is_Ring(currRing) && n_Equal(pGetCoeff(strat->B[i].sig),pGetCoeff(sig),currRing))
    6969     #endif
    69706950    )
    69716951    {
    … …  
    79897969        {
    79907970          Q.sig          = pOne();
    7991           #ifdef HAVE_RINGS
    79927971          if(rField_is_Ring(currRing))
    79937972            p_SetCoeff(Q.sig,nCopy(p_GetCoeff(strat->S[k],currRing)),currRing);
    7994           #endif
    79957973          p_ExpVectorCopy(Q.sig,strat->S[k],currRing);
    79967974          p_SetCompP (Q.sig, comp, currRing);
    79977975          poly q          = p_One(currRing);
    7998           #ifdef HAVE_RINGS
    79997976          if(rField_is_Ring(currRing))
    80007977            p_SetCoeff(q,nCopy(p_GetCoeff(strat->S[i],currRing)),currRing);
    8001           #endif
    80027978          p_ExpVectorCopy(q,strat->S[i],currRing);
    80037979          q               = p_Neg (q, currRing);
    … …  
    80378013    {
    80388014      Q.sig          = pOne();
    8039       #ifdef HAVE_RINGS
    80408015      if(rField_is_Ring(currRing))
    80418016        p_SetCoeff(Q.sig,nCopy(p_GetCoeff(strat->S[k],currRing)),currRing);
    8042       #endif
    80438017      p_ExpVectorCopy(Q.sig,strat->S[k],currRing);
    80448018      p_SetCompP (Q.sig, comp, currRing);
    80458019      poly q          = p_One(currRing);
    8046       #ifdef HAVE_RINGS
    80478020      if(rField_is_Ring(currRing))
    80488021        p_SetCoeff(q,nCopy(p_GetCoeff(strat->L[strat->Ll].p,currRing)),currRing);
    8049       #endif
    80508022      p_ExpVectorCopy(q,strat->L[strat->Ll].p,currRing);
    80518023      q               = p_Neg (q, currRing);
    … …  
    1067910651        }
    1068010652      }
     10653      if(p == NULL)
     10654        return;
    1068110655      pp = pNext(p);
    1068210656      while(pp != NULL)
Note: See TracChangeset for help on using the changeset viewer.