Changeset 094031 in git for kernel/GBEngine/kstd2.cc


Ignore:
Timestamp:
May 11, 2016, 9:27:07 AM (8 years ago)
Author:
Adi Popescu <adi_popescum@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'fc741b6502fd8a97288eaa3eba6e5220f3c3df87')
Children:
ae57df01d23de4585edc0ab0e326957b7c5d6713
Parents:
a94fcf8caf88c19db9ef8352748fc35986436105
Message:
first version that seems to work
trying to optimize it now
File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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);
Note: See TracChangeset for help on using the changeset viewer.