Changeset 601105 in git


Ignore:
Timestamp:
Nov 19, 2013, 6:39:47 PM (9 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', '5bec8f88c9ee2573d328cf7c3aff2bcb301d2395')
Children:
448b6571955b81192b53dc7300bb54a1984142e3
Parents:
9d864add8f262ed66a3af97f514c37d01844334c
Message:
chg: use syzComp in initenterstrongPairs
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • kernel/kstd1.cc

    r9d864a r601105  
    364364  int pass = 0;
    365365  long d,reddeg;
    366  
    367  
    368         #if ADIDEBUG_NF
    369         int iii;
    370         PrintLn();
    371         PrintS("---------------------------- NEW REDRILOC COMPUTATION ----------------------------");
    372         PrintLn();
    373         PrintS("                The pair h : "); PrintLn(); PrintLn();
    374         PrintS("                        p1 = "); p_Write(h->p1,strat->tailRing); PrintLn();
    375         PrintS("                        p2 = "); p_Write(h->p2,strat->tailRing); PrintLn();
    376         PrintS("                        p  = "); p_Write(h->p,strat->tailRing); PrintLn();
    377         PrintLn();
    378         PrintS("                The actual reducer T is: ");
    379         if(strat->tl<0)
    380                 {PrintS(" Empty.");PrintLn();}
    381         else
    382         for (iii=0;iii<=strat->tl;iii++)
    383                 {
    384                 PrintLn();
    385                 PrintS("                        T[");printf("%i",iii);PrintS("] = ");p_Write(strat->T[iii].p,strat->tailRing);
    386                 PrintLn();
    387                 }
    388         #endif /* ADIDEBUG_NF */
    389        
     366
     367
     368  #if ADIDEBUG_NF
     369  int iii;
     370  PrintLn();
     371  PrintS("---------------------------- NEW REDRILOC COMPUTATION ----------------------------");
     372  PrintLn();
     373  PrintS("    The pair h : "); PrintLn(); PrintLn();
     374  PrintS("      p1 = "); p_Write(h->p1,strat->tailRing); PrintLn();
     375  PrintS("      p2 = "); p_Write(h->p2,strat->tailRing); PrintLn();
     376  PrintS("      p  = "); p_Write(h->p,strat->tailRing); PrintLn();
     377  PrintLn();
     378  PrintS("    The actual reducer T is: ");
     379  if(strat->tl<0)
     380    {PrintS(" Empty.");PrintLn();}
     381  else
     382  for (iii=0;iii<=strat->tl;iii++)
     383    {
     384    PrintLn();
     385    PrintS("      T[");printf("%i",iii);PrintS("] = ");p_Write(strat->T[iii].p,strat->tailRing);
     386    PrintLn();
     387    }
     388  #endif /* ADIDEBUG_NF */
     389
    390390  d = h->GetpFDeg()+ h->ecart;
    391391  reddeg = strat->LazyDegree+d;
    392392  h->SetShortExpVector();
    393393  #if ADIDEBUG_NF
    394         PrintLn();
    395   PrintS("      Searching for a poly in T that divides h (of ecart ");
     394   PrintLn();
     395  PrintS("  Searching for a poly in T that divides h (of ecart ");
    396396  printf("%i",h->ecart);PrintS(") ...");
    397397  PrintLn();
     
    401401    j = kFindDivisibleByInT(strat->T, strat->sevT, strat->tl, h);
    402402    #if ADIDEBUG_NF
    403         if(j != -1)
    404                 {
    405                 ei = strat->T[j].ecart;
    406                 PrintLn();
    407                 PrintS("                Found one: T[");printf("%i",j);
    408                 PrintS("] of ecart ");printf("%i",ei);
    409                 PrintS(": ");p_Write(strat->T[j].p,strat->tailRing);
    410                 PrintLn();
    411                 PrintS("                Try to find another with smaller ecart:");
    412                 PrintLn();
    413                 }
    414           else
    415                 {
    416                 PrintLn();
    417                 PrintS("                No poly in T divides h.");
    418                 PrintLn();
    419                 }
    420         #endif
     403      if(j != -1)
     404        {
     405        ei = strat->T[j].ecart;
     406        PrintLn();
     407        PrintS("    Found one: T[");printf("%i",j);
     408        PrintS("] of ecart ");printf("%i",ei);
     409        PrintS(": ");p_Write(strat->T[j].p,strat->tailRing);
     410        PrintLn();
     411        PrintS("    Try to find another with smaller ecart:");
     412        PrintLn();
     413        }
     414      else
     415        {
     416        PrintLn();
     417        PrintS("    No poly in T divides h.");
     418        PrintLn();
     419        }
     420    #endif
    421421    if (j < 0)
    422422    {
     
    427427    ei = strat->T[j].ecart;
    428428    ii = j;
    429                 #if ADIDEBUG_NF
    430                 iii=ii;
    431                 #endif
     429    #if ADIDEBUG_NF
     430    iii=ii;
     431    #endif
    432432    if (ei > h->ecart && ii < strat->tl)
    433433    {
    434         li = strat->T[j].length;
     434      li = strat->T[j].length;
    435435      // the polynomial to reduce with (up to the moment) is;
    436436      // pi with ecart ei and length li
     
    462462        }
    463463      }
    464    
    465    
     464
     465
    466466    #if ADIDEBUG_NF
    467467    if(iii == ii)
    468         {
    469         PrintLn();
    470         PrintS("                None was found.");
    471         PrintLn();
    472         }
     468      {
     469      PrintLn();
     470      PrintS("    None was found.");
     471      PrintLn();
     472      }
    473473    else
    474         {
    475         PrintLn();
    476         PrintS("                A better one (ecart = ");printf("%i",ei);PrintS("): T[");
    477         printf("%i] = ",ii);p_Write(strat->T[ii].p,strat->tailRing);
    478         PrintLn();
    479         }
     474      {
     475      PrintLn();
     476      PrintS("    A better one (ecart = ");printf("%i",ei);PrintS("): T[");
     477      printf("%i] = ",ii);p_Write(strat->T[ii].p,strat->tailRing);
     478      PrintLn();
     479      }
    480480    #endif
    481    
     481
    482482    }
    483483
     
    514514    #if ADIDEBUG_NF
    515515    PrintLn();
    516           PrintS("      Partial Reduced h = ");p_Write(h->p,strat->tailRing);
    517           PrintLn();
    518           #endif
     516    PrintS("  Partial Reduced h = ");p_Write(h->p,strat->tailRing);
     517    PrintLn();
     518    #endif
    519519    strat->fromT=FALSE;
    520520
     
    11421142  while (i <= strat->tl)
    11431143  {
    1144         p = strat->T[i];
     1144    p = strat->T[i];
    11451145    deleteHC(&p,strat, TRUE);
    11461146    /*- tries to cancel a unit: -*/
     
    11951195    if (TEST_OPT_FINDET)
    11961196      return;
    1197      
     1197
    11981198#ifndef HAVE_RINGS
    11991199    strat->red = redFirst;
    12001200    strat->use_buckets = kMoraUseBucket(strat);
    12011201#else
    1202         if ( (!rField_is_Ring(currRing)) || (currRing->OrdSgn != -1))
    1203                 {
    1204                 strat->red = redFirst;
    1205         strat->use_buckets = kMoraUseBucket(strat);
    1206         }
    1207 #endif
    1208    
     1202  if ( (!rField_is_Ring(currRing)) || (currRing->OrdSgn != -1))
     1203    {
     1204    strat->red = redFirst;
     1205      strat->use_buckets = kMoraUseBucket(strat);
     1206      }
     1207#endif
     1208
    12091209    updateT(strat);
    1210    
     1210
    12111211#ifndef HAVE_RINGS
    12121212    strat->posInT = posInT2;
    12131213    reorderT(strat);
    12141214#else
    1215         if ( (!rField_is_Ring(currRing)) || (currRing->OrdSgn != -1))
    1216                 {
    1217                 strat->posInT = posInT2;
    1218             reorderT(strat);
    1219         }
     1215  if ( (!rField_is_Ring(currRing)) || (currRing->OrdSgn != -1))
     1216    {
     1217    strat->posInT = posInT2;
     1218      reorderT(strat);
     1219      }
    12201220#endif
    12211221  }
     
    12561256      if (TEST_OPT_FINDET)
    12571257        return;
    1258        
     1258
    12591259      /*- cuts elements in L above noether and reorders L -*/
    12601260      updateLHC(strat);
     
    13771377  {
    13781378    if(currRing->OrdSgn == -1)
    1379                 {strat->red = redRiloc;}
    1380         else   
    1381         {strat->red2 = redRing;}
     1379      {strat->red = redRiloc;}
     1380    else
     1381      {strat->red2 = redRing;}
    13821382  }
    13831383#endif
     
    14531453    strat->HCord = 32000;/*- very large -*/
    14541454  }
    1455  
     1455
    14561456    #ifdef HAVE_RINGS
    1457         if (rField_is_Ring(currRing))
    1458                 strat->red = redRiloc;
     1457    if (rField_is_Ring(currRing))
     1458      strat->red = redRiloc;
    14591459  #endif
    14601460
     
    15871587      else strat->noClearS=TRUE;
    15881588    }
    1589    
     1589
    15901590        #if ADIDEBUG
    1591                 #ifdef KDEBUG
    1592                
    1593                 PrintLn();
    1594                 PrintS("-------------------------------- LOOP ");printf("%d",loop_count);
    1595                 PrintS(" ---------------------------------------");
    1596                 PrintLn();
    1597                 //print the list L: (p1,p2,p)
    1598                 PrintLn();
    1599                 PrintS("                The pair list L -- in loop ");
    1600                 printf("%d",loop_count);PrintS(" -- is: "); PrintLn();
    1601                 for(int iii=0;iii<=strat->Ll;iii++)
    1602                         {
    1603                         PrintLn();
    1604                         PrintS("                L[");printf("%d",iii);Print("]: ");
    1605                         PrintLn();
    1606                         PrintS("                    ");p_Write(strat->L[iii].p1,strat->tailRing);
    1607                         PrintS("                    ");p_Write(strat->L[iii].p2,strat->tailRing);
    1608                         PrintS("                    ");p_Write(strat->L[iii].p,strat->tailRing);
    1609                         }
    1610                 PrintLn();
    1611                 #endif
    1612                 #endif
    1613 
    1614    
     1591    #ifdef KDEBUG
     1592
     1593    PrintLn();
     1594    PrintS("-------------------------------- LOOP ");printf("%d",loop_count);
     1595    PrintS(" ---------------------------------------");
     1596    PrintLn();
     1597    //print the list L: (p1,p2,p)
     1598    PrintLn();
     1599    PrintS("    The pair list L -- in loop ");
     1600    printf("%d",loop_count);PrintS(" -- is: "); PrintLn();
     1601    for(int iii=0;iii<=strat->Ll;iii++)
     1602      {
     1603      PrintLn();
     1604      PrintS("    L[");printf("%d",iii);Print("]: ");
     1605      PrintLn();
     1606      PrintS("        ");p_Write(strat->L[iii].p1,strat->tailRing);
     1607      PrintS("        ");p_Write(strat->L[iii].p2,strat->tailRing);
     1608      PrintS("        ");p_Write(strat->L[iii].p,strat->tailRing);
     1609      }
     1610    PrintLn();
     1611    #endif
     1612    #endif
     1613
     1614
    16151615    strat->P = strat->L[strat->Ll];/*- picks the last element from the lazyset L -*/
    16161616    if (strat->Ll==0) strat->interpt=TRUE;
    16171617    strat->Ll--;
    16181618
    1619                 #if ADIDEBUG
    1620                 #ifdef KDEBUG   
    1621                 PrintS("                My new pair P = (p1,p2,p) is: "); PrintLn();
    1622                 PrintS("                        p1 = "); p_Write(strat->P.p1,strat->tailRing);PrintLn();
    1623                 PrintS("                        p2 = "); p_Write(strat->P.p2,strat->tailRing);PrintLn();
    1624                 PrintS("                        p = "); p_Write(strat->P.p,strat->tailRing); PrintLn();
    1625                 PrintLn();
    1626                 PrintS("                The old reducer list T -- at the beg of loop ");
    1627                 printf("%d",loop_count);PrintS(" -- is :");
    1628                 if(strat->tl<0)
    1629                         {PrintS(" Empty.");PrintLn();}
    1630                 else
    1631                 for(int iii=0;iii<=strat->tl;iii++)
    1632                         {               
    1633                                 PrintLn();
    1634                                 PrintS("                T[");printf("%d",iii);PrintS("]:");
    1635                                 p_Write(strat->T[iii].p,strat->T->tailRing);
    1636                         }
    1637                 PrintLn();
    1638                
    1639                 #endif /* ADIDEBUG */   
    1640                 #endif
     1619    #if ADIDEBUG
     1620    #ifdef KDEBUG
     1621    PrintS("    My new pair P = (p1,p2,p) is: "); PrintLn();
     1622    PrintS("      p1 = "); p_Write(strat->P.p1,strat->tailRing);PrintLn();
     1623    PrintS("      p2 = "); p_Write(strat->P.p2,strat->tailRing);PrintLn();
     1624    PrintS("      p = "); p_Write(strat->P.p,strat->tailRing); PrintLn();
     1625    PrintLn();
     1626    PrintS("    The old reducer list T -- at the beg of loop ");
     1627    printf("%d",loop_count);PrintS(" -- is :");
     1628    if(strat->tl<0)
     1629      {PrintS(" Empty.");PrintLn();}
     1630    else
     1631    for(int iii=0;iii<=strat->tl;iii++)
     1632      {
     1633        PrintLn();
     1634        PrintS("    T[");printf("%d",iii);PrintS("]:");
     1635        p_Write(strat->T[iii].p,strat->T->tailRing);
     1636      }
     1637    PrintLn();
     1638
     1639    #endif /* ADIDEBUG */
     1640    #endif
    16411641
    16421642    // create the real Spoly
     
    17071707      if (rField_is_Ring(currRing))
    17081708      {
    1709         superenterpairs(strat->P.p,strat->sl,strat->P.ecart,0,strat, strat->tl);
    1710        
     1709        superenterpairs(strat->P.p,strat->sl,strat->P.ecart,0,strat, strat->tl);
     1710
    17111711        #if ADIDEBUG
    17121712        PrintLn();
    1713                 PrintS("                The new pair list L -- after superenterpairs in loop ");
    1714                 printf("%d",loop_count);PrintS(" -- is: "); PrintLn();
    1715                 for(int iii=0;iii<=strat->Ll;iii++)
    1716                 {
    1717                 PrintLn();
    1718                 PrintS("                L[");printf("%d",iii);PrintS("]:");PrintLn();
    1719                 PrintS("                     ");p_Write(strat->L[iii].p1,strat->tailRing);
    1720                 PrintS("                     ");p_Write(strat->L[iii].p2,strat->tailRing);
    1721                 PrintS("                     ");p_Write(strat->L[iii].p,strat->tailRing);
    1722                 }
    1723                 #endif
    1724       }
    1725      
     1713    PrintS("    The new pair list L -- after superenterpairs in loop ");
     1714    printf("%d",loop_count);PrintS(" -- is: "); PrintLn();
     1715    for(int iii=0;iii<=strat->Ll;iii++)
     1716    {
     1717    PrintLn();
     1718    PrintS("    L[");printf("%d",iii);PrintS("]:");PrintLn();
     1719    PrintS("         ");p_Write(strat->L[iii].p1,strat->tailRing);
     1720    PrintS("         ");p_Write(strat->L[iii].p2,strat->tailRing);
     1721    PrintS("         ");p_Write(strat->L[iii].p,strat->tailRing);
     1722    }
     1723    #endif
     1724      }
    17261725      else
    17271726#endif
     
    17331732
    17341733      // apply hilbert criterion
    1735       if (hilb!=NULL) 
    1736         {
    1737         if (strat->homog==isHomog)
    1738                 khCheck(Q,w,hilb,hilbeledeg,hilbcount,strat);
    1739         else
    1740                 khCheckLocInhom(Q,w,hilb,hilbcount,strat);
    1741         }
     1734      if (hilb!=NULL)
     1735        {
     1736        if (strat->homog==isHomog)
     1737          khCheck(Q,w,hilb,hilbeledeg,hilbcount,strat);
     1738        else
     1739          khCheckLocInhom(Q,w,hilb,hilbcount,strat);
     1740        }
    17421741
    17431742      // clear strat->P
    17441743      if (strat->P.lcm!=NULL)
    17451744#if defined(HAVE_RINGS) || defined(HAVE_RINGS_LOC)
    1746         pLmDelete(strat->P.lcm);
     1745  pLmDelete(strat->P.lcm);
    17471746#else
    17481747        pLmFree(strat->P.lcm);
     
    17721771    }
    17731772    assume(kTest_TS(strat));
    1774    
    1775         #if ADIDEBUG
    1776         PrintLn();
    1777         PrintS("                The new reducer list T -- at the end of loop ");
    1778         printf("%d",loop_count);PrintS(" -- is "); PrintLn();
    1779         for(int iii=0;iii<=strat->tl;iii++)
    1780                 {
    1781                 PrintLn();
    1782                 PrintS("                T[");printf("%d",iii);PrintS("]:");
    1783                 p_Write(strat->T[iii].p,strat->tailRing);
    1784                 }
    1785         PrintLn();
    1786        
    1787         loop_count++;
    1788         #endif /* ADIDEBUG */   
     1773
     1774      #if ADIDEBUG
     1775  PrintLn();
     1776  PrintS("    The new reducer list T -- at the end of loop ");
     1777  printf("%d",loop_count);PrintS(" -- is "); PrintLn();
     1778  for(int iii=0;iii<=strat->tl;iii++)
     1779    {
     1780    PrintLn();
     1781    PrintS("    T[");printf("%d",iii);PrintS("]:");
     1782    p_Write(strat->T[iii].p,strat->tailRing);
     1783    }
     1784  PrintLn();
     1785
     1786  loop_count++;
     1787  #endif /* ADIDEBUG */
    17891788  }
    17901789  /*- complete reduction of the standard basis------------------------ -*/
     
    19071906  }
    19081907#ifdef KDEBUG
    1909 //      kDebugPrint(strat);
     1908//  kDebugPrint(strat);
    19101909#endif
    19111910  /*- compute------------------------------------------- -*/
     
    22162215    {
    22172216    if(currRing->OrdSgn == -1)
    2218                 r=mora(F,Q,NULL,hilb,strat);
    2219         else
    2220         r=bba(F,Q,NULL,hilb,strat);
     2217      r=mora(F,Q,NULL,hilb,strat);
     2218    else
     2219      r=bba(F,Q,NULL,hilb,strat);
    22212220    }
    22222221  else
     
    23792378        r=sba(F,Q,*w,hilb,strat);
    23802379      else
    2381                           r=sba(F,Q,NULL,hilb,strat);
     2380        r=sba(F,Q,NULL,hilb,strat);
    23822381    }
    23832382  }
     
    31193118    idDelete(&FF);
    31203119    null=idInit(1,1);
    3121     if (need_retry) 
    3122       res1=kNF(null,Q,res,0,KSTD_NF_LAZY); 
    3123     else 
    3124       res1=kNF(null,Q,res); 
     3120    if (need_retry)
     3121      res1=kNF(null,Q,res,0,KSTD_NF_LAZY);
     3122    else
     3123      res1=kNF(null,Q,res);
    31253124    idDelete(&res);
    31263125    res=res1;
  • kernel/kstd2.cc

    r9d864a r601105  
    15041504  // in sba we have (until now) two possibilities:
    15051505  // 1. an incremental computation w.r.t. (C,monomial order)
    1506   // 2. a (possibly non-incremental) computation w.r.t. the 
     1506  // 2. a (possibly non-incremental) computation w.r.t. the
    15071507  //    induced Schreyer order.
    15081508  // The corresponding orders are computed in sbaRing(), depending
     
    15171517  ideal F = F0;
    15181518  ring sRing, currRingOld;
    1519   currRingOld  = currRing; 
     1519  currRingOld  = currRing;
    15201520  if (strat->incremental)
    15211521  {
     
    16271627      // 1. interreduction of the current standard basis
    16281628      // 2. generation of new principal syzygy rules for syzCriterion
    1629       f5c ( strat, olddeg, minimcnt, hilbeledeg, hilbcount, srmax, 
     1629      f5c ( strat, olddeg, minimcnt, hilbeledeg, hilbcount, srmax,
    16301630            lrmax, reduc, Q, w, hilb );
    16311631#endif
    1632       // initialize new syzygy rules for the next iteration step 
     1632      // initialize new syzygy rules for the next iteration step
    16331633      initSyzRules(strat);
    16341634    }
     
    17571757      // get the polynomial (canonicalize bucket, make sure P.p is set)
    17581758      strat->P.GetP(strat->lmBin);
    1759      
    1760       // sig-safe computations may lead to wrong FDeg computation, thus we need 
     1759
     1760      // sig-safe computations may lead to wrong FDeg computation, thus we need
    17611761      // to recompute it to make sure everything is alright
    17621762      (strat->P).FDeg = (strat->P).pFDeg();
     
    18701870            // add LM(F->m[i]) to the signature to get a Schreyer order
    18711871            // without changing the underlying polynomial ring at all
    1872             p_ExpVectorAdd (strat->syz[i],strat->S[ps],currRing); 
     1872            p_ExpVectorAdd (strat->syz[i],strat->S[ps],currRing);
    18731873            // since p_Add_q() destroys all input
    1874             // data we need to recreate help 
     1874            // data we need to recreate help
    18751875            // each time
    18761876            // ----------------------------------------------------------
    1877             // in the Schreyer order we always know that the multiplied 
     1877            // in the Schreyer order we always know that the multiplied
    18781878            // module monomial strat->P.sig gives the leading monomial of
    18791879            // the corresponding principal syzygy
    18801880            // => we do not need to compute the "real" syzygy completely
    18811881            poly help = pCopy(strat->sig[ps]);
    1882             p_ExpVectorAdd (help,strat->P.p,currRing); 
     1882            p_ExpVectorAdd (help,strat->P.p,currRing);
    18831883            strat->syz[i] = p_Add_q(strat->syz[i],help,currRing);
    18841884            //printf("%d. SYZ  ",i+1);
     
    18891889        }
    18901890      }
    1891         enterT(strat->P, strat);
    1892         strat->T[strat->tl].is_sigsafe = FALSE;
     1891      enterT(strat->P, strat);
     1892      strat->T[strat->tl].is_sigsafe = FALSE;
    18931893#ifdef HAVE_RINGS
    18941894      if (rField_is_Ring(currRing))
     
    22392239* 3. strat->S and strat->T are completely new computed in these steps
    22402240********************************************************************/
    2241 void f5c (kStrategy strat, int& olddeg, int& minimcnt, int& hilbeledeg, 
     2241void f5c (kStrategy strat, int& olddeg, int& minimcnt, int& hilbeledeg,
    22422242          int& hilbcount, int& srmax, int& lrmax, int& reduc, ideal Q,
    22432243          intvec *w,intvec *hilb )
     
    22662266        if (currRing->OrdSgn==-1)
    22672267        {
    2268           cancelunit(&h); 
     2268          cancelunit(&h);
    22692269          deleteHC(&h, strat);
    22702270        }
     
    24942494    strat->sig[cc]          = strat->T[cc].sig;
    24952495    strat->sevSig[cc]       = strat->T[cc].sevSig;
    2496     strat->T[cc].is_sigsafe = TRUE; 
     2496    strat->T[cc].is_sigsafe = TRUE;
    24972497    cc++;
    24982498  }
  • kernel/kutil.cc

    r9d864a r601105  
    340340  ring r = L->tailRing;
    341341  poly p = L->GetLmTailRing();
    342  
     342
    343343#ifdef HAVE_RINGS
    344     if (rField_is_Ring(currRing) && (currRing->OrdSgn == -1)) 
    345                 lc = p_GetCoeff(p,r); 
    346 #endif 
     344    if (rField_is_Ring(currRing) && (currRing->OrdSgn == -1))
     345                  lc = p_GetCoeff(p,r);
     346#endif
    347347
    348348#ifdef HAVE_RINGS_LOC
     
    358358//    }
    359359  h = pNext(p);
    360  
     360
    361361  loop
    362362  {
     
    366366      if (!inNF)
    367367      {
    368         number eins;
    369         #ifdef HAVE_RINGS
    370         if (rField_is_Ring(currRing) && (currRing->OrdSgn == -1))
    371                         eins = nCopy(lc);
    372                     else
    373                 #endif
    374         eins=nInit(1);
    375               if (L->p != NULL)  pSetCoeff(L->p,eins);
     368             number eins;
     369              #ifdef HAVE_RINGS
     370              if (rField_is_Ring(currRing) && (currRing->OrdSgn == -1))
     371                              eins = nCopy(lc);
     372                    else
     373                     #endif
     374              eins=nInit(1);
     375              if (L->p != NULL)  pSetCoeff(L->p,eins);
    376376        else if (L->t_p != NULL) nDelete(&pGetCoeff(L->t_p));
    377377        if (L->t_p != NULL) pSetCoeff0(L->t_p,eins);
     
    387387      if (L->p != NULL && pNext(L->p) != NULL)
    388388        pNext(L->p) = NULL;
    389                
     389
    390390      return;
    391391    }
     
    398398      ///should check also if the lc is a zero divisor, if it divides all the others
    399399      if (rField_is_Ring(currRing) && currRing->OrdSgn == -1)
    400         if(n_DivBy(p_GetCoeff(h,r->cf),lc,r->cf) == 0)
    401                 return;
     400              if(n_DivBy(p_GetCoeff(h,r->cf),lc,r->cf) == 0)
     401                      return;
    402402      #endif
    403403      if (i == r->N) break; // does divide, try next monom
     
    11671167  Lp.lcm = pInit();
    11681168  pSetCoeff0(Lp.lcm, n_Lcm(pGetCoeff(p), pGetCoeff(strat->S[i]), currRing->cf));
    1169  
     1169
    11701170  #if ADIDEBUG
    11711171  PrintS("\nLp.lcm (lc) = ");pWrite(Lp.lcm);
    11721172  #endif
    1173  
     1173
    11741174  // Lp.lcm == 0
    11751175  if (nIsZero(pGetCoeff(Lp.lcm)))
     
    11921192  // basic product criterion
    11931193  pLcm(p,strat->S[i],Lp.lcm);
    1194  
     1194
    11951195  #if ADIDEBUG
    11961196  PrintS("\nLp.lcm (lcm) = ");pWrite(Lp.lcm);
    11971197  #endif
    1198  
     1198
    11991199  pSetm(Lp.lcm);
    12001200  assume(!strat->sugarCrit);
     
    27722772        #if ADIDEBUG
    27732773        PrintS("\n initenterpairs: \n");
    2774         PrintS("                ");p_Write(h, strat->tailRing);
    2775         PrintS("                ");p_Write(strat->S[j],strat->tailRing);
     2774        PrintS("                ");p_Write(h, strat->tailRing);
     2775        PrintS("                ");p_Write(strat->S[j],strat->tailRing);
    27762776        #endif
    27772777          strat->enterOnePair(j,h,ecart,isFromQ,strat, atR);
     
    34533453//      if (((unsigned long) pGetCoeff(h) % (unsigned long) pGetCoeff(strat->S[j]) != 0) &&
    34543454//         ((unsigned long) pGetCoeff(strat->S[j]) % (unsigned long) pGetCoeff(h) != 0))
    3455       if ((iCompH == pGetComp(strat->S[j]))
     3455      if (((iCompH == pGetComp(strat->S[j]))
    34563456      || (0 == pGetComp(strat->S[j])))
     3457      && ((iCompH<=strat->syzComp)||(strat->syzComp==0)))
    34573458      {
    34583459        enterOneStrongPoly(j,h,ecart,isFromQ,strat, atR);
     
    35883589void superenterpairs (poly h,int k,int ecart,int pos,kStrategy strat, int atR)
    35893590{
    3590         #if ADIDEBUG
    3591         PrintLn();
    3592         PrintS("Enter superenterpairs");
    3593         PrintLn();
    3594         int iii = strat->Ll;
    3595         #endif
    3596     assume (rField_is_Ring(currRing));
    3597     // enter also zero divisor * poly, if this is non zero and of smaller degree
    3598     if (!(rField_is_Domain(currRing))) enterExtendedSpoly(h, strat);
    3599      #if ADIDEBUG
    3600     if(iii==strat->Ll)
    3601         {
    3602         PrintLn();
    3603         PrintS("                enterExtendedSpoly has not changed the list L.");
    3604         PrintLn();
    3605         }
    3606     else
    3607     {
    3608         PrintLn();
    3609         PrintS("                enterExtendedSpoly changed the list L: ");
    3610         PrintLn();   
    3611         for(iii=0;iii<=strat->Ll;iii++)
    3612                         {
    3613                         PrintLn();
    3614                         PrintS("                L[");printf("%d",iii);PrintS("]:");PrintLn();
    3615                         PrintS("                     ");p_Write(strat->L[iii].p1,strat->tailRing);
    3616                         PrintS("                     ");p_Write(strat->L[iii].p2,strat->tailRing);
    3617                         PrintS("                     ");p_Write(strat->L[iii].p,strat->tailRing);
    3618                         }
    3619         }
    3620         iii = strat->Ll;
    3621     #endif
    3622     initenterpairs(h, k, ecart, 0, strat, atR);
    3623     #if ADIDEBUG
    3624     if(iii==strat->Ll)
    3625         {
    3626         PrintLn();
    3627         PrintS("                initenterpairs has not changed the list L.");
    3628         PrintLn();
    3629         }
    3630     else
    3631     {
    3632         PrintLn();
    3633         PrintS("                initenterpairs changed the list L: ");
    3634         PrintLn();   
    3635         for(iii=0;iii<=strat->Ll;iii++)
    3636                         {
    3637                         PrintLn();
    3638                         PrintS("                L[");printf("%d",iii);PrintS("]:");PrintLn();
    3639                         PrintS("                     ");p_Write(strat->L[iii].p1,strat->tailRing);
    3640                         PrintS("                     ");p_Write(strat->L[iii].p2,strat->tailRing);
    3641                         PrintS("                     ");p_Write(strat->L[iii].p,strat->tailRing);
    3642                         }
    3643         }
    3644         iii = strat->Ll;
    3645     #endif
    3646     initenterstrongPairs(h, k, ecart, 0, strat, atR);
    3647     #if ADIDEBUG
    3648     if(iii==strat->Ll)
    3649         {
    3650         PrintLn();
    3651         PrintS("                initenterstrongPairs has not changed the list L.");
    3652         PrintLn();
    3653         }
    3654     else
    3655     {
    3656         PrintLn();
    3657         PrintS("                initenterstrongPairs changed the list L: ");
    3658         PrintLn();   
    3659         for(iii=0;iii<=strat->Ll;iii++)
    3660                         {
    3661                         PrintLn();
    3662                         PrintS("                L[");printf("%d",iii);PrintS("]:");PrintLn();
    3663                         PrintS("                     ");p_Write(strat->L[iii].p1,strat->tailRing);
    3664                         PrintS("                     ");p_Write(strat->L[iii].p2,strat->tailRing);
    3665                         PrintS("                     ");p_Write(strat->L[iii].p,strat->tailRing);
    3666                         }
    3667         }
    3668         PrintLn();
    3669         PrintS("End of superenterpairs");
    3670         PrintLn();
    3671         #endif
    3672         clearSbatch(h, k, pos, strat);
     3591  #if ADIDEBUG
     3592  PrintLn();
     3593  PrintS("Enter superenterpairs");
     3594  PrintLn();
     3595  int iii = strat->Ll;
     3596  #endif
     3597  assume (rField_is_Ring(currRing));
     3598  // enter also zero divisor * poly, if this is non zero and of smaller degree
     3599  if (!(rField_is_Domain(currRing))) enterExtendedSpoly(h, strat);
     3600   #if ADIDEBUG
     3601  if(iii==strat->Ll)
     3602  {
     3603    PrintLn();
     3604    PrintS("                enterExtendedSpoly has not changed the list L.");
     3605    PrintLn();
     3606  }
     3607  else
     3608  {
     3609    PrintLn();
     3610    PrintS("                enterExtendedSpoly changed the list L: ");
     3611    PrintLn();
     3612    for(iii=0;iii<=strat->Ll;iii++)
     3613    {
     3614      PrintLn();
     3615      PrintS("                L[");printf("%d",iii);PrintS("]:");PrintLn();
     3616      PrintS("                     ");p_Write(strat->L[iii].p1,strat->tailRing);
     3617      PrintS("                     ");p_Write(strat->L[iii].p2,strat->tailRing);
     3618      PrintS("                     ");p_Write(strat->L[iii].p,strat->tailRing);
     3619    }
     3620  }
     3621  iii = strat->Ll;
     3622  #endif
     3623  initenterpairs(h, k, ecart, 0, strat, atR);
     3624  #if ADIDEBUG
     3625  if(iii==strat->Ll)
     3626  {
     3627    PrintLn();
     3628    PrintS("                initenterpairs has not changed the list L.");
     3629    PrintLn();
     3630  }
     3631  else
     3632  {
     3633    PrintLn();
     3634    PrintS("                initenterpairs changed the list L: ");
     3635    PrintLn();
     3636    for(iii=0;iii<=strat->Ll;iii++)
     3637    {
     3638      PrintLn();
     3639      PrintS("                L[");printf("%d",iii);PrintS("]:");PrintLn();
     3640      PrintS("                     ");p_Write(strat->L[iii].p1,strat->tailRing);
     3641      PrintS("                     ");p_Write(strat->L[iii].p2,strat->tailRing);
     3642      PrintS("                     ");p_Write(strat->L[iii].p,strat->tailRing);
     3643    }
     3644  }
     3645  iii = strat->Ll;
     3646  #endif
     3647  initenterstrongPairs(h, k, ecart, 0, strat, atR);
     3648  #if ADIDEBUG
     3649  if(iii==strat->Ll)
     3650  {
     3651    PrintLn();
     3652    PrintS("                initenterstrongPairs has not changed the list L.");
     3653    PrintLn();
     3654  }
     3655  else
     3656  {
     3657    PrintLn();
     3658    PrintS("                initenterstrongPairs changed the list L: ");
     3659    PrintLn();
     3660    for(iii=0;iii<=strat->Ll;iii++)
     3661    {
     3662      PrintLn();
     3663      PrintS("                L[");printf("%d",iii);PrintS("]:");PrintLn();
     3664      PrintS("                     ");p_Write(strat->L[iii].p1,strat->tailRing);
     3665      PrintS("                     ");p_Write(strat->L[iii].p2,strat->tailRing);
     3666      PrintS("                     ");p_Write(strat->L[iii].p,strat->tailRing);
     3667    }
     3668  }
     3669  PrintLn();
     3670  PrintS("End of superenterpairs");
     3671  PrintLn();
     3672  #endif
     3673  clearSbatch(h, k, pos, strat);
    36733674}
    36743675#endif
     
    57805781      if (currRing->OrdSgn==-1)
    57815782      {
    5782                 /*#ifdef HAVE_RINGS
    5783                         if (rField_is_Ring(currRing))
    5784                         {
    5785                         h.pCleardenom();
    5786                         }
    5787                         else
    5788                                 #endif*/
     5783                    /*#ifdef HAVE_RINGS
     5784                          if (rField_is_Ring(currRing))
     5785                            {
     5786                            h.pCleardenom();
     5787                            }
     5788                          else
     5789                                #endif*/
    57895790        cancelunit(&h);  /*- tries to cancel a unit -*/
    57905791        deleteHC(&h, strat);
     
    72557256{
    72567257
    7257   //if the ordering is local, then hilb criterion 
     7258  //if the ordering is local, then hilb criterion
    72587259  //can be used also if tzhe ideal is not homogenous
    72597260  if((currRing->OrdSgn == -1) && (currRing->MixedOrder == 0 ))
     
    72617262  {
    72627263  if(rField_is_Ring(currRing))
    7263         *hilb=NULL;
     7264          *hilb=NULL;
    72647265  else
    7265         return;
     7266           return;
    72667267  }
    72677268#endif
     
    80238024/*  #ifdef HAVE_RINGS
    80248025  if (!rField_is_Ring(currRing))
    8025   #endif */ 
     8026  #endif */
    80268027  for (i=1; i<=(currRing->N); i++)
    80278028  {
     
    81298130  strat->overflow=FALSE;
    81308131  ring new_tailRing = rModifyRing(currRing,
    8131                                   // Hmmm .. the condition pFDeg == p_Deg
    8132                                   // might be too strong
     8132  // Hmmm .. the condition pFDeg == p_Deg
     8133  // might be too strong
    81338134#ifdef HAVE_RINGS
    8134                                   (strat->homog && currRing->pFDeg == p_Deg && !(rField_is_Ring(currRing))), // TODO Oliver
    8135                                  
    8136                                  
     8135  (strat->homog && currRing->pFDeg == p_Deg && !(rField_is_Ring(currRing))), // TODO Oliver
    81378136#else
    8138                                   (strat->homog && currRing->pFDeg == p_Deg), // omit_degree
    8139 #endif
    8140                                   (strat->ak==0), // omit_comp if the input is an ideal
    8141                                   expbound); // exp_limit
    8142 
    8143 if (new_tailRing == currRing) return TRUE;
     8137  (strat->homog && currRing->pFDeg == p_Deg), // omit_degree
     8138#endif
     8139  (strat->ak==0), // omit_comp if the input is an ideal
     8140  expbound); // exp_limit
     8141
     8142  if (new_tailRing == currRing) return TRUE;
    81448143
    81458144  strat->pOrigFDeg_TailRing = new_tailRing->pFDeg;
     
    87168715       PrintS("ecartWeights: ");
    87178716       for (int i = rVar(currRing); i > 0; i--)
    8718         Print("%hd ", ecartWeights[i]);
     8717        Print("%hd ", ecartWeights[i]);
    87198718       PrintLn();
    87208719       assume( TEST_OPT_WEIGHTM );
  • libpolys/coeffs/coeffs.h

    r9d864a r601105  
    7777
    7878/// Creation data needed for finite fields
    79 typedef struct 
     79typedef struct
    8080{
    8181  int GFChar;
     
    123123   // general stuff
    124124   numberfunc cfMult, cfSub ,cfAdd ,cfDiv, cfIntDiv, cfIntMod, cfExactDiv;
    125    
     125
    126126   /// init with an integer
    127127   number  (*cfInit)(long i,const coeffs r);
     
    129129   /// init with a GMP integer
    130130   number  (*cfInitMPZ)(mpz_t i, const coeffs r);
    131    
     131
    132132   /// how complicated, (0) => 0, or positive
    133133   int     (*cfSize)(number n, const coeffs r);
    134    
     134
    135135   /// convertion to int, 0 if impossible
    136136   int     (*cfInt)(number &n, const coeffs r);
     
    138138   /// Converts a non-negative number n into a GMP number, 0 if impossible
    139139   void     (*cfMPZ)(mpz_t result, number &n, const coeffs r);
    140    
     140
    141141   /// changes argument  inline: a:= -a
    142142   /// return -a! (no copy is returned)
     
    152152   /// print a given number (long format)
    153153   void    (*cfWriteLong)(number &a, const coeffs r);
    154    
     154
    155155   /// print a given number in a shorter way, if possible
    156156   /// e.g. in K(a): a2 instead of a^2
    157157   void    (*cfWriteShort)(number &a, const coeffs r);
    158    
     158
    159159   const char *  (*cfRead)(const char * s, number * a, const coeffs r);
    160160   void    (*cfNormalize)(number &a, const coeffs r);
    161    
     161
    162162#ifdef HAVE_RINGS
    163163   int     (*cfDivComp)(number a,number b,const coeffs r);
     
    167167#endif
    168168
    169    
     169
    170170   BOOLEAN (*cfGreater)(number a,number b, const coeffs r),
    171171            /// tests
     
    211211   /// create i^th parameter or NULL if not possible
    212212   number  (*cfParameter)(const int i, const coeffs r);
    213        
     213
    214214   /// function pointer behind n_ClearContent
    215215   nCoeffsEnumeratorFunc cfClearContent;
     
    230230
    231231   /// the 0 as constant, NULL by default
    232    number nNULL; 
     232   number nNULL;
    233233   int     char_flag;
    234234   int     ref;
     
    302302
    303303//  BOOLEAN   CanShortOut; //< if the elements can be printed in short format
    304 //                     // this is set to FALSE if a parameter name has >2 chars
     304//                       // this is set to FALSE if a parameter name has >2 chars
    305305//  BOOLEAN   ShortOut; //< if the elements should print in short format
    306306
     
    314314  unsigned short *m_nfPlus1Table;
    315315  int *m_nfMinPoly;
    316  
     316
    317317// ---------------------------------------------------
    318318// for Zp:
     
    608608#endif
    609609{
    610   assume(r != NULL); 
     610  assume(r != NULL);
    611611#ifdef LDEBUG
    612   assume(r->cfDBTest != NULL); 
     612  assume(r->cfDBTest != NULL);
    613613  return r->cfDBTest(n, filename, linenumber, r);
    614614#else
     
    640640static inline BOOLEAN nCoeff_is_Domain(const coeffs r)
    641641{
    642   assume(r != NULL); 
     642  assume(r != NULL);
    643643#ifdef HAVE_RINGS
    644644  return (getCoeffType(r)==n_Z || ((getCoeffType(r)!=n_Z2m) && (getCoeffType(r)!=n_Zn) && (getCoeffType(r)!=n_Znm)));
     
    679679
    680680static inline int n_ParDeg(number n, const coeffs r)
    681 { 
    682   assume(r != NULL); assume(r->cfParDeg != NULL); return r->cfParDeg(n,r); 
     681{
     682  assume(r != NULL); assume(r->cfParDeg != NULL); return r->cfParDeg(n,r);
    683683}
    684684
     
    697697  assume((iParameter >= 1) || (iParameter <= n_NumberOfParameters(r)));
    698698  assume(r->cfParameter != NULL);
    699   return r->cfParameter(iParameter, r); 
    700 }
    701 
     699  return r->cfParameter(iParameter, r);
     700}
    702701
    703702static inline number  n_Init_bigint(number i, const coeffs dummy,
    704                 const coeffs dst)
    705 {
    706   assume(dummy != NULL && dst != NULL); assume(dst->cfInit_bigint!=NULL); 
     703                const coeffs dst)
     704{
     705  assume(dummy != NULL && dst != NULL); assume(dst->cfInit_bigint!=NULL);
    707706  return dst->cfInit_bigint(i, dummy, dst);
    708707}
     
    710709static inline number  n_RePart(number i, const coeffs cf)
    711710{
    712   assume(cf != NULL); assume(cf->cfRePart!=NULL); 
     711  assume(cf != NULL); assume(cf->cfRePart!=NULL);
    713712  return cf->cfRePart(i,cf);
    714713}
    715714static inline number  n_ImPart(number i, const coeffs cf)
    716715{
    717   assume(cf != NULL); assume(cf->cfImPart!=NULL); 
     716  assume(cf != NULL); assume(cf->cfImPart!=NULL);
    718717  return cf->cfImPart(i,cf);
    719718}
  • libpolys/coeffs/modulop.cc

    r9d864a r601105  
    3535{
    3636  assume( getCoeffType(r) == ID );
    37  
     37
    3838#if SIZEOF_LONG == 4
    3939#define ULONG64 (unsigned long long)(unsigned long)
     
    4141#define ULONG64 (unsigned long)
    4242#endif
    43   return (number) 
     43  return (number)
    4444      (unsigned long)((ULONG64 a)*(ULONG64 b) % (ULONG64 r->ch));
    4545}
     
    5656{
    5757  assume( n_Test(k, r) );
    58  
     58
    5959  int h = (int)((long) k);
    6060  return ((int)h !=0) && (h <= (r->ch>>1));
     
    7878  number c = npMultM(a,b, r);
    7979  assume( n_Test(c, r) );
    80   return c; 
     80  return c;
    8181}
    8282
     
    9292  assume( n_Test(c, r) );
    9393  return c;
    94  
     94
    9595}
    9696
     
    102102{
    103103  assume( n_Test(n, r) );
    104  
     104
    105105  if ((long)n > (((long)r->ch) >>1)) return (int)((long)n -((long)r->ch));
    106106  else                               return (int)((long)n);
     
    111111  assume( n_Test(a, r) );
    112112  assume( n_Test(b, r) );
    113  
     113
    114114  number c = npAddM(a,b, r);
    115115
    116116  assume( n_Test(c, r) );
    117  
     117
    118118  return c;
    119119}
     
    123123  assume( n_Test(a, r) );
    124124  assume( n_Test(b, r) );
    125  
     125
    126126  number c = npSubM(a,b,r);
    127127
     
    134134{
    135135  assume( n_Test(a, r) );
    136  
     136
    137137  return 0 == (long)a;
    138138}
     
    141141{
    142142  assume( n_Test(a, r) );
    143  
     143
    144144  return 1 == (long)a;
    145145}
     
    148148{
    149149  assume( n_Test(a, r) );
    150  
     150
    151151  return ((r->npPminus1M == (long)a)&&((long)1!=(long)a));
    152152}
     
    231231    return (number)0;
    232232  number d;
    233  
     233
    234234#ifndef HAVE_DIV_MOD
    235235  if ((long)b==0)
     
    238238    return (number)0;
    239239  }
    240  
     240
    241241  int s = r->npLogTable[(long)a] - r->npLogTable[(long)b];
    242242  if (s < 0)
     
    250250  assume( n_Test(d, r) );
    251251  return d;
    252  
     252
    253253}
    254254number  npInvers (number c, const coeffs r)
    255255{
    256256  assume( n_Test(c, r) );
    257  
     257
    258258  if ((long)c==0)
    259259  {
     
    262262  }
    263263  number d = npInversM(c,r);
    264  
     264
    265265  assume( n_Test(d, r) );
    266266  return d;
    267  
     267
    268268}
    269269
     
    271271{
    272272  assume( n_Test(c, r) );
    273  
     273
    274274  if ((long)c==0) return c;
    275275
    276 #if 0 
    277   number d = npNegM(c,r); 
     276#if 0
     277  number d = npNegM(c,r);
    278278  assume( n_Test(d, r) );
    279279  return d;
    280280#else
    281   c = npNegM(c,r); 
     281  c = npNegM(c,r);
    282282  assume( n_Test(c, r) );
    283283  return c;
    284 #endif 
     284#endif
    285285}
    286286
     
    298298  assume( n_Test(a, r) );
    299299  assume( n_Test(b, r) );
    300  
     300
    301301//  return (long)a == (long)b;
    302  
     302
    303303  return npEqualM(a,b,r);
    304304}
     
    307307{
    308308  assume( n_Test(a, r) );
    309  
     309
    310310  if ((long)a>(((long)r->ch) >>1)) StringAppend("-%d",(int)(((long)r->ch)-((long)a)));
    311311  else                             StringAppend("%d",(int)((long)a));
     
    436436
    437437  assume( c > 0 );
    438  
     438
    439439  int i, w;
    440440
     
    507507  r->convFactoryNSingN=npConvFactoryNSingN;
    508508#endif
    509  
     509
    510510  // the variables:
    511511  r->nNULL = (number)0;
     
    539539                               % r->ch);
    540540          r->npLogTable[r->npExpTable[i]] = i;
    541           if /*(i == r->ch - 1 ) ||*/ (/*(*/ r->npExpTable[i] == 1 /*)*/) 
     541          if /*(i == r->ch - 1 ) ||*/ (/*(*/ r->npExpTable[i] == 1 /*)*/)
    542542            break;
    543543        }
     
    757757#else
    758758/// TODO: use "long InvMod(long a, const coeffs R)"?!
    759  
     759
    760760   long  s;
    761761
    762    long  u, u0, u1, u2, q, r; // v0, v1, v2, 
     762   long  u, u0, u1, u2, q, r; // v0, v1, v2,
    763763
    764764   u1=1; // v1=0;
  • libpolys/coeffs/modulop.h

    r9d864a r601105  
    1111// defines are in struct.h
    1212// define if a*b is with mod instead of tables
    13 //#define HAVE_MULT_MOD 
     13//#define HAVE_MULT_MOD
    1414// define if a/b is with mod instead of tables
    15 //#define HAVE_DIV_MOD 
     15//#define HAVE_DIV_MOD
    1616// define if an if should be used
    1717//#define HAVE_GENERIC_ADD
     
    7171//    double ab;
    7272//    long q, res;
    73 // 
     73//
    7474//    ab = ((double) ((int)a)) * ((double) ((int)b));
    7575//    q  = (long) (ab/((double) npPrimeM));  // q could be off by (+/-) 1
     
    8383static inline number npMultM(number a, number b, const coeffs r)
    8484{
    85   return (number) 
     85  return (number)
    8686    ((((unsigned long) a)*((unsigned long) b)) % ((unsigned long) r->ch));
    8787}
Note: See TracChangeset for help on using the changeset viewer.