Changeset 094031 in git


Ignore:
Timestamp:
May 11, 2016, 9:27:07 AM (8 years ago)
Author:
Adi Popescu <adi_popescum@…>
Branches:
(u'spielwiese', '82fc009ea2b0098c1a4896c841bb70860976bdfc')
Children:
ae57df01d23de4585edc0ab0e326957b7c5d6713
Parents:
a94fcf8caf88c19db9ef8352748fc35986436105
Message:
first version that seems to work
trying to optimize it now
Files:
139 added
8 edited

Legend:

Unmodified
Added
Removed
  • kernel/GBEngine/kspoly.cc

    ra94fcf8 r094031  
    2222#include <kernel/polys.h>
    2323#endif
     24
     25#define ADIDEBUG 0
    2426
    2527#ifdef KDEBUG
     
    180182                 kStrategy strat)
    181183{
     184#if ADIDEBUG
     185printf("\nksReducePolySig\n");
     186pWrite(PR->p);pWrite(PR->sig);
     187pWrite(PW->p);pWrite(PW->sig);
     188#endif
    182189#ifdef KDEBUG
    183190  red_count++;
     
    235242#endif
    236243    p_ExpVectorAddSub(sigMult,PR->GetLmCurrRing(),PW->GetLmCurrRing(),currRing);
     244    //I have also to set the leading coeficient for sigMult (in the case of rings)
     245    #ifdef HAVE_RINGS
     246    if(rField_is_Ring(currRing))
     247    {
     248      pSetCoeff(sigMult,nMult(nDiv(pGetCoeff(PR->p),pGetCoeff(PW->p)), pGetCoeff(sigMult)));
     249    }
     250    #endif
    237251//#if 1
    238252#ifdef DEBUGF5
     
    244258    printf("--------------\n");
    245259#endif
    246     int sigSafe = p_LmCmp(PR->sig,sigMult,currRing);
     260    int sigSafe;
     261    #ifdef HAVE_RINGS
     262    if(rField_is_Ring(currRing))
     263      sigSafe = p_LtCmp(PR->sig,sigMult,currRing);
     264    else
     265    #endif
     266      sigSafe = p_LmCmp(PR->sig,sigMult,currRing);
    247267    // now we can delete the copied polynomial data used for checking for
    248268    // sig-safeness of the reduction step
     
    252272
    253273#endif
     274    #ifdef HAVE_RINGS
     275    if(rField_is_Ring(currRing))
     276    {
     277      // Set the sig
     278      if(pLmCmp(PR->sig, sigMult) == 0)
     279      {
     280        //The sigs have the same lm, have to substract
     281        PR->sig = pSub(PR->sig, pCopy(sigMult));
     282        //It may happen that now the signature is 0 (drop)
     283        if(PR->sig == NULL)
     284        {
     285          #if ADIDEBUG
     286          printf("\nPossible sigdrop in ksreducepolysig (lost signature)\n");
     287          #endif
     288          strat->sigdrop=TRUE;
     289        }
     290      }
     291      else
     292      {
     293        if(sigSafe == -1)
     294        {
     295          p_Delete(&PR->sig,currRing);
     296          PR->sig = pNeg(pCopy(sigMult));
     297        }
     298      }
     299    }
     300    #endif
    254301    //pDelete(&f1);
    255302    pDelete(&sigMult);
    256303    // go on with the computations only if the signature of p2 is greater than the
    257304    // signature of fm*p1
    258     if(sigSafe != 1)
     305    if(sigSafe != 1 && !rField_is_Ring(currRing))
    259306    {
    260307      PR->is_redundant = TRUE;
     
    361408  }
    362409#endif
    363 
    364410#if defined(KDEBUG) && defined(TEST_OPT_DEBUG_RED)
    365411  if (TEST_OPT_DEBUG)
  • kernel/GBEngine/kstd1.cc

    ra94fcf8 r094031  
    25032503#ifdef KDEBUG
    25042504  idTest(F);
    2505   idTest(Q);
     2505  if(Q != NULL)
     2506    idTest(Q);
    25062507
    25072508#if MYTEST
     
    25262527  else
    25272528#endif
    2528 #ifdef HAVE_RINGS
    2529   if (rField_is_Ring(currRing))
    2530     r=bba(F,Q,NULL,hilb,strat);
    2531   else
    2532 #endif
    25332529  {
    25342530    if (rHasLocalOrMixedOrdering(currRing))
     
    25442540        r=sba(F,Q,*w,hilb,strat);
    25452541      else
     2542      {
     2543        //It is set to True, just to know that it is the first run
     2544        strat->sigdrop = FALSE;
     2545        strat->sbaEnterS = -1;
    25462546        r=sba(F,Q,NULL,hilb,strat);
     2547        #if ADIDEBUG
     2548        printf("\nSBA Run 1: %i elements (syzCrit = %i)\n",strat->sl+1,strat->nrsyzcrit);
     2549        //idPrint(r);
     2550        getchar();
     2551        #endif
     2552        int sbarun = 2;
     2553        while(strat->sigdrop)
     2554        {
     2555          r=sba(r,Q,NULL,hilb,strat);
     2556          #if ADIDEBUG
     2557          printf("SBA Run %i: %i elements (syzCrit = %i)\n",sbarun++,strat->sl+1,strat->nrsyzcrit);
     2558          //idPrint(r);
     2559          getchar();
     2560          #endif
     2561        }
     2562      }
    25472563    }
    25482564  }
     
    25582574//Print("%d reductions canceled \n",strat->cel);
    25592575  HCord=strat->HCord;
    2560   delete(strat);
     2576  //delete(strat);
    25612577  if ((delete_w)&&(w!=NULL)&&(*w!=NULL)) delete *w;
    25622578  return r;
  • kernel/GBEngine/kstd2.cc

    ra94fcf8 r094031  
    2222#define ADIDEBUG 0
    2323#define ADIDEBUG_COUNT 0
     24#define REV_BLOCK_SBA 0
     25#define SIG_DROP_FIRST 1
    2426
    2527#if MYTEST
     
    640642}
    641643
    642 KINLINE int ksReducePolyTailSig(LObject* PR, TObject* PW, LObject* Red)
     644KINLINE int ksReducePolyTailSig(LObject* PR, TObject* PW, LObject* Red, kStrategy strat)
    643645{
    644646  BOOLEAN ret;
     
    651653  pWrite(Red->GetLmCurrRing());
    652654  */
    653   ret = ksReducePolySig(Red, PW, 1, NULL, &coef);
    654 
     655  ret = ksReducePolySig(Red, PW, 1, NULL, &coef, strat);
    655656
    656657  if (!ret)
     
    678679int redSig (LObject* h,kStrategy strat)
    679680{
     681  #ifdef HAVE_RINGS
     682  poly beforeredsig;
     683  if(rField_is_Ring(currRing))
     684    beforeredsig = pCopy(h->sig);
     685  #endif
    680686  if (strat->tl<0) return 1;
    681687  //if (h->GetLmTailRing()==NULL) return 0; // HS: SHOULD NOT BE NEEDED!
    682688  //printf("FDEGS: %ld -- %ld\n",h->FDeg, h->pFDeg());
    683689  assume(h->FDeg == h->pFDeg());
     690  #if ADIDEBUG
     691  printf("\n--------------------------redSig-------------------------------------\n");
     692  printf("\nBefore redSig:\n");
     693  p_Write(h->p,strat->tailRing);pWrite(h->sig);
     694  #endif
    684695//#if 1
    685696#ifdef DEBUGF5
     
    711722    if (j < 0)
    712723    {
     724      #ifdef HAVE_RINGS
     725      if(rField_is_Ring(currRing))
     726      {
     727        //Check for sigdrop after reduction
     728        if(pLtCmp(beforeredsig,h->sig) == 1)
     729        {
     730          #if ADIDEBUG
     731          printf("\nSigDrop after reduce\n");pWrite(beforeredsig);pWrite(h->sig);
     732          #endif
     733          strat->sigdrop = TRUE;
     734          //Reduce it as much as you can
     735          int red_result = redRing(h,strat);
     736          if(red_result == 0)
     737          {
     738            //It reduced to 0, cancel the sigdrop
     739            #if ADIDEBUG
     740            printf("\nReduced to 0 via redRing. Cancel sigdrop\n");
     741            #endif
     742            strat->sigdrop = FALSE;
     743            p_Delete(&h->sig,currRing);h->sig = NULL;
     744          }
     745          else
     746          {
     747            #if ADIDEBUG
     748            printf("\nReduced to this via redRing.SIGDROP\n");pWrite(h->p);
     749            #endif
     750            //strat->enterS(*h, strat->sl+1, strat, strat->tl);
     751            return 0;
     752          }
     753        }
     754        p_Delete(&beforeredsig,currRing);
     755      }
     756      #endif
    713757      return 1;
    714758    }
     
    732776        break;
    733777      if ((strat->T[i].pLength < li)
    734          &&
    735           p_LmShortDivisibleBy(strat->T[i].GetLmTailRing(), strat->sevT[i],
     778         #ifdef HAVE_RINGS
     779         && (!rField_is_Ring(currRing) || n_DivBy(pGetCoeff(h_p),pGetCoeff(strat->T[i].p),currRing->cf))
     780         #endif
     781         && p_LmShortDivisibleBy(strat->T[i].GetLmTailRing(), strat->sevT[i],
    736782                               h_p, not_sev, strat->tailRing))
    737783      {
     
    772818    printf("INDEX OF REDUCER T: %d\n",ii);
    773819#endif
     820    #if ADIDEBUG
     821    printf("\nWe reduce it with:\n");p_Write(strat->T[ii].p,strat->tailRing);pWrite(strat->T[ii].sig);
     822    #endif
    774823    sigSafe = ksReducePolySig(h, &(strat->T[ii]), strat->S_2_R[ii], NULL, NULL, strat);
     824    #if ADIDEBUG
     825    printf("\nAfter small reduction:\n");pWrite(h->p);pWrite(h->sig);
     826    #endif
     827    #ifdef HAVE_RINGS
     828    if(rField_is_Ring(currRing) && h->p == NULL && h->sig == NULL)
     829    {
     830      //Trivial case catch
     831      strat->sigdrop = FALSE;
     832    }
     833    if(rField_is_Ring(currRing) && strat->sigdrop)
     834    {
     835      return 1;
     836    }
     837    #endif
    775838#if SBA_PRINT_REDUCTION_STEPS
    776839    if (sigSafe != 3)
     
    874937    loop
    875938    {
     939      #ifdef HAVE_RINGS
     940      if(rField_is_Ring(currRing) && strat->sigdrop)
     941        break;
     942      #endif
    876943      Ln.SetShortExpVector();
    877944      if (withT)
     
    904971      }
    905972      strat->redTailChange=TRUE;
    906       int ret = ksReducePolyTailSig(L, With, &Ln);
     973      #if ADIDEBUG
     974      printf("\nWill TAILreduce * with *:\n");pWrite(Ln.p);pWrite(Ln.sig);
     975      pWrite(With->p);pWrite(With->sig);pWrite(L->sig);
     976      #endif
     977      int ret = ksReducePolyTailSig(L, With, &Ln, strat);
     978      #ifdef HAVE_RINGS
     979      if(rField_is_Ring(currRing) && strat->sigdrop)
     980      {
     981        //Cannot break the loop here so easily
     982        break;
     983      }
     984      if(rField_is_Ring(currRing))
     985        L->sig = Ln.sig;
     986      //Because Ln.sig is set to L->sig, but in ksReducePolyTailSig -> ksReducePolySig
     987      // I delete it an then set Ln.sig. Hence L->sig is lost
     988      #endif
     989      #if ADIDEBUG
     990      printf("\nAfter small TAILreduce:\n");pWrite(Ln.p);pWrite(Ln.sig);pWrite(L->sig);
     991      #endif
    907992#if SBA_PRINT_REDUCTION_STEPS
    908993      if (ret != 3)
     
    9351020    L->pLength++;
    9361021  }
    937 
    9381022  all_done:
    9391023  Ln.Delete();
     
    15601644    }
    15611645    #endif
    1562     getchar();
     1646    //getchar();
    15631647    #endif
    15641648    #ifdef KDEBUG
     
    19081992  sba_interreduction_operations = 0;
    19091993#endif
    1910 
     1994 
    19111995  ideal F1 = F0;
    19121996  ring sRing, currRingOld;
     
    19232007  // sort ideal F
    19242008  ideal F       = idInit(IDELEMS(F1),F1->rank);
    1925   intvec *sort  = idSort(F1);
    1926   for (int i=0; i<sort->length();++i)
    1927     F->m[i] = F1->m[(*sort)[i]-1];
     2009  #if REV_BLOCK_SBA || SIG_DROP_FIRST
     2010  //#ifdef HAVE_RINGS
     2011  if(rField_is_Ring(currRing) && strat->sigdrop)
     2012  {
     2013    #if REV_BLOCK_SBA
     2014    for (int i=0; i<IDELEMS(F1);++i)
     2015      F->m[i] = F1->m[i];
     2016    #else
     2017    //Now I put the element on pos 0 already with enterS
     2018    #if 0
     2019    for (int i=IDELEMS(F1)-1; i>0;i--)
     2020      F->m[i] = F1->m[i-1];
     2021    F->m[0] = F1->m[IDELEMS(F1)-1];
     2022    #else
     2023    for (int i=0; i<IDELEMS(F1);++i)
     2024      F->m[i] = F1->m[i];
     2025    //Put the SigDrop element on the correct position (think of sbaEnterS)
     2026    if(strat->sbaEnterS >= 0)
     2027    {
     2028      poly dummy;
     2029      dummy = pCopy(F->m[0]); //the sigdrop element
     2030      for(int i = 0;i<strat->sbaEnterS;i++)
     2031        F->m[i] = F->m[i+1];
     2032      F->m[strat->sbaEnterS] = dummy;
     2033    }
     2034    #endif
     2035    #endif
     2036  }
     2037  else
     2038  #endif
     2039  {
     2040    intvec *sort  = idSort(F1);
     2041    for (int i=0; i<sort->length();++i)
     2042      F->m[i] = F1->m[(*sort)[i]-1];
     2043  }
     2044  #ifdef HAVE_RINGS
     2045  if(rField_is_Ring(currRing))
     2046    strat->sigdrop = FALSE;
     2047  strat->nrsyzcrit = 0;
     2048  #endif
    19282049#if SBA_INTERRED_START
    19292050  F = kInterRed(F,NULL);
     
    19412062  BOOLEAN withT     = TRUE;
    19422063  strat->max_lower_index = 0;
    1943 
    19442064  //initBuchMoraCrit(strat); /*set Gebauer, honey, sugarCrit*/
    19452065  initSbaCrit(strat); /*set Gebauer, honey, sugarCrit*/
     
    19532073  srmax = strat->sl;
    19542074  reduc = olddeg = lrmax = 0;
    1955 
    19562075#ifndef NO_BUCKETS
    19572076  if (!TEST_OPT_NOT_BUCKETS)
     
    19642083
    19652084  // strat->posInT = posInT_pLength;
    1966   kTest_TS(strat);
    1967 
     2085 
    19682086#ifdef KDEBUG
    19692087#if MYTEST
     
    19892107  }
    19902108
    1991 
     2109  #if 1
     2110  if(rField_is_Ring(currRing) && strat->sbaEnterS >= 0)
     2111  {
     2112    for(int i = 0;i<strat->sbaEnterS;i++)
     2113    {
     2114      //Update: now the element is at the corect place
     2115      //i+1 because on the 0 position is the sigdrop element
     2116      enterT(strat->L[strat->Ll-(i)],strat);
     2117      strat->enterS(strat->L[strat->Ll-(i)], strat->sl+1, strat, strat->tl);
     2118    }
     2119    strat->Ll = strat->Ll - strat->sbaEnterS;
     2120    strat->sbaEnterS = -1;
     2121  }
     2122  #endif
     2123  kTest_TS(strat);
    19922124#ifdef KDEBUG
    19932125  //kDebugPrint(strat);
     
    19962128  while (strat->Ll >= 0)
    19972129  {
     2130    #if ADIDEBUG
     2131    printf("\n      ------------------------NEW LOOP\n");
     2132    printf("\nShdl = \n");
     2133    #if 0
     2134    idPrint(strat->Shdl);
     2135    #else
     2136    for(int ii = 0; ii<=strat->sl;ii++)
     2137    {
     2138      printf("\nS[%i]:  ",ii);p_Write(strat->S[ii],strat->tailRing);
     2139      printf("sig:   ");pWrite(strat->sig[ii]);
     2140    }
     2141    #endif
     2142    #if 0
     2143    for(int iii = 0; iii< strat->syzl; iii++)
     2144    {
     2145        printf("\nsyz[%i]:\n",iii);
     2146        p_Write(strat->syz[iii], currRing);
     2147    }
     2148    #endif
     2149    #if 0
     2150    for(int iii = 0; iii<= strat->tl; iii++)
     2151    {
     2152        printf("\nT[%i]:\n",iii);
     2153        p_Write(strat->T[iii].p, currRing);
     2154    }
     2155    #endif
     2156    printf("\n   list   L\n");
     2157    int iii;
     2158    #if 1
     2159    for(iii = 0; iii<= strat->Ll; iii++)
     2160    {
     2161        printf("\nL[%i]:\n",iii);
     2162        p_Write(strat->L[iii].p, currRing);
     2163        p_Write(strat->L[iii].p1, currRing);
     2164        p_Write(strat->L[iii].p2, currRing);
     2165        p_Write(strat->L[iii].sig, currRing);
     2166    }
     2167    #else
     2168    {
     2169        printf("L[%i]:",strat->Ll);
     2170        p_Write(strat->L[strat->Ll].p, strat->tailRing);
     2171        p_Write(strat->L[strat->Ll].p1, strat->tailRing);
     2172        p_Write(strat->L[strat->Ll].p2, strat->tailRing);
     2173        p_Write(strat->L[strat->Ll].sig, strat->tailRing);
     2174    }
     2175    #endif
     2176    //getchar();
     2177    #endif
    19982178    if (strat->Ll > lrmax) lrmax =strat->Ll;/*stat.*/
    19992179    #ifdef KDEBUG
     
    20312211      // initialize new syzygy rules for the next iteration step
    20322212      initSyzRules(strat);
    2033 
    20342213    }
    20352214    /*********************************************************************
     
    20402219    strat->P = strat->L[strat->Ll];
    20412220    strat->Ll--;
     2221   
     2222    #ifdef HAVE_RINGS
     2223    if(rField_is_Ring(currRing))
     2224      strat->sbaEnterS = pGetComp(strat->P.sig) - 1;
     2225    #endif
     2226   
     2227    #if ADIDEBUG
     2228    printf("\n-------------------------\nThis is the current element P\n");
     2229    pWrite(strat->P.p);
     2230    pWrite(strat->P.p1);
     2231    pWrite(strat->P.p2);
     2232    pWrite(strat->P.sig);
     2233    #endif
    20422234    /* reduction of the element chosen from L */
    20432235
     
    21312323      red_result = 2;
    21322324    }
     2325    #ifdef HAVE_RINGS
     2326    if(rField_is_Ring(currRing))
     2327    {
     2328      strat->P.pLength = pLength(strat->P.p);
     2329      if(strat->P.sig != NULL)
     2330        strat->P.sevSig = pGetShortExpVector(strat->P.sig);
     2331      if(strat->P.p != NULL)
     2332        strat->P.sev = pGetShortExpVector(strat->P.p);
     2333    }
     2334    #endif
     2335    #if ADIDEBUG
     2336    printf("\nAfter reduce (redresult=%i): \n",red_result);pWrite(strat->P.p);pWrite(strat->P.sig);
     2337    #endif
     2338    #ifdef HAVE_RINGS
     2339    //sigdrop case
     2340    if(rField_is_Ring(currRing) && strat->sigdrop)
     2341    {
     2342      //First reduce it as much as one can
     2343      #if ADIDEBUG
     2344      printf("\nSigdrop in the reduce. Trying redring\n");
     2345      #endif
     2346      red_result = redRing(&strat->P,strat);
     2347      if(red_result == 0)
     2348      {
     2349        #if ADIDEBUG
     2350        printf("\nSigdrop cancelled since redRing reduced to 0\n");
     2351        #endif
     2352        strat->sigdrop = FALSE;
     2353      }
     2354      else
     2355      {
     2356        #if ADIDEBUG
     2357        printf("\nStill Sigdrop - redRing reduced to:\n");pWrite(strat->P.p);
     2358        #endif
     2359        strat->enterS(strat->P, 0, strat, strat->tl);
     2360        break;
     2361      }
     2362    }
     2363    #endif
     2364   
    21332365    if (errorreported)  break;
    21342366
     
    21482380        if (!kStratChangeTailRing(strat)) { Werror("OVERFLOW.."); break;}
    21492381    }
    2150 
    21512382    // reduction to non-zero new poly
    21522383    if (red_result == 1)
     
    21702401      // the one with highest signature
    21712402      int pos = strat->sl+1;
    2172 
    21732403#ifdef KDEBUG
    21742404#if MYTEST
     
    21802410      // in the ring case we cannot expect LC(f) = 1,
    21812411      // therefore we call pContent instead of pNorm
     2412      #ifdef HAVE_RINGS
     2413      poly beforetailred;
     2414      if(rField_is_Ring(currRing))
     2415        beforetailred = pCopy(strat->P.sig);
     2416      #endif
    21822417#if SBA_TAIL_RED
    2183       if (strat->sbaOrder != 2) {
    2184         if ((TEST_OPT_INTSTRATEGY) || (rField_is_Ring(currRing)))
    2185         {
    2186           strat->P.pCleardenom();
    2187           if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
     2418#ifdef HAVE_RINGS
     2419      if(rField_is_Ring(currRing))
     2420      { 
     2421        if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
     2422          strat->P.p = redtailSba(&(strat->P),pos-1,strat, withT);
     2423      }
     2424      else
     2425#endif
     2426      {
     2427        if (strat->sbaOrder != 2) {
     2428          if (TEST_OPT_INTSTRATEGY)
    21882429          {
    2189             strat->P.p = redtailSba(&(strat->P),pos-1,strat, withT);
    21902430            strat->P.pCleardenom();
     2431            if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
     2432            {
     2433              strat->P.p = redtailSba(&(strat->P),pos-1,strat, withT);
     2434              strat->P.pCleardenom();
     2435            }
    21912436          }
     2437          else
     2438          {
     2439            strat->P.pNorm();
     2440            if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
     2441              strat->P.p = redtailSba(&(strat->P),pos-1,strat, withT);
     2442          }
     2443        }
     2444      }
     2445      // It may happen that we have lost the sig in redtailsba
     2446      // It cannot reduce to 0 since here we are doing just tail reduction.
     2447      // Best case scenerio: remains the leading term
     2448      #ifdef HAVE_RINGS
     2449      if(rField_is_Ring(currRing) && strat->sigdrop)     
     2450      {
     2451        #if ADIDEBUG
     2452        printf("\n Still sigdrop after redtailSba - it reduced to \n");pWrite(strat->P.p);
     2453        #endif
     2454        strat->enterS(strat->P, 0, strat, strat->tl);
     2455        break;
     2456      }
     2457      #endif
     2458#endif
     2459    #ifdef HAVE_RINGS
     2460    if(rField_is_Ring(currRing))
     2461    {
     2462      if(strat->P.sig == NULL || pLtCmp(beforetailred,strat->P.sig) == 1)
     2463      {
     2464        #if ADIDEBUG
     2465        printf("\nSigDrop after TAILred\n");pWrite(beforetailred);pWrite(strat->P.sig);
     2466        #endif
     2467        strat->sigdrop = TRUE;
     2468        //Reduce it as much as you can
     2469        red_result = redRing(&strat->P,strat);
     2470        if(red_result == 0)
     2471        {
     2472          //It reduced to 0, cancel the sigdrop
     2473          #if ADIDEBUG
     2474          printf("\nReduced to 0 via redRing. Cancel sigdrop\n");
     2475          #endif
     2476          strat->sigdrop = FALSE;
     2477          p_Delete(&strat->P.sig,currRing);strat->P.sig = NULL;
    21922478        }
    21932479        else
    21942480        {
    2195           strat->P.pNorm();
    2196           if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
    2197             strat->P.p = redtailSba(&(strat->P),pos-1,strat, withT);
    2198         }
    2199       }
    2200 #endif
     2481          #if ADIDEBUG
     2482          printf("\nReduced to this via redRing.SIGDROP\n");pWrite(strat->P.p);
     2483          #endif
     2484          strat->enterS(strat->P, 0, strat, strat->tl);
     2485          break;
     2486        }
     2487      }
     2488      p_Delete(&beforetailred,currRing);
     2489      if(!nGreaterZero(pGetCoeff(strat->P.p)))
     2490      {
     2491        strat->P.p = pNeg(strat->P.p);
     2492        strat->P.sig = pNeg(strat->P.sig);
     2493      }
     2494    }
     2495    #endif
    22012496
    22022497    // remove sigsafe label since it is no longer valid for the next element to
     
    22592554#ifdef HAVE_RINGS
    22602555      if (rField_is_Ring(currRing))
    2261         superenterpairs(strat->P.p,strat->sl,strat->P.ecart,pos,strat, strat->tl);
     2556        superenterpairsSig(strat->P.p,strat->P.sig,strat->sl+1,strat->sl,strat->P.ecart,pos,strat, strat->tl);
    22622557      else
    22632558#endif
    22642559        enterpairsSig(strat->P.p,strat->P.sig,strat->sl+1,strat->sl,strat->P.ecart,pos,strat, strat->tl);
     2560      #if ADIDEBUG
     2561        printf("\nThis element is added to S\n");
     2562        p_Write(strat->P.p, strat->tailRing);p_Write(strat->P.p1, strat->tailRing);p_Write(strat->P.p2, strat->tailRing);pWrite(strat->P.sig);
     2563        #endif
    22652564      // posInS only depends on the leading term
     2565     
     2566      #ifdef HAVE_RINGS
     2567      if(rField_is_Ring(currRing) && strat->sigdrop)
     2568        break;
     2569      #endif
     2570      strat->P.sevSig = p_GetShortExpVector(strat->P.sig,currRing);
    22662571      strat->enterS(strat->P, pos, strat, strat->tl);
     2572     
    22672573      if(strat->sbaOrder != 1)
    22682574      {
     
    24322738        zeroreductions++;
    24332739#endif
    2434         int pos = posInSyz(strat, strat->P.sig);
    2435         enterSyz(strat->P, strat, pos);
    2436 //#if 1
    2437 #ifdef DEBUGF5
    2438         Print("ADDING STUFF TO SYZ :  ");
    2439         //pWrite(strat->P.p);
    2440         pWrite(strat->P.sig);
    2441 #endif
     2740        #ifdef HAVE_RINGS
     2741        if(rField_is_Ring(currRing) && strat->P.p == NULL && strat->P.sig == NULL)
     2742        {
     2743          //Catch the case when p = 0, sig = 0
     2744        }
     2745        else
     2746        #endif
     2747        {
     2748          int pos = posInSyz(strat, strat->P.sig);
     2749          enterSyz(strat->P, strat, pos);
     2750  //#if 1
     2751  #ifdef DEBUGF5
     2752          Print("ADDING STUFF TO SYZ :  ");
     2753          //pWrite(strat->P.p);
     2754          pWrite(strat->P.sig);
     2755  #endif
     2756        }
    24422757      }
    24432758      if (strat->P.p1 == NULL && strat->minim > 0)
     
    24522767    kTest_TS(strat);
    24532768  }
     2769  #if 0
     2770  if(strat->sigdrop)
     2771    printf("\nSigDrop!\n");
     2772  else
     2773    printf("\nEnded with no SigDrop\n");
     2774  #endif
     2775// Clean strat->P for the next sba call
     2776#ifdef HAVE_RINGS
     2777  if(rField_is_Ring(currRing) && strat->sigdrop)
     2778  {
     2779    //This is used to know how many elements can we directly add to S in the next run
     2780    if(strat->P.sig != NULL)
     2781      strat->sbaEnterS = pGetComp(strat->P.sig)-1;
     2782    //else we already set it at the beggining of the loop
     2783    #ifdef KDEBUG
     2784    memset(&(strat->P), 0, sizeof(strat->P));
     2785    #endif /* KDEBUG */
     2786  }
     2787#endif
    24542788#ifdef KDEBUG
    24552789#if MYTEST
    2456   PrintS("bba finish GB: currRing: "); rWrite(currRing);
     2790  PrintS("sba finish GB: currRing: "); rWrite(currRing);
    24572791#endif /* MYTEST */
    24582792  if (TEST_OPT_DEBUG) messageSets(strat);
     
    24802814    }
    24812815  }
    2482 
    24832816  /* complete reduction of the standard basis--------- */
    24842817  if (TEST_OPT_REDSB)
     
    25042837  size_syz = strat->syzl;
    25052838#endif
    2506   exitSba(strat);
    25072839//  if (TEST_OPT_WEIGHTM)
    25082840//  {
     
    25162848  if (TEST_OPT_PROT) messageStat(hilbcount,strat);
    25172849  if (Q!=NULL) updateResult(strat->Shdl,Q,strat);
    2518 
    25192850#ifdef KDEBUG
    25202851#if MYTEST
    2521   PrintS("bba_end: currRing: "); rWrite(currRing);
     2852  PrintS("sba_end: currRing: "); rWrite(currRing);
    25222853#endif /* MYTEST */
    25232854#endif /* KDEBUG */
     
    25252856  size_g_non_red  = IDELEMS(strat->Shdl);
    25262857#endif
     2858  //This is again done better at the beginning of the next loop because else damage S
     2859  //Put the element that caused the sigdrop ast the beginning
     2860  #if 0
     2861  //#if SIG_DROP_FIRST
     2862  poly dummy;
     2863  dummy = pCopy(strat->Shdl->m[strat->sl]);
     2864  for(int k=strat->sl;k>=1;k--)
     2865  {
     2866    strat->Shdl->m[k] = strat->Shdl->m[k-1];
     2867    strat->sig[k] = strat->sig[k-1];
     2868  }
     2869  strat->Shdl->m[0] = dummy;
     2870  #endif
     2871  idTest(strat->Shdl);
     2872  // I have to add the initial input polynomials which where not used (p1 and p2 = NULL)
     2873  #ifdef HAVE_RINGS
     2874  int k;
     2875  if(rField_is_Ring(currRing))
     2876  {
     2877    //for(k = strat->sl;k>=0;k--)
     2878    //  {printf("\nS[%i] = %p\n",k,strat->Shdl->m[k]);pWrite(strat->Shdl->m[k]);}
     2879    k = strat->Ll;
     2880    #if 1
     2881    // 1 - adds just the unused ones, 0 - adds everthing
     2882    for(;k>=0 && (strat->L[k].p1 != NULL || strat->L[k].p2 != NULL);k--)
     2883    {
     2884      //printf("\nDeleted k = %i, %p\n",k,strat->L[k].p);pWrite(strat->L[k].p);pWrite(strat->L[k].p1);pWrite(strat->L[k].p2);
     2885      deleteInL(strat->L,&strat->Ll,k,strat);
     2886    }
     2887    #endif
     2888    //for(int kk = strat->sl;kk>=0;kk--)
     2889    //  {printf("\nS[%i] = %p\n",kk,strat->Shdl->m[kk]);pWrite(strat->Shdl->m[kk]);}
     2890    //idPrint(strat->Shdl);
     2891  idTest(strat->Shdl);
     2892    //printf("\nk = %i\n",k);
     2893    for(;k>=0 && strat->L[k].p1 == NULL && strat->L[k].p2 == NULL;k--)
     2894    {
     2895      //printf("\nAdded k = %i\n",k);
     2896      strat->enterS(strat->L[k], strat->sl+1, strat, strat->tl);
     2897      //printf("\nThis elements was added from L on pos %i\n",strat->sl);pWrite(strat->S[strat->sl]);pWrite(strat->sig[strat->sl]);
     2898    }
     2899  }
     2900  // Find the "sigdrop element" and put the same signature as the previous one - do we really need this?? - now i put it on the 0 position - no more comparing needed
     2901  #if 0
     2902  if(strat->sigdrop && rField_is_Ring(currRing))
     2903  {
     2904    for(k=strat->sl;k>=0;k--)
     2905    {
     2906      printf("\nsig[%i] = ",i);pWrite(strat->sig[k]);
     2907      if(strat->sig[k] == NULL)
     2908        strat->sig[k] = pCopy(strat->sig[k-1]);
     2909    }
     2910  }
     2911  #endif
     2912  #endif
     2913  //Never do this - you will damage S
     2914  //idSkipZeroes(strat->Shdl);
     2915  //idPrint(strat->Shdl);
     2916  idTest(strat->Shdl);
     2917  #if REV_BLOCK_SBA
     2918  #if ADIDEBUG
     2919  printf("\nSBA Endrun before block reverse sigdrop sorting: \n");
     2920  for(k = 0; k<=strat->sl; k++)
     2921  {
     2922    printf("[%i]:",k);pWrite(strat->Shdl->m[k]);
     2923    if(strat->sig[k]!= NULL)
     2924      {printf("       ");pWrite(strat->sig[k]);}
     2925    else
     2926      printf("        0\n");
     2927  }
     2928  #endif
     2929  //Reverse Blockwise Sorting of output needed for the Sig Drop Problem
     2930  #ifdef HAVE_RINGS
     2931  if(rField_is_Ring(currRing) && strat->sigdrop)
     2932  {
     2933    poly dummy;
     2934    int i,j;
     2935    for(i=0;i<=strat->sl;)
     2936    {
     2937      k = pGetComp(strat->sig[i]);
     2938      for(j = i; j<=strat->sl && strat->sig[j]!= NULL && pGetComp(strat->sig[j]) == k;++j)
     2939      {
     2940        //printf("\n%i is ok",j);
     2941      }
     2942      if(j == strat->sl && strat->sig[j] == NULL)
     2943        j++;
     2944      j--;
     2945      //printf("\ni = %i, j = %i\n",i,j);
     2946      //getchar();
     2947      for(k=0;k<(j-i)/2;k++)
     2948      {
     2949        //printf("\n%i <> %i\n",i+k,j-k);
     2950        dummy = pCopy(strat->Shdl->m[i+k]);
     2951        strat->Shdl->m[i+k] = strat->Shdl->m[j-k];
     2952        strat->Shdl->m[j-k] = pCopy(dummy);
     2953        p_Delete(&dummy, currRing);
     2954        if(strat->sig[i+k]!= NULL)
     2955          dummy = pCopy(strat->sig[i+k]);
     2956        else
     2957          dummy = NULL;
     2958        strat->sig[i+k] = strat->sig[j-k];
     2959        if(dummy!= NULL)
     2960        {
     2961          strat->sig[j-k] = pCopy(dummy);
     2962          p_Delete(&dummy, currRing);
     2963        }
     2964      }
     2965      i = j+1;
     2966    }
     2967  }
     2968  #endif
     2969  #if ADIDEBUG
     2970  printf("\nSBA Endrun after block reverse sigdrop sorting: \n");
     2971  for(k = 0; k<=strat->sl; k++)
     2972  {
     2973    printf("[%i]:",k);pWrite(strat->Shdl->m[k]);
     2974    if(strat->sig[k]!= NULL)
     2975      {printf("       ");pWrite(strat->sig[k]);}
     2976    else
     2977      printf("        0\n");
     2978  }
     2979  #endif
     2980  #endif
    25272981  if ((strat->sbaOrder == 1 || strat->sbaOrder == 3) && sRing!=currRingOld)
    25282982  {
     
    25302984    F0          = idrMoveR (F1, sRing, currRing);
    25312985    strat->Shdl = idrMoveR_NoSort (strat->Shdl, sRing, currRing);
     2986    rChangeCurrRing (sRing);
     2987    exitSba(strat);
     2988    rChangeCurrRing (currRingOld);
    25322989    rDelete (sRing);
    25332990  }
    2534   id_DelDiv(strat->Shdl, currRing);
     2991  #ifdef HAVE_RINGS
     2992  if(rField_is_Ring(currRing) && !strat->sigdrop)
     2993  #endif
     2994    id_DelDiv(strat->Shdl, currRing);
    25352995  idSkipZeroes(strat->Shdl);
    25362996  idTest(strat->Shdl);
  • kernel/GBEngine/kutil.cc

    ra94fcf8 r094031  
    513513     pGetShallowCopyDeleteProc(strat->tailRing, currRing) :
    514514     NULL);
    515 
    516515  for (j=0; j<=strat->tl; j++)
    517516  {
     
    534533        }
    535534        else
    536           pDelete(&p);
     535        {
     536          //pDelete(&p);
     537          p = NULL;
     538        }
    537539        break;
    538540      }
     
    821823{
    822824  int i;
    823 
    824825  // test P
    825826  kFalseReturn(kTest_L(&(strat->P), strat->tailRing,
     
    15241525  return TRUE;
    15251526}
     1527
     1528
     1529BOOLEAN enterOneStrongPolySig (int i,poly p,poly sig,int /*ecart*/, int /*isFromQ*/,kStrategy strat, int atR)
     1530{
     1531  number d, s, t;
     1532  assume(atR >= 0);
     1533  poly m1, m2, gcd,si;
     1534  assume(i<=strat->sl);
     1535  si = strat->S[i];
     1536  //printf("\n--------------------------------\n");
     1537  //pWrite(p);pWrite(si);
     1538  d = n_ExtGcd(pGetCoeff(p), pGetCoeff(si), &s, &t, currRing->cf);
     1539
     1540  if (nIsZero(s) || nIsZero(t))  // evtl. durch divBy tests ersetzen
     1541  {
     1542    nDelete(&d);
     1543    nDelete(&s);
     1544    nDelete(&t);
     1545    return FALSE;
     1546  }
     1547
     1548  k_GetStrongLeadTerms(p, si, currRing, m1, m2, gcd, strat->tailRing);
     1549  //p_Test(m1,strat->tailRing);
     1550  //p_Test(m2,strat->tailRing);
     1551  /*if(!enterTstrong)
     1552  {
     1553    while (! kCheckStrongCreation(atR, m1, i, m2, strat) )
     1554    {
     1555      memset(&(strat->P), 0, sizeof(strat->P));
     1556      kStratChangeTailRing(strat);
     1557      strat->P = *(strat->R[atR]);
     1558      p_LmFree(m1, strat->tailRing);
     1559      p_LmFree(m2, strat->tailRing);
     1560      p_LmFree(gcd, currRing);
     1561      k_GetStrongLeadTerms(p, si, currRing, m1, m2, gcd, strat->tailRing);
     1562    }
     1563  }*/
     1564  pSetCoeff0(m1, s);
     1565  pSetCoeff0(m2, t);
     1566  pSetCoeff0(gcd, d);
     1567  p_Test(m1,strat->tailRing);
     1568  p_Test(m2,strat->tailRing);
     1569  //printf("\n===================================\n");
     1570  //pWrite(m1);pWrite(m2);pWrite(gcd);
     1571#ifdef KDEBUG
     1572  if (TEST_OPT_DEBUG)
     1573  {
     1574    // Print("t = %d; s = %d; d = %d\n", nInt(t), nInt(s), nInt(d));
     1575    PrintS("m1 = ");
     1576    p_wrp(m1, strat->tailRing);
     1577    PrintS(" ; m2 = ");
     1578    p_wrp(m2, strat->tailRing);
     1579    PrintS(" ; gcd = ");
     1580    wrp(gcd);
     1581    PrintS("\n--- create strong gcd poly: ");
     1582    Print("\n p: %d", i);
     1583    wrp(p);
     1584    Print("\n strat->S[%d]: ", i);
     1585    wrp(si);
     1586    PrintS(" ---> ");
     1587  }
     1588#endif
     1589
     1590  pNext(gcd) = p_Add_q(pp_Mult_mm(pNext(p), m1, strat->tailRing), pp_Mult_mm(pNext(si), m2, strat->tailRing), strat->tailRing);
     1591 
     1592#ifdef KDEBUG
     1593  if (TEST_OPT_DEBUG)
     1594  {
     1595    wrp(gcd);
     1596    PrintLn();
     1597  }
     1598#endif
     1599
     1600  //Check and set the signatures
     1601  poly pSigMult = p_Copy(sig,currRing);
     1602  poly sSigMult = p_Copy(strat->sig[i],currRing);
     1603  pSigMult = p_Mult_mm(pSigMult,m1,currRing);
     1604  sSigMult = p_Mult_mm(sSigMult,m2,currRing);
     1605  p_LmDelete(m1, strat->tailRing);
     1606  p_LmDelete(m2, strat->tailRing);
     1607  poly pairsig;
     1608  if(pLmCmp(pSigMult,sSigMult) == 0)
     1609  {
     1610    //Same lm, have to add them
     1611    pairsig = p_Add_q(pSigMult,sSigMult,currRing);
     1612    //This might be zero
     1613  }
     1614  else
     1615  {
     1616    //Set the sig to either pSigMult or sSigMult
     1617    if(pLtCmp(pSigMult,sSigMult)==1)
     1618    {
     1619      pairsig = pSigMult;
     1620      pDelete(&sSigMult);
     1621    }
     1622    else
     1623    {
     1624      pairsig = sSigMult;
     1625      pDelete(&pSigMult);
     1626    }
     1627  }
     1628
     1629  LObject h;
     1630  h.p = gcd;
     1631  h.tailRing = strat->tailRing;
     1632  h.sig = pairsig;
     1633  int posx;
     1634  h.pCleardenom();
     1635  strat->initEcart(&h);
     1636  h.sev = pGetShortExpVector(h.p);
     1637  h.i_r1 = -1;h.i_r2 = -1;
     1638  if (currRing!=strat->tailRing)
     1639    h.t_p = k_LmInit_currRing_2_tailRing(h.p, strat->tailRing);
     1640  if(h.sig == NULL)
     1641    {
     1642      #if ADIDEBUG
     1643      printf("\nPossible sigdrop in enterpairSig (due to lost of sig)\n");
     1644      #endif
     1645      //sigdrop since we loose the signature
     1646      strat->sigdrop = TRUE;
     1647      //Try to reduce it as far as we can via redRing
     1648      int red_result = redRing(&h,strat);
     1649      #if ADIDEBUG
     1650      printf("\nAfter redRing reduce:\n");pWrite(h.p);
     1651      #endif
     1652      if(red_result == 0)
     1653      {
     1654        // Cancel the sigdrop
     1655        #if ADIDEBUG
     1656        printf("\nCancel the sigdrop. It reduced to 0\n");
     1657        #endif
     1658        p_Delete(&h.sig,currRing);h.sig = NULL;
     1659        strat->sigdrop = FALSE;
     1660        return FALSE;
     1661      }
     1662      else
     1663      {
     1664        #if ADIDEBUG
     1665        printf("\nSigdrop. end\n");
     1666        #endif
     1667        strat->enterS(strat->P,strat->sl+1,strat, strat->tl+1);
     1668        #if 1
     1669        strat->enterS(h,0,strat,strat->tl);
     1670        #endif
     1671        return FALSE;
     1672      }
     1673    }
     1674  if(!nGreaterZero(pGetCoeff(h.sig)))
     1675  {
     1676    h.sig = pNeg(h.sig);
     1677    h.p = pNeg(h.p);
     1678  }
     1679  #ifdef HAVE_RINGS
     1680 
     1681    if(rField_is_Ring(currRing) &&
     1682      pLtCmp(h.sig,sig) == -1
     1683      )
     1684    {
     1685      #if ADIDEBUG
     1686      printf("\nSigDrop in enteronestrongpolySig\n");
     1687      pWrite(h.sig);
     1688      pWrite(p);pWrite(sig);
     1689      pWrite(strat->S[i]);pWrite(strat->sig[i]);
     1690      #endif
     1691      strat->sigdrop = TRUE;
     1692      // Completely reduce it
     1693      int red_result = redRing(&h,strat);
     1694      if(red_result == 0)
     1695      {
     1696        // Reduced to 0
     1697        #if ADIDEBUG
     1698        printf("\nCancel the sigdrop after redRing (=0)\n");
     1699        #endif
     1700        strat->sigdrop = FALSE;
     1701        p_Delete(&h.sig,currRing);h.sig = NULL;
     1702        return FALSE;
     1703      }
     1704      else
     1705      {
     1706        #if ADIDEBUG
     1707        printf("\nAfter redRing still sigdrop:\n");pWrite(h.p);
     1708        #endif
     1709        strat->enterS(strat->P,strat->sl+1,strat, strat->tl+1);
     1710        // 0 - add just the original poly causing the sigdrop, 1 - add also this
     1711        #if 1
     1712        strat->enterS(h,0,strat, strat->tl+1);
     1713        #endif
     1714        return FALSE;
     1715      }
     1716    }
     1717    #endif
     1718  #if ADIDEBUG
     1719  printf("\nThis strong poly was added to L:\n");pWrite(h.p);pWrite(h.p1);pWrite(h.p2);pWrite(h.sig);
     1720  #endif
     1721  //Check for sigdrop
     1722  if(gcd != NULL && pLtCmp(sig,pairsig) > 0 && pLtCmp(strat->sig[i],pairsig) > 0)
     1723  {
     1724    #if ADIDEBUG
     1725    printf("\nSigDrop in strongpair\noriginals: ");pWrite(sig);pWrite(strat->sig[i]);
     1726    printf("\nnow: ");pWrite(pairsig);
     1727    #endif
     1728    strat->sigdrop = TRUE;
     1729    //Enter this element to S
     1730    strat->enterS(strat->P,strat->sl+1,strat, strat->tl+1);
     1731    strat->enterS(h,strat->sl+1,strat,strat->tl+1);
     1732  }
     1733  #if 1
     1734  h.p1 = p;h.p2 = strat->S[i];
     1735  #endif
     1736  if (atR >= 0)
     1737  {
     1738    h.i_r2 = strat->S_2_R[i];
     1739    h.i_r1 = atR;
     1740  }
     1741  else
     1742  {
     1743    h.i_r1 = -1;
     1744    h.i_r2 = -1;
     1745  }
     1746  if (strat->Ll==-1)
     1747    posx =0;
     1748  else
     1749    posx = strat->posInLSba(strat->L,strat->Ll,&h,strat);
     1750  enterL(&strat->L,&strat->Ll,&strat->Lmax,h,posx);
     1751  return TRUE;
     1752}
    15261753#endif
    15271754
     
    20542281#endif
    20552282{
     2283  #if ADIDEBUG
     2284  printf("\nTrying to add p and S[%i]\n",i);
     2285  pWrite(p);pWrite(pSig);
     2286  pWrite(strat->S[i]);pWrite(strat->sig[i]);
     2287  #endif
    20562288  assume(i<=strat->sl);
    2057 
    20582289  int      l;
    20592290  poly m1 = NULL,m2 = NULL; // we need the multipliers for the s-polynomial to compute
     
    20802311
    20812312  // set coeffs of multipliers m1 and m2
    2082   pSetCoeff0(m1, nInit(1));
    2083   pSetCoeff0(m2, nInit(1));
    2084 //#if 1
     2313  #ifdef HAVE_RINGS
     2314  if(rField_is_Ring(currRing))
     2315  {
     2316    number s = nCopy(pGetCoeff(strat->S[i]));
     2317    number t = nCopy(pGetCoeff(p));
     2318    pSetCoeff0(Lp.lcm, n_Lcm(s, t, currRing->cf));
     2319    ksCheckCoeff(&s, &t, currRing->cf);
     2320    pSetCoeff0(m1,s);
     2321    pSetCoeff0(m2,t);
     2322    #if ADIDEBUG
     2323    printf("\nIn Spoly: m1, m2 :\n");pWrite(m1);pWrite(m2);
     2324    #endif
     2325  }
     2326  else
     2327  #endif
     2328  {
     2329    pSetCoeff0(m1, nInit(1));
     2330    pSetCoeff0(m2, nInit(1));
     2331  }
    20852332#ifdef DEBUGF5
    20862333  Print("P1  ");
     
    20932340  pWrite(m2);
    20942341#endif
     2342 
    20952343  // get multiplied signatures for testing
    2096   pSigMult = currRing->p_Procs->pp_Mult_mm(pSigMult,m1,currRing);
     2344  pSigMult = pp_Mult_mm(pSigMult,m1,currRing);
    20972345  pSigMultNegSev = ~p_GetShortExpVector(pSigMult,currRing);
    2098   sSigMult = currRing->p_Procs->pp_Mult_mm(sSigMult,m2,currRing);
     2346  sSigMult = pp_Mult_mm(sSigMult,m2,currRing);
    20992347  sSigMultNegSev = ~p_GetShortExpVector(sSigMult,currRing);
    2100 
    21012348//#if 1
    21022349#ifdef DEBUGF5
     
    21072354  Lp.checked  = 0;
    21082355#endif
    2109   int sigCmp = p_LmCmp(pSigMult,sSigMult,currRing);
     2356  int sigCmp;
     2357  #ifdef HAVE_RINGS
     2358  if(rField_is_Ring(currRing))
     2359    sigCmp = p_LtCmp(pSigMult,sSigMult,currRing);
     2360  else
     2361  #endif
     2362    sigCmp = p_LmCmp(pSigMult,sSigMult,currRing);
    21102363//#if 1
    21112364#if DEBUGF5
     
    21142367  pWrite(sSigMult);
    21152368#endif
     2369  //In the ring case we already build the sig
     2370  #ifdef HAVE_RINGS
     2371  if(rField_is_Ring(currRing))
     2372  {
     2373    if(sigCmp == 0)
     2374    {
     2375      #if ADIDEBUG
     2376      printf("\nPossible sigdrop in enterpairSig (due to lost of sig)\n");
     2377      #endif
     2378      //sigdrop since we loose the signature
     2379      strat->sigdrop = TRUE;
     2380      //Try to reduce it as far as we can via redRing
     2381      Lp.p = pCopy(p);
     2382      int red_result = redRing(&Lp,strat);
     2383      #if ADIDEBUG
     2384      printf("\nAfter redRing reduce:\n");pWrite(Lp.p);
     2385      #endif
     2386      if(red_result == 0)
     2387      {
     2388        // Cancel the sigdrop
     2389        #if ADIDEBUG
     2390        printf("\nCancel the sigdrop. It reduced to 0\n");
     2391        #endif
     2392        p_Delete(&Lp.sig,currRing);Lp.sig = NULL;
     2393        strat->sigdrop = FALSE;
     2394        return;
     2395      }
     2396      else
     2397      {
     2398        #if ADIDEBUG
     2399        printf("\nSigdrop. end\n");
     2400        #endif
     2401        strat->enterS(strat->P,strat->sl+1,strat, strat->tl+1);
     2402        #if 1
     2403        strat->enterS(Lp,0,strat,strat->tl);
     2404        #endif
     2405        return;
     2406      }
     2407    }
     2408    if(p_LmCmp(pSigMult,sSigMult,currRing) == 0)
     2409    {
     2410      //Same lm, have to substract
     2411      Lp.sig = p_Sub(pCopy(pSigMult),pCopy(sSigMult),currRing);
     2412    }
     2413    else
     2414    {
     2415      if(sigCmp == 1)
     2416      {
     2417        Lp.sig = pCopy(pSigMult);
     2418      }
     2419      if(sigCmp == -1)
     2420      {
     2421        Lp.sig = pNeg(pCopy(sSigMult));
     2422      }
     2423    }
     2424    Lp.sevSig = p_GetShortExpVector(Lp.sig,currRing);
     2425  }
     2426  #endif
     2427 
     2428  #if 0 
    21162429  if(sigCmp==0)
    21172430  {
     
    21312444    return;
    21322445  }
     2446  #endif
    21332447  // testing by syzCrit = F5 Criterion
    21342448  // testing by rewCrit1 = Rewritten Criterion
     
    21392453      )
    21402454  {
     2455    #if ADIDEBUG
     2456    printf("\nDELETED!\n");
     2457    #endif
    21412458    pDelete(&pSigMult);
    21422459    pDelete(&sSigMult);
     
    21662483  else
    21672484  {
    2168     #ifdef HAVE_PLURAL
    2169     if ( rIsPluralRing(currRing) )
    2170     {
    2171       if(pHasNotCF(p, strat->S[i]))
    2172       {
    2173          if(ncRingType(currRing) == nc_lie)
    2174          {
    2175              // generalized prod-crit for lie-type
    2176              strat->cp++;
    2177              Lp.p = nc_p_Bracket_qq(pCopy(p),strat->S[i], currRing);
    2178          }
    2179          else
    2180         if( ALLOW_PROD_CRIT(strat) )
    2181         {
    2182             // product criterion for homogeneous case in SCA
    2183             strat->cp++;
    2184             Lp.p = NULL;
     2485    //Build p
     2486    #ifdef HAVE_RINGS
     2487    if(rField_is_Ring(currRing))
     2488    {
     2489      poly p1 = p_Copy(p,currRing);
     2490      poly p2 = p_Copy(strat->S[i],currRing);
     2491      p1 = p_Mult_mm(p1,m1,currRing);
     2492      p2 = p_Mult_mm(p2,m2,currRing);
     2493      Lp.p = p_Sub(p1,p2,currRing);
     2494      if(Lp.p != NULL)
     2495        Lp.sev = p_GetShortExpVector(Lp.p,currRing);
     2496    }
     2497    else
     2498    #endif
     2499    {
     2500      #ifdef HAVE_PLURAL
     2501      if ( rIsPluralRing(currRing) )
     2502      {
     2503        if(pHasNotCF(p, strat->S[i]))
     2504        {
     2505           if(ncRingType(currRing) == nc_lie)
     2506           {
     2507               // generalized prod-crit for lie-type
     2508               strat->cp++;
     2509               Lp.p = nc_p_Bracket_qq(pCopy(p),strat->S[i], currRing);
     2510           }
     2511           else
     2512          if( ALLOW_PROD_CRIT(strat) )
     2513          {
     2514              // product criterion for homogeneous case in SCA
     2515              strat->cp++;
     2516              Lp.p = NULL;
     2517          }
     2518          else
     2519          {
     2520            Lp.p = // nc_CreateSpoly(strat->S[i],p,currRing);
     2521                  nc_CreateShortSpoly(strat->S[i], p, currRing);
     2522
     2523            assume(pNext(Lp.p)==NULL); // TODO: this may be violated whenever ext.prod.crit. for Lie alg. is used
     2524            pNext(Lp.p) = strat->tail; // !!!
     2525          }
    21852526        }
    21862527        else
     
    21912532          assume(pNext(Lp.p)==NULL); // TODO: this may be violated whenever ext.prod.crit. for Lie alg. is used
    21922533          pNext(Lp.p) = strat->tail; // !!!
    2193         }
     2534
     2535        }
     2536
     2537
     2538  #if MYTEST
     2539        if (TEST_OPT_DEBUG)
     2540        {
     2541          PrintS("enterOnePairNormal::\n strat->S[i]: "); pWrite(strat->S[i]);
     2542          PrintS("p: "); pWrite(p);
     2543          PrintS("SPoly: "); pWrite(Lp.p);
     2544        }
     2545  #endif
     2546
    21942547      }
    21952548      else
    2196       {
    2197         Lp.p = // nc_CreateSpoly(strat->S[i],p,currRing);
    2198               nc_CreateShortSpoly(strat->S[i], p, currRing);
    2199 
    2200         assume(pNext(Lp.p)==NULL); // TODO: this may be violated whenever ext.prod.crit. for Lie alg. is used
    2201         pNext(Lp.p) = strat->tail; // !!!
    2202 
    2203       }
    2204 
    2205 
    2206 #if MYTEST
    2207       if (TEST_OPT_DEBUG)
    2208       {
    2209         PrintS("enterOnePairNormal::\n strat->S[i]: "); pWrite(strat->S[i]);
    2210         PrintS("p: "); pWrite(p);
    2211         PrintS("SPoly: "); pWrite(Lp.p);
    2212       }
    2213 #endif
    2214 
    2215     }
    2216     else
    2217     #endif
    2218     {
    2219       assume(!rIsPluralRing(currRing));
    2220       Lp.p = ksCreateShortSpoly(strat->S[i], p, strat->tailRing);
    2221 #if MYTEST
    2222       if (TEST_OPT_DEBUG)
    2223       {
    2224         PrintS("enterOnePairNormal::\n strat->S[i]: "); pWrite(strat->S[i]);
    2225         PrintS("p: "); pWrite(p);
    2226         PrintS("commutative SPoly: "); pWrite(Lp.p);
    2227       }
    2228 #endif
    2229 
    2230       }
     2549      #endif
     2550      {
     2551        assume(!rIsPluralRing(currRing));
     2552        Lp.p = ksCreateShortSpoly(strat->S[i], p, strat->tailRing);
     2553  #if MYTEST
     2554        if (TEST_OPT_DEBUG)
     2555        {
     2556          PrintS("enterOnePairNormal::\n strat->S[i]: "); pWrite(strat->S[i]);
     2557          PrintS("p: "); pWrite(p);
     2558          PrintS("commutative SPoly: "); pWrite(Lp.p);
     2559        }
     2560  #endif
     2561
     2562        }
     2563    }
    22312564  }
    22322565  // store from which element this pair comes from for further tests
    22332566  //Lp.from = strat->sl+1;
    2234   if(sigCmp==currRing->OrdSgn)
    2235   {
    2236     // pSig > sSig
    2237     pDelete (&sSigMult);
    2238     Lp.sig    = pSigMult;
    2239     Lp.sevSig = ~pSigMultNegSev;
     2567  #ifdef HAVE_RINGS
     2568  if(rField_is_Ring(currRing))
     2569  {
     2570    //Put the sig to be > 0
     2571    if(!nGreaterZero(pGetCoeff(Lp.sig)))
     2572    {
     2573      Lp.sig = pNeg(Lp.sig);
     2574      Lp.p = pNeg(Lp.p);
     2575    }
    22402576  }
    22412577  else
    2242   {
    2243     // pSig < sSig
    2244     pDelete (&pSigMult);
    2245     Lp.sig    = sSigMult;
    2246     Lp.sevSig = ~sSigMultNegSev;
     2578  #endif
     2579  {
     2580    if(sigCmp==currRing->OrdSgn)
     2581    {
     2582      // pSig > sSig
     2583      pDelete (&sSigMult);
     2584      Lp.sig    = pSigMult;
     2585      Lp.sevSig = ~pSigMultNegSev;
     2586    }
     2587    else
     2588    {
     2589      // pSig < sSig
     2590      pDelete (&pSigMult);
     2591      Lp.sig    = sSigMult;
     2592      Lp.sevSig = ~sSigMultNegSev;
     2593    }
    22472594  }
    22482595  if (Lp.p == NULL)
     
    22572604    if (strat->rewCrit3(Lp.sig,~Lp.sevSig,Lp.p,strat,strat->sl+1)) {
    22582605      pLmFree(Lp.lcm);
     2606      #if ADIDEBUG
     2607      printf("\nrewCrit3 deletes it!\n");
     2608      #endif
    22592609      pDelete(&Lp.sig);
    22602610      Lp.lcm=NULL;
     
    22982648        (!rIsPluralRing(currRing))
    22992649//      ||  (rIsPluralRing(currRing) && (ncRingType(currRing) != nc_lie))
     2650      #ifdef HAVE_RINGS
     2651      && !rField_is_Ring(currRing)
     2652      #endif
    23002653       )
    23012654    {
     
    23182671    if (TEST_OPT_INTSTRATEGY)
    23192672    {
    2320       if (!rIsPluralRing(currRing))
     2673      if (!rIsPluralRing(currRing)
     2674      #ifdef HAVE_RINGS
     2675      && !rField_is_Ring(currRing)
     2676      #endif
     2677      )
    23212678        nDelete(&(Lp.p->coef));
    23222679    }
    2323 
    2324     l = strat->posInLSba(strat->B,strat->Bl,&Lp,strat);
    2325     enterL(&strat->B,&strat->Bl,&strat->Bmax,Lp,l);
     2680    // Check for sigdrop
     2681    #ifdef HAVE_RINGS
     2682    if(rField_is_Ring(currRing) &&
     2683      pLtCmp(Lp.sig,pSig) == -1
     2684      )
     2685    {
     2686      #if ADIDEBUG
     2687      printf("\nSigDrop in enteronepairSig\n");pWrite(Lp.sig);
     2688      pWrite(p);pWrite(pSig);
     2689      pWrite(strat->S[i]);pWrite(strat->sig[i]);
     2690      #endif
     2691      strat->sigdrop = TRUE;
     2692      // Completely reduce it
     2693      int red_result = redRing(&Lp,strat);
     2694      if(red_result == 0)
     2695      {
     2696        // Reduced to 0
     2697        #if ADIDEBUG
     2698        printf("\nCancel the sigdrop after redRing (=0)\n");
     2699        #endif
     2700        strat->sigdrop = FALSE;
     2701        p_Delete(&Lp.sig,currRing);Lp.sig = NULL;
     2702        return;
     2703      }
     2704      else
     2705      {
     2706        #if ADIDEBUG
     2707        printf("\nAfter redRing still sigdrop:\n");pWrite(Lp.p);
     2708        #endif
     2709        strat->enterS(strat->P,strat->sl+1,strat, strat->tl+1);
     2710        // 0 - add just the original poly causing the sigdrop, 1 - add also this
     2711        #if 1
     2712        strat->enterS(Lp,0,strat, strat->tl+1);
     2713        #endif
     2714        return;
     2715      }
     2716    }
     2717    #endif
     2718    #if ADIDEBUG
     2719    printf("\nThis spair was added to B:\n");
     2720    pWrite(Lp.p);
     2721    pWrite(Lp.p1);
     2722    pWrite(Lp.p2);
     2723    pWrite(Lp.sig);
     2724    #endif
     2725    l = strat->posInLSba(strat->L,strat->Ll,&Lp,strat);
     2726    enterL(&strat->L,&strat->Ll,&strat->Lmax,Lp,l);
    23262727  }
    23272728}
     
    31093510      if ((isFromQ)&&(strat->fromQ!=NULL))
    31103511      {
    3111         for (j=0; j<=k; j++)
     3512        for (j=0; j<=k && !strat->sigdrop; j++)
    31123513        {
    31133514          if (!strat->fromQ[j])
     
    31223523      {
    31233524        new_pair=TRUE;
    3124         for (j=0; j<=k; j++)
     3525        for (j=0; j<=k && !strat->sigdrop; j++)
    31253526        {
    31263527          enterOnePairSig(j,h,hSig,hFrom,ecart,isFromQ,strat, atR);
     
    31313532    else
    31323533    {
    3133       for (j=0; j<=k; j++)
     3534      for (j=0; j<=k && !strat->sigdrop; j++)
    31343535      {
    31353536        if ((pGetComp(h)==pGetComp(strat->S[j]))
     
    31433544    }
    31443545
     3546#if 0
    31453547    if (new_pair)
    31463548    {
     
    31523554      strat->chainCrit(h,ecart,strat);
    31533555    }
     3556#endif
    31543557  }
    31553558}
     
    37674170    }
    37684171  }
    3769 /*
    3770 ring r=256,(x,y,z),dp;
    3771 ideal I=12xz-133y, 2xy-z;
    3772 */
     4172}
     4173
     4174void initenterstrongPairsSig (poly h,poly hSig, int hFrom, int k,int ecart,int isFromQ,kStrategy strat, int atR = -1)
     4175{
     4176  const int iCompH = pGetComp(h);
     4177  if (!nIsOne(pGetCoeff(h)))
     4178  {
     4179    int j;
     4180
     4181    for (j=0; j<=k && !strat->sigdrop; j++)
     4182    {
     4183      // Print("j:%d, Ll:%d\n",j,strat->Ll);
     4184//      if (((unsigned long) pGetCoeff(h) % (unsigned long) pGetCoeff(strat->S[j]) != 0) &&
     4185//         ((unsigned long) pGetCoeff(strat->S[j]) % (unsigned long) pGetCoeff(h) != 0))
     4186      if (((iCompH == pGetComp(strat->S[j]))
     4187      || (0 == pGetComp(strat->S[j])))
     4188      && ((iCompH<=strat->syzComp)||(strat->syzComp==0)))
     4189      {
     4190        enterOneStrongPolySig(j,h,hSig,ecart,isFromQ,strat, atR);
     4191      }
     4192    }
     4193  }
    37734194}
    37744195#endif
     
    39004321void superenterpairs (poly h,int k,int ecart,int pos,kStrategy strat, int atR)
    39014322{
    3902 #if ADIDEBUG
    3903   PrintS("\nEnter superenterpairs\n");
    3904   int iii = strat->Ll;
    3905   printf("\nstrat->tl = %i\n",strat->tl);
    3906 #endif
    39074323  assume (rField_is_Ring(currRing));
    39084324  // enter also zero divisor * poly, if this is non zero and of smaller degree
    39094325  if (!(rField_is_Domain(currRing))) enterExtendedSpoly(h, strat);
    3910 //#if ADIDEBUG
    3911   #if 0
    3912   if(iii==strat->Ll)
    3913   {
    3914     PrintS("\n                enterExtendedSpoly has not changed the list L.\n");
    3915   }
    3916   else
    3917   {
    3918     PrintLn();
    3919     PrintS("\n                enterExtendedSpoly changed the list L:\n");
    3920     for(iii=0;iii<=strat->Ll;iii++)
    3921     {
    3922       Print("\n                L[%d]:\n",iii);
    3923       PrintS("                     ");p_Write(strat->L[iii].p,strat->tailRing);
    3924       PrintS("                     ");p_Write(strat->L[iii].p1,strat->tailRing);
    3925       PrintS("                     ");p_Write(strat->L[iii].p2,strat->tailRing);
    3926     }
    3927   }
    3928   printf("\nstrat->tl = %i\n",strat->tl);
    3929   iii = strat->Ll;
    3930 #endif
    39314326  initenterpairs(h, k, ecart, 0, strat, atR);
    3932 //#if ADIDEBUG
    3933   #if 0
    3934   if(iii==strat->Ll)
    3935   {
    3936     PrintS("\n                initenterpairs has not changed the list L.\n");
    3937   }
    3938   else
    3939   {
    3940     PrintS("\n                initenterpairs changed the list L:\n");
    3941     for(iii=0;iii<=strat->Ll;iii++)
    3942     {
    3943       Print("\n                L[%d]:\n",iii);
    3944       PrintS("                     ");p_Write(strat->L[iii].p1,strat->tailRing);
    3945       PrintS("                     ");p_Write(strat->L[iii].p2,strat->tailRing);
    3946       PrintS("                     ");p_Write(strat->L[iii].p,strat->tailRing);
    3947     }
    3948   }
    3949   printf("\nstrat->tl = %i\n",strat->tl);
    3950   iii = strat->Ll;
    3951 #endif
    39524327  initenterstrongPairs(h, k, ecart, 0, strat, atR);
    3953 //#if ADIDEBUG
    3954   #if 0
    3955   if(iii==strat->Ll)
    3956   {
    3957     PrintS("\n                initenterstrongPairs has not changed the list L.\n");
    3958   }
    3959   else
    3960   {
    3961     PrintS("\n                initenterstrongPairs changed the list L:\n");
    3962     for(iii=0;iii<=strat->Ll;iii++)
    3963     {
    3964       Print("\n                L[%d]:\n",iii);
    3965       PrintS("                     ");p_Write(strat->L[iii].p1,strat->tailRing);
    3966       PrintS("                     ");p_Write(strat->L[iii].p2,strat->tailRing);
    3967       PrintS("                     ");p_Write(strat->L[iii].p,strat->tailRing);
    3968     }
    3969   }
    3970   printf("\nstrat->tl = %i\n",strat->tl);
    3971   PrintS("\nEnd of superenterpairs\n");
    3972 #endif
    39734328  clearSbatch(h, k, pos, strat);
    3974 #if ADIDEBUG
    3975   printf("\nstrat->tl = %i\n",strat->tl);
    3976 #endif
     4329}
     4330
     4331void superenterpairsSig (poly h,poly hSig,int hFrom,int k,int ecart,int pos,kStrategy strat, int atR)
     4332{
     4333  assume (rField_is_Ring_Z(currRing));
     4334  // enter also zero divisor * poly, if this is non zero and of smaller degree
     4335  //if (!(rField_is_Domain(currRing))) enterExtendedSpoly(h, strat);
     4336  #if ADIDEBUG
     4337  printf("\n      Trying to add spolys\n");
     4338  #endif
     4339  initenterpairsSig(h, hSig, hFrom, k, ecart, 0, strat, atR);
     4340  #if ADIDEBUG
     4341  printf("\n      Trying to add gcd-polys\n");
     4342  #endif
     4343  initenterstrongPairsSig(h, hSig, hFrom,k, ecart, 0, strat, atR);
     4344  clearSbatch(h, k, pos, strat);
    39774345}
    39784346#endif
     
    49385306{
    49395307if (length<0) return 0;
    4940 if (pLmCmp(set[length].sig,p->sig)== currRing->OrdSgn)
     5308if (pLtCmp(set[length].sig,p->sig)== currRing->OrdSgn)
    49415309  return length+1;
    49425310
     
    49485316  if (an >= en-1)
    49495317  {
    4950     if (pLmCmp(set[an].sig,p->sig) == currRing->OrdSgn) return en;
     5318    if (pLtCmp(set[an].sig,p->sig) == currRing->OrdSgn) return en;
    49515319    return an;
    49525320  }
    49535321  i=(an+en) / 2;
    4954   if (pLmCmp(set[i].sig,p->sig) == currRing->OrdSgn) an=i;
     5322  if (pLtCmp(set[i].sig,p->sig) == currRing->OrdSgn) an=i;
    49555323  else                                      en=i;
    49565324  /*aend. fuer lazy == in !=- machen */
     
    50425410{
    50435411if (strat->syzl==0) return 0;
    5044 if (pLmCmp(strat->syz[strat->syzl-1],sig) != currRing->OrdSgn)
     5412if (pLtCmp(strat->syz[strat->syzl-1],sig) != currRing->OrdSgn)
    50455413  return strat->syzl;
    50465414int i;
     
    50515419  if (an >= en-1)
    50525420  {
    5053     if (pLmCmp(strat->syz[an],sig) != currRing->OrdSgn) return en;
     5421    if (pLtCmp(strat->syz[an],sig) != currRing->OrdSgn) return en;
    50545422    return an;
    50555423  }
    50565424  i=(an+en) / 2;
    5057   if (pLmCmp(strat->syz[i],sig) != currRing->OrdSgn) an=i;
     5425  if (pLtCmp(strat->syz[i],sig) != currRing->OrdSgn) an=i;
    50585426  else                                      en=i;
    50595427  /*aend. fuer lazy == in !=- machen */
     
    56856053    pWrite(pHead(strat->syz[k]));
    56866054#endif
    5687     if (p_LmShortDivisibleBy(strat->syz[k], strat->sevSyz[k], sig, not_sevSig, currRing))
     6055    if (p_LmShortDivisibleBy(strat->syz[k], strat->sevSyz[k], sig, not_sevSig, currRing)
     6056    #ifdef HAVE_RINGS
     6057    && (!rField_is_Ring(currRing) ||
     6058    (n_DivBy(pGetCoeff(sig), pGetCoeff(strat->syz[k]),currRing) && pLtCmp(sig,strat->syz[k]) == 1))
     6059    #endif
     6060    )
    56886061    {
    56896062//#if 1
     
    56916064      PrintS("DELETE!\n");
    56926065#endif
     6066      #if ADIDEBUG
     6067      printf("\nsyzCrit:\n");pWrite(strat->syz[k]);pWrite(sig);
     6068      #endif
     6069      strat->nrsyzcrit++;
    56936070      //printf("- T -\n\n");
    56946071      return TRUE;
     
    57346111      pWrite(pHead(strat->syz[k]));
    57356112#endif
    5736       if (p_LmShortDivisibleBy(strat->syz[k], strat->sevSyz[k], sig, not_sevSig, currRing))
     6113      if (p_LmShortDivisibleBy(strat->syz[k], strat->sevSyz[k], sig, not_sevSig, currRing)
     6114      #ifdef HAVE_RINGS
     6115      && (!rField_is_Ring(currRing) ||
     6116      (n_DivBy(pGetCoeff(sig), pGetCoeff(strat->syz[k]),currRing) && pLtCmp(sig,strat->syz[k]) == 1))
     6117    #endif     
     6118      )
     6119      {
     6120        #if ADIDEBUG
     6121        printf("\nsyzCrit:\n");pWrite(strat->syz[k]);pWrite(sig);
     6122        #endif
     6123        strat->nrsyzcrit++;
    57376124        return TRUE;
     6125      }
    57386126    }
    57396127    return FALSE;
     
    57466134BOOLEAN faugereRewCriterion(poly sig, unsigned long not_sevSig, poly /*lm*/, kStrategy strat, int start=0)
    57476135{
     6136 
     6137  #ifdef HAVE_RINGS
     6138  if(rField_is_Ring(currRing))
     6139    return FALSE;
     6140  #endif
    57486141  //printf("Faugere Rewritten Criterion\n");
    57496142//#if 1
     
    57606153    pWrite(pHead(strat->S[k]));
    57616154#endif
    5762     if (p_LmShortDivisibleBy(strat->sig[k], strat->sevSig[k], sig, not_sevSig, currRing))
     6155    if (p_LmShortDivisibleBy(strat->sig[k], strat->sevSig[k], sig, not_sevSig, currRing)
     6156    #ifdef HAVE_RINGS
     6157    && rField_is_Ring(currRing) && n_DivBy(pGetCoeff(sig),pGetCoeff(strat->sig[k]),currRing)
     6158    #endif
     6159    )
    57636160    {
    57646161//#if 1
     
    58026199BOOLEAN arriRewCriterion(poly /*sig*/, unsigned long /*not_sevSig*/, poly /*lm*/, kStrategy strat, int start=0)
    58036200{
     6201  #ifdef HAVE_RINGS
     6202  if(rField_is_Ring(currRing))
     6203    return FALSE;
     6204  #endif
    58046205  poly p1 = pOne();
    58056206  poly p2 = pOne();
    58066207  for (int ii=strat->sl; ii>start; ii--)
    58076208  {
    5808     if (p_LmShortDivisibleBy(strat->sig[ii], strat->sevSig[ii], strat->P.sig, ~strat->P.sevSig, currRing))
     6209    if (p_LmShortDivisibleBy(strat->sig[ii], strat->sevSig[ii], strat->P.sig, ~strat->P.sevSig, currRing)
     6210    #ifdef HAVE_RINGS
     6211    &&(rField_is_Ring(currRing)) && n_DivBy(pGetCoeff(strat->P.sig),pGetCoeff(strat->sig[ii]),currRing)
     6212    #endif
     6213    )
    58096214    {
    58106215      p_ExpVectorSum(p1,strat->P.sig,strat->S[ii],currRing);
    58116216      p_ExpVectorSum(p2,strat->sig[ii],strat->P.p,currRing);
     6217      #ifdef HAVE_RINGS
     6218      if((rField_is_Ring(currRing) && !(pLtCmp(p1,p2) == 1))
     6219        || (!rField_is_Ring(currRing) && !(pLmCmp(p1,p2) == 1)))
     6220      #else
    58126221      if (!(pLmCmp(p1,p2) == 1))
     6222      #endif
    58136223      {
    58146224        pDelete(&p1);
     
    58256235BOOLEAN arriRewCriterionPre(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int /*start=0*/)
    58266236{
     6237  #ifdef HAVE_RINGS
     6238  //Over Rings, there are still some changes to do: considering coeffs
     6239  if(rField_is_Ring(currRing))
     6240    return FALSE;
     6241  #endif
    58276242  int found = -1;
    58286243  for (int i=strat->Bl; i>-1; i--) {
    5829     if (pLmEqual(strat->B[i].sig,sig)) {
     6244    if (pLmEqual(strat->B[i].sig,sig)
     6245    #ifdef HAVE_RINGS
     6246    && (rField_is_Ring(currRing) && n_Equal(pGetCoeff(strat->B[i].sig),pGetCoeff(sig),currRing))
     6247    #endif
     6248    )
     6249    {
    58306250      found = i;
    58316251      break;
     
    67357155  if( strat->S[0] )
    67367156  {
    6737     if( strat->S[1] )
     7157    if( strat->S[1] && !rField_is_Ring(currRing))
    67387158    {
    67397159      omFreeSize(strat->syzIdx,(strat->syzidxmax)*sizeof(int));
     
    68027222        {
    68037223          Q.sig          = pOne();
     7224          #ifdef HAVE_RINGS
     7225          if(rField_is_Ring(currRing))
     7226            p_SetCoeff(Q.sig,nCopy(p_GetCoeff(strat->S[k],currRing)),currRing);
     7227          #endif
    68047228          p_ExpVectorCopy(Q.sig,strat->S[k],currRing);
    68057229          p_SetCompP (Q.sig, comp, currRing);
    68067230          poly q          = p_One(currRing);
     7231          #ifdef HAVE_RINGS
     7232          if(rField_is_Ring(currRing))
     7233            p_SetCoeff(q,nCopy(p_GetCoeff(strat->S[i],currRing)),currRing);
     7234          #endif
    68077235          p_ExpVectorCopy(q,strat->S[i],currRing);
    68087236          q               = p_Neg (q, currRing);
     
    68427270    {
    68437271      Q.sig          = pOne();
     7272      #ifdef HAVE_RINGS
     7273      if(rField_is_Ring(currRing))
     7274        p_SetCoeff(Q.sig,nCopy(p_GetCoeff(strat->S[k],currRing)),currRing);
     7275      #endif
    68447276      p_ExpVectorCopy(Q.sig,strat->S[k],currRing);
    68457277      p_SetCompP (Q.sig, comp, currRing);
    68467278      poly q          = p_One(currRing);
     7279      #ifdef HAVE_RINGS
     7280      if(rField_is_Ring(currRing))
     7281        p_SetCoeff(q,nCopy(p_GetCoeff(strat->L[strat->Ll].p,currRing)),currRing);
     7282      #endif
    68477283      p_ExpVectorCopy(q,strat->L[strat->Ll].p,currRing);
    68487284      q               = p_Neg (q, currRing);
     
    77208156  // appear due to the fact that the critical pairs are already sorted
    77218157  // by increasing signature.
     8158  // True. However, in the case of integers we need to put the element
     8159  // that caused the signature drop on the first position
    77228160  if (atS <= strat->sl)
    77238161  {
     
    77268164    memmove(&(strat->S[atS+1]), &(strat->S[atS]),
    77278165            (strat->sl - atS + 1)*sizeof(poly));
     8166    memmove(&(strat->sig[atS+1]), &(strat->sig[atS]),
     8167            (strat->sl - atS + 1)*sizeof(poly));
     8168    memmove(&(strat->sevSig[atS+1]), &(strat->sevSig[atS]),
     8169            (strat->sl - atS + 1)*sizeof(unsigned long));
    77288170    memmove(&(strat->ecartS[atS+1]), &(strat->ecartS[atS]),
    77298171            (strat->sl - atS + 1)*sizeof(int));
     
    77458187      strat->sevS[i] = strat->sevS[i-1];
    77468188      strat->S_2_R[i] = strat->S_2_R[i-1];
     8189      strat->sig[i] = strat->sig[i-1];
     8190      strat->sevSig[i] = strat->sevSig[i-1];
    77478191    }
    77488192    if (strat->lenS!=NULL)
     
    78698313  #if ADIDEBUG
    78708314  printf("\nenterT: add in position %i\n",atT);
    7871   pWrite(p.p);
     8315  pWrite(p.p);pWrite(p.sig);
    78728316  #endif
    78738317  //printf("\nenterT: neue hingefÃŒgt: lÀnge = %i, ecart = %i\n",p.length,p.ecart);
     
    80038447void enterSyz(LObject &p, kStrategy strat, int atT)
    80048448{
     8449  #if ADIDEBUG
     8450  printf("\n  Entersyz:\n");pWrite(p.sig);
     8451  #endif
    80058452  int i;
    80068453  strat->newt = TRUE;
     
    80328479  //i = strat->syzl;
    80338480  i = atT;
     8481  //Makes sure the syz saves just the signature
     8482  #ifdef HAVE_RINGS
     8483  if(rField_is_Ring(currRing))
     8484    pNext(p.sig) = NULL;
     8485  #endif
    80348486  strat->syz[atT] = p.sig;
    80358487  strat->sevSyz[atT] = p.sevSig;
     
    80438495  while (cc>-1)
    80448496  {
     8497    //printf("\nCheck if syz is div by L\n");pWrite(strat->syz[atT]);pWrite(strat->L[cc].sig);
     8498    //printf("\npLmShDivBy(syz,L) = %i\nn_DivBy(L,syz) = %i\n pLtCmp(L,syz) = %i",p_LmShortDivisibleBy( strat->syz[atT], strat->sevSyz[atT],strat->L[cc].sig, ~strat->L[cc].sevSig, currRing), n_DivBy(pGetCoeff(strat->L[cc].sig),pGetCoeff(strat->syz[atT]),currRing), pLtCmp(strat->L[cc].sig,strat->syz[atT])==1);
    80458499    if (p_LmShortDivisibleBy( strat->syz[atT], strat->sevSyz[atT],
    8046                               strat->L[cc].sig, ~strat->L[cc].sevSig, currRing))
    8047     {
     8500                              strat->L[cc].sig, ~strat->L[cc].sevSig, currRing)
     8501                              #ifdef HAVE_RINGS
     8502                              &&(rField_is_Ring(currRing))
     8503                              && n_DivBy(pGetCoeff(strat->L[cc].sig),pGetCoeff(strat->syz[atT]),currRing) && (pLtCmp(strat->L[cc].sig,strat->syz[atT])==1)
     8504                              #endif
     8505                              )
     8506    {
     8507      //printf("\nYES!\n");
     8508      #if ADIDEBUG
     8509      printf("\n syzCrit deleted!\n");pWrite(strat->L[cc].p);pWrite(strat->L[cc].sig);
     8510      #endif
    80488511      deleteInL(strat->L,&strat->Ll,cc,strat);
    80498512    }
     
    85919054    else
    85929055    {
    8593       /*Shdl=*/initSLSba(F, Q,strat); /*sets also S, ecartS, fromQ */
    8594       // /*Shdl=*/initS(F, Q,strat); /*sets also S, ecartS, fromQ */
     9056      initSLSba(F, Q,strat); /*sets also S, ecartS, fromQ */
    85959057    }
    85969058  }
     
    86189080  omFreeSize((ADDRESS)strat->sevS,IDELEMS(strat->Shdl)*sizeof(unsigned long));
    86199081  omFreeSize((ADDRESS)strat->sevSig,IDELEMS(strat->Shdl)*sizeof(unsigned long));
    8620   omFreeSize((ADDRESS)strat->syz,(strat->syzmax)*sizeof(poly));
    8621   omFreeSize((ADDRESS)strat->sevSyz,(strat->syzmax)*sizeof(unsigned long));
    8622   if (strat->sbaOrder == 1)
    8623   {
    8624     omFreeSize(strat->syzIdx,(strat->syzidxmax)*sizeof(int));
     9082  if(strat->syzmax>0)
     9083  {
     9084    omFreeSize((ADDRESS)strat->syz,(strat->syzmax)*sizeof(poly));
     9085    omFreeSize((ADDRESS)strat->sevSyz,(strat->syzmax)*sizeof(unsigned long));
     9086    if (strat->sbaOrder == 1)
     9087    {
     9088      omFreeSize(strat->syzIdx,(strat->syzidxmax)*sizeof(int));
     9089    }
    86259090  }
    86269091  omFreeSize(strat->S_2_R,IDELEMS(strat->Shdl)*sizeof(int));
  • kernel/GBEngine/kutil.h

    ra94fcf8 r094031  
    355355  int newIdeal;
    356356  int minim;
     357  #ifdef HAVE_RINGS
     358  bool sigdrop; //This is used to check sigdrop in sba over Z
     359  int nrsyzcrit; // counts how many pairs are deleted by SyzCrit
     360  int sbaEnterS; // sba over Z strategy: if sigdrop element has _*gen(sbaEnterS+1), then
     361                 // add directly sbaEnterS elements into S
     362  #endif
    357363  #ifdef HAVE_SHIFTBBA
    358364  int lV;
     
    485491void enterExtendedSpoly(poly h,kStrategy strat);
    486492void superenterpairs (poly h,int k,int ecart,int pos,kStrategy strat, int atR = -1);
     493void superenterpairsSig (poly h,poly hSig,int hFrom,int k,int ecart,int pos,kStrategy strat, int atR = -1);
    487494poly kCreateZeroPoly(long exp[], long cabsind, poly* t_p, ring leadRing, ring tailRing);
    488495long ind2(long arg);
     
    501508void pairs ();
    502509BOOLEAN enterOneStrongPoly (int i,poly p,int /*ecart*/, int /*isFromQ*/,kStrategy strat, int atR = -1, bool enterTstrong = FALSE);
     510BOOLEAN enterOneStrongPolySig (int i,poly p,poly sig,int /*ecart*/, int /*isFromQ*/,kStrategy strat, int atR = -1);
    503511void message (int i,int* reduc,int* olddeg,kStrategy strat,int red_result);
    504512void messageStat (int hilbcount,kStrategy strat);
  • kernel/polys.h

    ra94fcf8 r094031  
    104104/// returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
    105105#define pLmCmp(p,q)         p_LmCmp(p,q,currRing)
     106#define pLtCmp(p,q)         p_LtCmp(p,q,currRing)
    106107/// executes axtionE|actionG|actionS if p=q|p>q|p<q w.r.t monomial ordering
    107108/// action should be a "goto ..."
  • libpolys/polys/monomials/p_polys.h

    ra94fcf8 r094031  
    15041504}
    15051505
     1506// The coefficient will be compared in absolute value
     1507static inline int p_LtCmp(poly p, poly q, const ring r)
     1508{
     1509  int res = p_LmCmp(p,q,r);
     1510  if(res == 0)
     1511  {
     1512    number pc = n_Copy(p_GetCoeff(p,r),r->cf);
     1513    number qc = n_Copy(p_GetCoeff(q,r),r->cf);
     1514    if(!n_GreaterZero(pc,r->cf))
     1515      pc = n_InpNeg(pc,r->cf);
     1516    if(!n_GreaterZero(qc,r->cf))
     1517      qc = n_InpNeg(qc,r->cf);
     1518    if(n_Greater(pc,qc,r->cf))
     1519      res = 1;
     1520    if(n_Greater(qc,pc,r->cf))
     1521      res = -1;
     1522    if(n_Equal(pc,qc,r->cf))
     1523      res = 0;
     1524    n_Delete(&pc,r->cf);
     1525    n_Delete(&qc,r->cf);
     1526  }
     1527  return res;
     1528}
     1529
    15061530/// returns TRUE if p1 is a skalar multiple of p2
    15071531/// assume p1 != NULL and p2 != NULL
  • libpolys/polys/simpleideals.cc

    ra94fcf8 r094031  
    476476  if (nolex)
    477477  {
    478     int r=p_LmCmp(a,b,R);
     478    int r=p_LtCmp(a,b,R);
     479    return r;
     480    #if 0
    479481    if (r!=0) return r;
    480482    number h=n_Sub(pGetCoeff(a),pGetCoeff(b),R->cf);
     
    482484    n_Delete(&h, R->cf);
    483485    return r;
     486    #endif
    484487  }
    485488  int l=rVar(R);
Note: See TracChangeset for help on using the changeset viewer.