My Project
Loading...
Searching...
No Matches
Macros | Functions | Variables
kstd1.cc File Reference
#include "kernel/mod2.h"
#include "misc/options.h"
#include "misc/intvec.h"
#include "polys/weight.h"
#include "kernel/polys.h"
#include "kernel/GBEngine/kutil.h"
#include "kernel/GBEngine/kstd1.h"
#include "kernel/GBEngine/khstd.h"
#include "kernel/combinatorics/stairc.h"
#include "kernel/ideals.h"
#include "polys/nc/nc.h"
#include "polys/nc/sca.h"
#include "kernel/GBEngine/nc.h"
#include "kernel/GBEngine/kInline.h"
#include "polys/shiftop.h"

Go to the source code of this file.

Macros

#define MORA_USE_BUCKETS
 
#define PRE_INTEGER_CHECK   0
 

Functions

static BOOLEAN kMoraUseBucket (kStrategy strat)
 
static void kOptimizeLDeg (pLDegProc ldeg, kStrategy strat)
 
static int doRed (LObject *h, TObject *with, BOOLEAN intoT, kStrategy strat, bool redMoraNF)
 
int redEcart (LObject *h, kStrategy strat)
 
int redRiloc (LObject *h, kStrategy strat)
 
int redRiloc_Z (LObject *h, kStrategy strat)
 
int redFirst (LObject *h, kStrategy strat)
 
static poly redMoraNF (poly h, kStrategy strat, int flag)
 
static poly redMoraNFRing (poly h, kStrategy strat, int flag)
 
void reorderL (kStrategy strat)
 
void reorderT (kStrategy strat)
 
void missingAxis (int *last, kStrategy strat)
 
BOOLEAN hasPurePower (const poly p, int last, int *length, kStrategy strat)
 
BOOLEAN hasPurePower (LObject *L, int last, int *length, kStrategy strat)
 
int posInL10 (const LSet set, const int length, LObject *p, const kStrategy strat)
 
void updateL (kStrategy strat)
 
void updateLHC (kStrategy strat)
 
void updateT (kStrategy strat)
 
void firstUpdate (kStrategy strat)
 
void enterSMora (LObject &p, int atS, kStrategy strat, int atR=-1)
 
void enterSMoraNF (LObject &p, int atS, kStrategy strat, int atR=-1)
 
void initBba (kStrategy strat)
 
void initSba (ideal F, kStrategy strat)
 
void initMora (ideal F, kStrategy strat)
 
void kDebugPrint (kStrategy strat)
 
ideal mora (ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
 
poly kNF1 (ideal F, ideal Q, poly q, kStrategy strat, int lazyReduce)
 
ideal kNF1 (ideal F, ideal Q, ideal q, kStrategy strat, int lazyReduce)
 
long kModDeg (poly p, const ring r)
 
long kHomModDeg (poly p, const ring r)
 
static poly kTryHC (ideal F, ideal Q)
 
ideal kStd (ideal F, ideal Q, tHomog h, intvec **w, intvec *hilb, int syzComp, int newIdeal, intvec *vw, s_poly_proc_t sp)
 
ideal kSba (ideal F, ideal Q, tHomog h, intvec **w, int sbaOrder, int arri, intvec *hilb, int syzComp, int newIdeal, intvec *vw)
 
ideal kStdShift (ideal F, ideal Q, tHomog h, intvec **w, intvec *hilb, int syzComp, int newIdeal, intvec *vw, BOOLEAN rightGB)
 
ideal kMin_std (ideal F, ideal Q, tHomog h, intvec **w, ideal &M, intvec *hilb, int syzComp, int reduced)
 
poly kNF (ideal F, ideal Q, poly p, int syzComp, int lazyReduce)
 
poly kNFBound (ideal F, ideal Q, poly p, int bound, int syzComp, int lazyReduce)
 
ideal kNF (ideal F, ideal Q, ideal p, int syzComp, int lazyReduce)
 
ideal kNFBound (ideal F, ideal Q, ideal p, int bound, int syzComp, int lazyReduce)
 
poly k_NF (ideal F, ideal Q, poly p, int syzComp, int lazyReduce, const ring _currRing)
 NOTE: this is just a wrapper which sets currRing for the actual kNF call.
 
ideal kInterRedOld (ideal F, const ideal Q)
 
ideal kInterRedBba (ideal F, ideal Q, int &need_retry)
 
ideal kInterRed (ideal F, const ideal Q)
 

Variables

VAR BITSET kOptions
 
VAR BITSET validOpts
 
VAR intveckModW
 
VAR intveckHomW
 

Macro Definition Documentation

◆ MORA_USE_BUCKETS

#define MORA_USE_BUCKETS

Definition at line 12 of file kstd1.cc.

◆ PRE_INTEGER_CHECK

#define PRE_INTEGER_CHECK   0

Definition at line 14 of file kstd1.cc.

Function Documentation

◆ doRed()

static int doRed ( LObject * h,
TObject * with,
BOOLEAN intoT,
kStrategy strat,
bool redMoraNF )
static

Definition at line 119 of file kstd1.cc.

120{
121 int ret;
122#if KDEBUG > 0
123 kTest_L(h);
124 kTest_T(with);
125#endif
126 // Hmmm ... why do we do this -- polys from T should already be normalized
128 with->pNorm();
129#ifdef KDEBUG
130 if (TEST_OPT_DEBUG)
131 {
132 PrintS("reduce ");h->wrp();PrintS(" with ");with->wrp();PrintLn();
133 }
134#endif
135 if (intoT)
136 {
137 // need to do it exactly like this: otherwise
138 // we might get errors
139 LObject L= *h;
140 L.Copy();
141 h->GetP();
142 h->length=h->pLength=pLength(h->p);
143 ret = ksReducePoly(&L, with, strat->kNoetherTail(), NULL, NULL, strat);
144 if (ret)
145 {
146 if (ret < 0) return ret;
147 if (h->tailRing != strat->tailRing)
148 h->ShallowCopyDelete(strat->tailRing,
150 strat->tailRing));
151 }
153 enterT_strong(*h,strat);
154 else
155 enterT(*h,strat);
156 *h = L;
157 }
158 else
159 ret = ksReducePoly(h, with, strat->kNoetherTail(), NULL, NULL, strat);
160#ifdef KDEBUG
161 if (TEST_OPT_DEBUG)
162 {
163 PrintS("to ");h->wrp();PrintLn();
164 }
165#endif
166 return ret;
167}
KINLINE poly kNoetherTail()
Definition kInline.h:66
ring tailRing
Definition kutil.h:343
STATIC_VAR Poly * h
Definition janet.cc:971
int ksReducePoly(LObject *PR, TObject *PW, poly spNoether, number *coef, poly *mon, kStrategy strat, BOOLEAN reduce)
Definition kspoly.cc:189
static poly redMoraNF(poly h, kStrategy strat, int flag)
Definition kstd1.cc:978
void enterT(LObject &p, kStrategy strat, int atT)
Definition kutil.cc:9177
void enterT_strong(LObject &p, kStrategy strat, int atT)
Definition kutil.cc:9277
BOOLEAN kTest_L(LObject *L, kStrategy strat, BOOLEAN testp, int lpos, TSet T, int tlength)
Definition kutil.cc:925
BOOLEAN kTest_T(TObject *T, kStrategy strat, int i, char TN)
Definition kutil.cc:800
class sLObject LObject
Definition kutil.h:58
#define NULL
Definition omList.c:12
#define TEST_OPT_INTSTRATEGY
Definition options.h:110
#define TEST_OPT_DEBUG
Definition options.h:108
pShallowCopyDeleteProc pGetShallowCopyDeleteProc(ring, ring)
static int pLength(poly a)
Definition p_polys.h:190
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition polys.cc:13
void PrintS(const char *s)
Definition reporter.cc:284
void PrintLn()
Definition reporter.cc:310
#define rField_is_Ring(R)
Definition ring.h:490

◆ enterSMora()

void enterSMora ( LObject & p,
int atS,
kStrategy strat,
int atR = -1 )

Definition at line 1628 of file kstd1.cc.

1629{
1630 enterSBba(p, atS, strat, atR);
1631 #ifdef KDEBUG
1632 if (TEST_OPT_DEBUG)
1633 {
1634 Print("new s%d:",atS);
1635 p_wrp(p.p,currRing,strat->tailRing);
1636 PrintLn();
1637 }
1638 #endif
1639 HEckeTest(p.p,strat);
1640 if (strat->kAllAxis)
1641 {
1642 if (newHEdge(strat))
1643 {
1644 firstUpdate(strat);
1645 if (TEST_OPT_FINDET)
1646 return;
1647
1648 /*- cuts elements in L above noether and reorders L -*/
1649 updateLHC(strat);
1650 /*- reorders L with respect to posInL -*/
1651 reorderL(strat);
1652 }
1653 }
1654 else if ((strat->kNoether==NULL)
1655 && (TEST_OPT_FASTHC))
1656 {
1657 if (strat->posInLOldFlag)
1658 {
1659 missingAxis(&strat->lastAxis,strat);
1660 if (strat->lastAxis)
1661 {
1662 strat->posInLOld = strat->posInL;
1663 strat->posInLOldFlag = FALSE;
1664 strat->posInL = posInL10;
1665 strat->posInLDependsOnLength = TRUE;
1666 updateL(strat);
1667 reorderL(strat);
1668 }
1669 }
1670 else if (strat->lastAxis)
1671 updateL(strat);
1672 }
1673}
#define TRUE
Definition auxiliary.h:100
#define FALSE
Definition auxiliary.h:96
int p
Definition cfModGcd.cc:4086
char posInLOldFlag
Definition kutil.h:382
poly kNoether
Definition kutil.h:329
int lastAxis
Definition kutil.h:355
int(* posInL)(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition kutil.h:284
int(* posInLOld)(const LSet Ls, const int Ll, LObject *Lo, const kStrategy strat)
Definition kutil.h:288
char kAllAxis
Definition kutil.h:376
char posInLDependsOnLength
Definition kutil.h:389
#define Print
Definition emacs.cc:80
void firstUpdate(kStrategy strat)
Definition kstd1.cc:1561
void updateLHC(kStrategy strat)
Definition kstd1.cc:1469
void missingAxis(int *last, kStrategy strat)
Definition kstd1.cc:1284
void reorderL(kStrategy strat)
Definition kstd1.cc:1226
int posInL10(const LSet set, const int length, LObject *p, const kStrategy strat)
Definition kstd1.cc:1365
void updateL(kStrategy strat)
Definition kstd1.cc:1398
void HEckeTest(poly pp, kStrategy strat)
Definition kutil.cc:500
void enterSBba(LObject &p, int atS, kStrategy strat, int atR)
Definition kutil.cc:8828
BOOLEAN newHEdge(kStrategy strat)
Definition kutil.cc:10461
#define TEST_OPT_FINDET
Definition options.h:111
#define TEST_OPT_FASTHC
Definition options.h:109
void p_wrp(poly p, ring lmRing, ring tailRing)
Definition polys0.cc:373

◆ enterSMoraNF()

void enterSMoraNF ( LObject & p,
int atS,
kStrategy strat,
int atR = -1 )

Definition at line 1681 of file kstd1.cc.

1682{
1683 enterSBba(p, atS, strat, atR);
1684 if ((!strat->kAllAxis) || (strat->kNoether!=NULL)) HEckeTest(p.p,strat);
1685 if (strat->kAllAxis)
1686 newHEdge(strat);
1687}

◆ firstUpdate()

void firstUpdate ( kStrategy strat)

Definition at line 1561 of file kstd1.cc.

1562{
1563 if (strat->update)
1564 {
1565 kTest_TS(strat);
1566 strat->update = (strat->tl == -1);
1567 if (TEST_OPT_WEIGHTM)
1568 {
1570 if (strat->tailRing != currRing)
1571 {
1572 strat->tailRing->pFDeg = strat->pOrigFDeg_TailRing;
1573 strat->tailRing->pLDeg = strat->pOrigLDeg_TailRing;
1574 }
1575 int i;
1576 for (i=strat->Ll; i>=0; i--)
1577 {
1578 strat->L[i].SetpFDeg();
1579 }
1580 for (i=strat->tl; i>=0; i--)
1581 {
1582 strat->T[i].SetpFDeg();
1583 }
1584 if (ecartWeights)
1585 {
1586 omFreeSize((ADDRESS)ecartWeights,(rVar(currRing)+1)*sizeof(short));
1588 }
1589 }
1590 if (TEST_OPT_FASTHC)
1591 {
1592 strat->posInL = strat->posInLOld;
1593 strat->lastAxis = 0;
1594 }
1595 if (TEST_OPT_FINDET)
1596 return;
1597
1599 {
1600 strat->red = redFirst;
1601 strat->use_buckets = kMoraUseBucket(strat);
1602 }
1603 updateT(strat);
1604
1606 {
1607 strat->posInT = posInT2;
1608 reorderT(strat);
1609 }
1610 }
1611 kTest_TS(strat);
1612}
int i
Definition cfEzgcd.cc:132
pFDegProc pOrigFDeg_TailRing
Definition kutil.h:298
int Ll
Definition kutil.h:351
TSet T
Definition kutil.h:326
int tl
Definition kutil.h:350
pFDegProc pOrigFDeg
Definition kutil.h:296
char use_buckets
Definition kutil.h:383
LSet L
Definition kutil.h:327
int(* posInT)(const TSet T, const int tl, LObject &h)
Definition kutil.h:281
int(* red)(LObject *L, kStrategy strat)
Definition kutil.h:278
pLDegProc pOrigLDeg
Definition kutil.h:297
char update
Definition kutil.h:381
pLDegProc pOrigLDeg_TailRing
Definition kutil.h:299
void reorderT(kStrategy strat)
Definition kstd1.cc:1246
int redFirst(LObject *h, kStrategy strat)
Definition kstd1.cc:797
static BOOLEAN kMoraUseBucket(kStrategy strat)
Definition kstd1.cc:3890
void updateT(kStrategy strat)
Definition kstd1.cc:1535
BOOLEAN kTest_TS(kStrategy strat)
Definition kutil.cc:1072
int posInT2(const TSet set, const int length, LObject &p)
Definition kutil.cc:4946
#define omFreeSize(addr, size)
#define TEST_OPT_WEIGHTM
Definition options.h:121
void pRestoreDegProcs(ring r, pFDegProc old_FDeg, pLDegProc old_lDeg)
Definition p_polys.cc:3671
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition ring.h:597
BOOLEAN rHasGlobalOrdering(const ring r)
Definition ring.h:766
EXTERN_VAR short * ecartWeights
Definition weight.h:12

◆ hasPurePower() [1/2]

BOOLEAN hasPurePower ( const poly p,
int last,
int * length,
kStrategy strat )

Definition at line 1317 of file kstd1.cc.

1318{
1319 poly h;
1320 int i;
1321
1322 if (pNext(p) == strat->tail)
1323 return FALSE;
1324 pp_Test(p, currRing, strat->tailRing);
1325 if (strat->ak <= 0 || p_MinComp(p, currRing, strat->tailRing) == strat->ak)
1326 {
1328 if (rField_is_Ring(currRing) && (!n_IsUnit(pGetCoeff(p), currRing->cf))) i=0;
1329 if (i == last)
1330 {
1331 *length = 0;
1332 return TRUE;
1333 }
1334 *length = 1;
1335 h = pNext(p);
1336 while (h != NULL)
1337 {
1338 i = p_IsPurePower(h, strat->tailRing);
1339 if (rField_is_Ring(currRing) && (!n_IsUnit(pGetCoeff(h), currRing->cf))) i=0;
1340 if (i==last) return TRUE;
1341 (*length)++;
1342 pIter(h);
1343 }
1344 }
1345 return FALSE;
1346}
int ak
Definition kutil.h:353
poly tail
Definition kutil.h:334
static FORCE_INLINE BOOLEAN n_IsUnit(number n, const coeffs r)
TRUE iff n has a multiplicative inverse in the given coeff field/ring r.
Definition coeffs.h:519
STATIC_VAR poly last
Definition hdegree.cc:1172
static BOOLEAN length(leftv result, leftv arg)
Definition interval.cc:257
#define pIter(p)
Definition monomials.h:37
#define pNext(p)
Definition monomials.h:36
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
Definition monomials.h:44
int p_IsPurePower(const poly p, const ring r)
return i, if head depends only on var(i)
Definition p_polys.cc:1229
static long p_MinComp(poly p, ring lmRing, ring tailRing)
Definition p_polys.h:313
#define pp_Test(p, lmRing, tailRing)
Definition p_polys.h:163

◆ hasPurePower() [2/2]

BOOLEAN hasPurePower ( LObject * L,
int last,
int * length,
kStrategy strat )

Definition at line 1348 of file kstd1.cc.

1349{
1350 if (L->bucket != NULL)
1351 {
1352 poly p = L->GetP();
1353 return hasPurePower(p, last, length, strat);
1354 }
1355 else
1356 {
1357 return hasPurePower(L->p, last, length, strat);
1358 }
1359}
BOOLEAN hasPurePower(const poly p, int last, int *length, kStrategy strat)
Definition kstd1.cc:1317

◆ initBba()

void initBba ( kStrategy strat)

Definition at line 1689 of file kstd1.cc.

1690{
1691 /* setting global variables ------------------- */
1692 strat->enterS = enterSBba;
1693 strat->red = redHoney;
1694 if (strat->honey)
1695 strat->red = redHoney;
1696 else if (currRing->pLexOrder && !strat->homog)
1697 strat->red = redLazy;
1698 else
1699 {
1700 strat->LazyPass *=4;
1701 strat->red = redHomog;
1702 }
1704 {
1705 if (rField_is_Z(currRing))
1706 strat->red = redRing_Z;
1707 else
1708 strat->red = redRing;
1709 }
1710 if (TEST_OPT_IDLIFT
1711 && (!rIsNCRing(currRing))
1712 && (!rField_is_Ring(currRing)))
1713 strat->red=redLiftstd;
1714 if (currRing->pLexOrder && strat->honey)
1715 strat->initEcart = initEcartNormal;
1716 else
1717 strat->initEcart = initEcartBBA;
1718 if (strat->honey)
1720 else
1722// if ((TEST_OPT_WEIGHTM)&&(F!=NULL))
1723// {
1724// //interred machen Aenderung
1725// strat->pOrigFDeg=pFDeg;
1726// strat->pOrigLDeg=pLDeg;
1727// //h=ggetid("ecart");
1728// //if ((h!=NULL) /*&& (IDTYP(h)==INTVEC_CMD)*/)
1729// //{
1730// // ecartWeights=iv2array(IDINTVEC(h));
1731// //}
1732// //else
1733// {
1734// ecartWeights=(short *)omAlloc(((currRing->N)+1)*sizeof(short));
1735// /*uses automatic computation of the ecartWeights to set them*/
1736// kEcartWeights(F->m,IDELEMS(F)-1,ecartWeights);
1737// }
1738// pRestoreDegProcs(currRing,totaldegreeWecart, maxdegreeWecart);
1739// if (TEST_OPT_PROT)
1740// {
1741// for(i=1; i<=(currRing->N); i++)
1742// Print(" %d",ecartWeights[i]);
1743// PrintLn();
1744// mflush();
1745// }
1746// }
1747}
char honey
Definition kutil.h:377
void(* initEcartPair)(LObject *h, poly f, poly g, int ecartF, int ecartG)
Definition kutil.h:287
void(* enterS)(LObject &h, int pos, kStrategy strat, int atR)
Definition kutil.h:286
void(* initEcart)(TObject *L)
Definition kutil.h:280
int LazyPass
Definition kutil.h:353
char homog
Definition kutil.h:372
int redLiftstd(LObject *h, kStrategy strat)
Definition kLiftstd.cc:167
int redRing_Z(LObject *h, kStrategy strat)
Definition kstd2.cc:683
int redHoney(LObject *h, kStrategy strat)
Definition kstd2.cc:2074
int redHomog(LObject *h, kStrategy strat)
Definition kstd2.cc:1114
int redLazy(LObject *h, kStrategy strat)
Definition kstd2.cc:1869
int redRing(LObject *h, kStrategy strat)
Definition kstd2.cc:951
void initEcartPairMora(LObject *Lp, poly, poly, int ecartF, int ecartG)
Definition kutil.cc:1325
void initEcartNormal(TObject *h)
Definition kutil.cc:1303
void initEcartBBA(TObject *h)
Definition kutil.cc:1311
void initEcartPairBba(LObject *Lp, poly, poly, int, int)
Definition kutil.cc:1318
#define TEST_OPT_IDLIFT
Definition options.h:129
static BOOLEAN rField_is_Z(const ring r)
Definition ring.h:514
static BOOLEAN rIsNCRing(const ring r)
Definition ring.h:426

◆ initMora()

void initMora ( ideal F,
kStrategy strat )

!

Definition at line 1819 of file kstd1.cc.

1820{
1821 int i,j;
1822
1823 strat->NotUsedAxis = (BOOLEAN *)omAlloc(((currRing->N)+1)*sizeof(BOOLEAN));
1824 for (j=(currRing->N); j>0; j--) strat->NotUsedAxis[j] = TRUE;
1825 strat->enterS = enterSMora;
1826 strat->initEcartPair = initEcartPairMora; /*- ecart approximation -*/
1827 strat->posInLOld = strat->posInL;
1828 strat->posInLOldFlag = TRUE;
1829 strat->initEcart = initEcartNormal;
1830 strat->kAllAxis = (currRing->ppNoether) != NULL; //!!
1831 if ( currRing->ppNoether != NULL )
1832 {
1833 strat->kNoether = pCopy((currRing->ppNoether));
1834 strat->red = redFirst; /*take the first possible in T*/
1835 if (TEST_OPT_PROT)
1836 {
1837 Print("H(%ld)",p_FDeg(currRing->ppNoether,currRing)+1);
1838 mflush();
1839 }
1840 }
1841 else if (strat->homog)
1842 strat->red = redFirst; /*take the first possible in T*/
1843 else
1844 strat->red = redEcart;/*take the first possible in under ecart-restriction*/
1845 if (currRing->ppNoether != NULL)
1846 {
1847 HCord = currRing->pFDeg((currRing->ppNoether),currRing)+1;
1848 }
1849 else
1850 {
1851 HCord = 32000;/*- very large -*/
1852 }
1853
1855 {
1856 if (rField_is_Z(currRing))
1857 strat->red = redRiloc_Z;
1858 else
1859 strat->red = redRiloc;
1860 }
1861
1862 /*reads the ecartWeights used for Graebes method from the
1863 *intvec ecart and set ecartWeights
1864 */
1865 if ((TEST_OPT_WEIGHTM)&&(F!=NULL))
1866 {
1867 //interred machen Aenderung
1868 strat->pOrigFDeg=currRing->pFDeg;
1869 strat->pOrigLDeg=currRing->pLDeg;
1870 ecartWeights=(short *)omAlloc(((currRing->N)+1)*sizeof(short));
1871 /*uses automatic computation of the ecartWeights to set them*/
1873
1875 if (TEST_OPT_PROT)
1876 {
1877 for(i=1; i<=(currRing->N); i++)
1878 Print(" %d",ecartWeights[i]);
1879 PrintLn();
1880 mflush();
1881 }
1882 }
1883 kOptimizeLDeg(currRing->pLDeg, strat);
1884}
int BOOLEAN
Definition auxiliary.h:87
BOOLEAN * NotUsedAxis
Definition kutil.h:332
int j
Definition facHensel.cc:110
int redEcart(LObject *h, kStrategy strat)
Definition kstd1.cc:169
static void kOptimizeLDeg(pLDegProc ldeg, kStrategy strat)
Definition kstd1.cc:100
int redRiloc(LObject *h, kStrategy strat)
Definition kstd1.cc:387
void enterSMora(LObject &p, int atS, kStrategy strat, int atR=-1)
Definition kstd1.cc:1628
int redRiloc_Z(LObject *h, kStrategy strat)
Definition kstd1.cc:568
VAR int HCord
Definition kutil.cc:246
#define omAlloc(size)
#define TEST_OPT_PROT
Definition options.h:103
void pSetDegProcs(ring r, pFDegProc new_FDeg, pLDegProc new_lDeg)
Definition p_polys.cc:3659
static long p_FDeg(const poly p, const ring r)
Definition p_polys.h:380
#define pCopy(p)
return a copy of the poly
Definition polys.h:185
#define mflush()
Definition reporter.h:58
#define IDELEMS(i)
long totaldegreeWecart(poly p, ring r)
Definition weight.cc:217
long maxdegreeWecart(poly p, int *l, ring r)
Definition weight.cc:247
void kEcartWeights(poly *s, int sl, short *eweight, const ring R)
Definition weight.cc:182

◆ initSba()

void initSba ( ideal F,
kStrategy strat )

Definition at line 1749 of file kstd1.cc.

1750{
1751 int i;
1752 //idhdl h;
1753 /* setting global variables ------------------- */
1754 strat->enterS = enterSSba;
1755 strat->red2 = redHoney;
1756 if (strat->honey)
1757 strat->red2 = redHoney;
1758 else if (currRing->pLexOrder && !strat->homog)
1759 strat->red2 = redLazy;
1760 else
1761 {
1762 strat->LazyPass *=4;
1763 strat->red2 = redHomog;
1764 }
1766 {
1768 {strat->red2 = redRiloc;}
1769 else
1770 {strat->red2 = redRing;}
1771 }
1772 if (currRing->pLexOrder && strat->honey)
1773 strat->initEcart = initEcartNormal;
1774 else
1775 strat->initEcart = initEcartBBA;
1776 if (strat->honey)
1778 else
1780 //strat->kIdeal = NULL;
1781 //if (strat->ak==0) strat->kIdeal->rtyp=IDEAL_CMD;
1782 //else strat->kIdeal->rtyp=MODUL_CMD;
1783 //strat->kIdeal->data=(void *)strat->Shdl;
1784 if ((TEST_OPT_WEIGHTM)&&(F!=NULL))
1785 {
1786 //interred machen Aenderung
1787 strat->pOrigFDeg = currRing->pFDeg;
1788 strat->pOrigLDeg = currRing->pLDeg;
1789 //h=ggetid("ecart");
1790 //if ((h!=NULL) /*&& (IDTYP(h)==INTVEC_CMD)*/)
1791 //{
1792 // ecartWeights=iv2array(IDINTVEC(h));
1793 //}
1794 //else
1795 {
1796 ecartWeights=(short *)omAlloc(((currRing->N)+1)*sizeof(short));
1797 /*uses automatic computation of the ecartWeights to set them*/
1799 }
1801 if (TEST_OPT_PROT)
1802 {
1803 for(i=1; i<=(currRing->N); i++)
1804 Print(" %d",ecartWeights[i]);
1805 PrintLn();
1806 mflush();
1807 }
1808 }
1809 // for sig-safe reductions in signature-based
1810 // standard basis computations
1812 strat->red = redSigRing;
1813 else
1814 strat->red = redSig;
1815 //strat->sbaOrder = 1;
1816 strat->currIdx = 1;
1817}
int currIdx
Definition kutil.h:317
int(* red2)(LObject *L, kStrategy strat)
Definition kutil.h:279
int redSigRing(LObject *h, kStrategy strat)
Definition kstd2.cc:1500
int redSig(LObject *h, kStrategy strat)
Definition kstd2.cc:1333
void enterSSba(LObject &p, int atS, kStrategy strat, int atR)
Definition kutil.cc:8951
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
Definition ring.h:767

◆ k_NF()

poly k_NF ( ideal F,
ideal Q,
poly p,
int syzComp,
int lazyReduce,
const ring _currRing )

NOTE: this is just a wrapper which sets currRing for the actual kNF call.

Definition at line 3449 of file kstd1.cc.

3450{
3451 const ring save = currRing;
3453 poly ret = kNF(F, Q, p, syzComp, lazyReduce);
3455 return ret;
3456}
poly kNF(ideal F, ideal Q, poly p, int syzComp, int lazyReduce)
Definition kstd1.cc:3235
void rChangeCurrRing(ring r)
Definition polys.cc:15
#define Q
Definition sirandom.c:26

◆ kDebugPrint()

void kDebugPrint ( kStrategy strat)

Definition at line 11559 of file kutil.cc.

11560{
11561 printf("red: ");
11562 if (strat->red==redFirst) printf("redFirst\n");
11563 else if (strat->red==redHoney) printf("redHoney\n");
11564 else if (strat->red==redEcart) printf("redEcart\n");
11565 else if (strat->red==redHomog) printf("redHomog\n");
11566 else if (strat->red==redLazy) printf("redLazy\n");
11567 else if (strat->red==redLiftstd) printf("redLiftstd\n");
11568 else printf("%p\n",(void*)strat->red);
11569 printf("posInT: ");
11570 if (strat->posInT==posInT0) printf("posInT0\n");
11571 else if (strat->posInT==posInT1) printf("posInT1\n");
11572 else if (strat->posInT==posInT11) printf("posInT11\n");
11573 else if (strat->posInT==posInT110) printf("posInT110\n");
11574 else if (strat->posInT==posInT13) printf("posInT13\n");
11575 else if (strat->posInT==posInT15) printf("posInT15\n");
11576 else if (strat->posInT==posInT17) printf("posInT17\n");
11577 else if (strat->posInT==posInT17_c) printf("posInT17_c\n");
11578 else if (strat->posInT==posInT19) printf("posInT19\n");
11579 else if (strat->posInT==posInT2) printf("posInT2\n");
11580 #ifdef HAVE_RINGS
11581 else if (strat->posInT==posInT11Ring) printf("posInT11Ring\n");
11582 else if (strat->posInT==posInT110Ring) printf("posInT110Ring\n");
11583 else if (strat->posInT==posInT15Ring) printf("posInT15Ring\n");
11584 else if (strat->posInT==posInT17Ring) printf("posInT17Ring\n");
11585 else if (strat->posInT==posInT17_cRing) printf("posInT17_cRing\n");
11586 #endif
11587#ifdef HAVE_MORE_POS_IN_T
11588 else if (strat->posInT==posInT_EcartFDegpLength) printf("posInT_EcartFDegpLength\n");
11589 else if (strat->posInT==posInT_FDegpLength) printf("posInT_FDegpLength\n");
11590 else if (strat->posInT==posInT_pLength) printf("posInT_pLength\n");
11591#endif
11592 else if (strat->posInT==posInT_EcartpLength) printf("posInT_EcartpLength\n");
11593 else printf("%p\n",(void*)strat->posInT);
11594 printf("posInL: ");
11595 if (strat->posInL==posInL0) printf("posInL0\n");
11596 else if (strat->posInL==posInL10) printf("posInL10\n");
11597 else if (strat->posInL==posInL11) printf("posInL11\n");
11598 else if (strat->posInL==posInL110) printf("posInL110\n");
11599 else if (strat->posInL==posInL13) printf("posInL13\n");
11600 else if (strat->posInL==posInL15) printf("posInL15\n");
11601 else if (strat->posInL==posInL17) printf("posInL17\n");
11602 else if (strat->posInL==posInL17_c) printf("posInL17_c\n");
11603 #ifdef HAVE_RINGS
11604 else if (strat->posInL==posInL0) printf("posInL0Ring\n");
11605 else if (strat->posInL==posInL11Ring) printf("posInL11Ring\n");
11606 else if (strat->posInL==posInL11Ringls) printf("posInL11Ringls\n");
11607 else if (strat->posInL==posInL110Ring) printf("posInL110Ring\n");
11608 else if (strat->posInL==posInL15Ring) printf("posInL15Ring\n");
11609 else if (strat->posInL==posInL17Ring) printf("posInL17Ring\n");
11610 else if (strat->posInL==posInL17_cRing) printf("posInL17_cRing\n");
11611 #endif
11612 else if (strat->posInL==posInLSpecial) printf("posInLSpecial\n");
11613 else printf("%p\n",(void*)strat->posInL);
11614 printf("enterS: ");
11615 if (strat->enterS==enterSBba) printf("enterSBba\n");
11616 else if (strat->enterS==enterSMora) printf("enterSMora\n");
11617 else if (strat->enterS==enterSMoraNF) printf("enterSMoraNF\n");
11618 else printf("%p\n",(void*)strat->enterS);
11619 printf("initEcart: ");
11620 if (strat->initEcart==initEcartBBA) printf("initEcartBBA\n");
11621 else if (strat->initEcart==initEcartNormal) printf("initEcartNormal\n");
11622 else printf("%p\n",(void*)strat->initEcart);
11623 printf("initEcartPair: ");
11624 if (strat->initEcartPair==initEcartPairBba) printf("initEcartPairBba\n");
11625 else if (strat->initEcartPair==initEcartPairMora) printf("initEcartPairMora\n");
11626 else printf("%p\n",(void*)strat->initEcartPair);
11627 printf("homog=%d, LazyDegree=%d, LazyPass=%d, ak=%d,\n",
11628 strat->homog, strat->LazyDegree,strat->LazyPass, strat->ak);
11629 printf("honey=%d, sugarCrit=%d, Gebauer=%d, noTailReduction=%d, use_buckets=%d\n",
11630 strat->honey,strat->sugarCrit,strat->Gebauer,strat->noTailReduction,strat->use_buckets);
11631 printf("chainCrit: ");
11632 if (strat->chainCrit==chainCritNormal) printf("chainCritNormal\n");
11633 else if (strat->chainCrit==chainCritOpt_1) printf("chainCritOpt_1\n");
11634 else printf("%p\n",(void*)strat->chainCrit);
11635 printf("posInLDependsOnLength=%d\n",
11636 strat->posInLDependsOnLength);
11637 printf("%s\n",showOption());
11638 printf("LDeg: ");
11639 if (currRing->pLDeg==pLDeg0) printf("pLDeg0");
11640 else if (currRing->pLDeg==pLDeg0c) printf("pLDeg0c");
11641 else if (currRing->pLDeg==pLDegb) printf("pLDegb");
11642 else if (currRing->pLDeg==pLDeg1) printf("pLDeg1");
11643 else if (currRing->pLDeg==pLDeg1c) printf("pLDeg1c");
11644 else if (currRing->pLDeg==pLDeg1_Deg) printf("pLDeg1_Deg");
11645 else if (currRing->pLDeg==pLDeg1c_Deg) printf("pLDeg1c_Deg");
11646 else if (currRing->pLDeg==pLDeg1_Totaldegree) printf("pLDeg1_Totaldegree");
11647 else if (currRing->pLDeg==pLDeg1c_Totaldegree) printf("pLDeg1c_Totaldegree");
11648 else if (currRing->pLDeg==pLDeg1_WFirstTotalDegree) printf("pLDeg1_WFirstTotalDegree");
11649 else if (currRing->pLDeg==pLDeg1c_WFirstTotalDegree) printf("pLDeg1c_WFirstTotalDegree");
11650 else if (currRing->pLDeg==maxdegreeWecart) printf("maxdegreeWecart");
11651 else printf("? (%lx)", (long)currRing->pLDeg);
11652 printf(" / ");
11653 if (strat->tailRing->pLDeg==pLDeg0) printf("pLDeg0");
11654 else if (strat->tailRing->pLDeg==pLDeg0c) printf("pLDeg0c");
11655 else if (strat->tailRing->pLDeg==pLDegb) printf("pLDegb");
11656 else if (strat->tailRing->pLDeg==pLDeg1) printf("pLDeg1");
11657 else if (strat->tailRing->pLDeg==pLDeg1c) printf("pLDeg1c");
11658 else if (strat->tailRing->pLDeg==pLDeg1_Deg) printf("pLDeg1_Deg");
11659 else if (strat->tailRing->pLDeg==pLDeg1c_Deg) printf("pLDeg1c_Deg");
11660 else if (strat->tailRing->pLDeg==pLDeg1_Totaldegree) printf("pLDeg1_Totaldegree");
11661 else if (strat->tailRing->pLDeg==pLDeg1c_Totaldegree) printf("pLDeg1c_Totaldegree");
11662 else if (strat->tailRing->pLDeg==pLDeg1_WFirstTotalDegree) printf("pLDeg1_WFirstTotalDegree");
11663 else if (strat->tailRing->pLDeg==pLDeg1c_WFirstTotalDegree) printf("pLDeg1c_WFirstTotalDegree");
11664 else if (strat->tailRing->pLDeg==maxdegreeWecart) printf("maxdegreeWecart");
11665 else printf("? (%lx)", (long)strat->tailRing->pLDeg);
11666 printf("\n");
11667 printf("currRing->pFDeg: ");
11668 if (currRing->pFDeg==p_Totaldegree) printf("p_Totaldegree");
11669 else if (currRing->pFDeg==p_WFirstTotalDegree) printf("pWFirstTotalDegree");
11670 else if (currRing->pFDeg==p_Deg) printf("p_Deg");
11671 else if (currRing->pFDeg==kHomModDeg) printf("kHomModDeg");
11672 else if (currRing->pFDeg==totaldegreeWecart) printf("totaldegreeWecart");
11673 else if (currRing->pFDeg==p_WTotaldegree) printf("p_WTotaldegree");
11674 else printf("? (%lx)", (long)currRing->pFDeg);
11675 printf("\n");
11676 printf(" syzring:%d, syzComp(strat):%d limit:%d\n",rIsSyzIndexRing(currRing),strat->syzComp,rGetCurrSyzLimit(currRing));
11678 printf(" degBound: %d\n", Kstd1_deg);
11679
11680 if( ecartWeights != NULL )
11681 {
11682 printf("ecartWeights: ");
11683 for (int i = rVar(currRing); i > 0; i--)
11684 printf("%hd ", ecartWeights[i]);
11685 printf("\n");
11687 }
11688
11689#ifndef SING_NDEBUG
11691#endif
11692}
int syzComp
Definition kutil.h:354
void(* chainCrit)(poly p, int ecart, kStrategy strat)
Definition kutil.h:291
char noTailReduction
Definition kutil.h:378
char sugarCrit
Definition kutil.h:377
char Gebauer
Definition kutil.h:378
int LazyDegree
Definition kutil.h:353
long kHomModDeg(poly p, const ring r)
Definition kstd1.cc:2436
int posInL17Ring(const LSet set, const int length, LObject *p, const kStrategy)
Definition kutil.cc:6338
int posInL17_cRing(const LSet set, const int length, LObject *p, const kStrategy)
Definition kutil.cc:6453
int posInL110(const LSet set, const int length, LObject *p, const kStrategy)
Definition kutil.cc:6092
int posInT17(const TSet set, const int length, LObject &p)
Definition kutil.cc:5305
int redFirst(LObject *h, kStrategy strat)
Definition kstd1.cc:797
int posInL11Ring(const LSet set, const int length, LObject *p, const kStrategy)
Definition kutil.cc:5875
int redEcart(LObject *h, kStrategy strat)
Definition kstd1.cc:169
int posInT11(const TSet set, const int length, LObject &p)
Definition kutil.cc:4974
int posInT1(const TSet set, const int length, LObject &p)
Definition kutil.cc:4917
int posInT110Ring(const TSet set, const int length, LObject &p)
Definition kutil.cc:5095
void enterSMoraNF(LObject &p, int atS, kStrategy strat, int atR=-1)
Definition kstd1.cc:1681
int posInT_EcartpLength(const TSet set, const int length, LObject &p)
Definition kutil.cc:5171
int posInT0(const TSet, const int length, LObject &)
Definition kutil.cc:4906
int posInL13(const LSet set, const int length, LObject *p, const kStrategy)
Definition kutil.cc:6181
int posInL110Ring(const LSet set, const int length, LObject *p, const kStrategy)
Definition kutil.cc:6134
int posInT_pLength(const TSet set, const int length, LObject &p)
Definition kutil.cc:11525
int posInT13(const TSet set, const int length, LObject &p)
Definition kutil.cc:5142
int posInL0(const LSet set, const int length, LObject *p, const kStrategy)
Definition kutil.cc:5642
void chainCritOpt_1(poly, int, kStrategy strat)
Definition kutil.cc:3457
int posInT11Ring(const TSet set, const int length, LObject &p)
Definition kutil.cc:5011
int posInL15(const LSet set, const int length, LObject *p, const kStrategy)
Definition kutil.cc:6216
int posInT17_c(const TSet set, const int length, LObject &p)
Definition kutil.cc:5413
int posInT_EcartFDegpLength(const TSet set, const int length, LObject &p)
Definition kutil.cc:11434
int posInT15(const TSet set, const int length, LObject &p)
Definition kutil.cc:5209
int posInLSpecial(const LSet set, const int length, LObject *p, const kStrategy)
Definition kutil.cc:5598
VAR int Kstd1_deg
Definition kutil.cc:247
int posInL11Ringls(const LSet set, const int length, LObject *p, const kStrategy)
Definition kutil.cc:5945
int posInL17(const LSet set, const int length, LObject *p, const kStrategy)
Definition kutil.cc:6293
int posInT110(const TSet set, const int length, LObject &p)
Definition kutil.cc:5052
int posInL15Ring(const LSet set, const int length, LObject *p, const kStrategy)
Definition kutil.cc:6252
int posInT19(const TSet set, const int length, LObject &p)
Definition kutil.cc:5541
int posInT15Ring(const TSet set, const int length, LObject &p)
Definition kutil.cc:5264
int posInT17Ring(const TSet set, const int length, LObject &p)
Definition kutil.cc:5367
void enterSMora(LObject &p, int atS, kStrategy strat, int atR=-1)
Definition kstd1.cc:1628
int posInT17_cRing(const TSet set, const int length, LObject &p)
Definition kutil.cc:5475
int posInL17_c(const LSet set, const int length, LObject *p, const kStrategy)
Definition kutil.cc:6388
int posInT_FDegpLength(const TSet set, const int length, LObject &p)
Definition kutil.cc:11488
void chainCritNormal(poly p, int ecart, kStrategy strat)
Definition kutil.cc:3216
int posInL11(const LSet set, const int length, LObject *p, const kStrategy)
Definition kutil.cc:5832
char * showOption()
Definition misc_ip.cc:709
#define assume(x)
Definition mod2.h:387
#define TEST_OPT_DEGBOUND
Definition options.h:113
long pLDegb(poly p, int *l, const ring r)
Definition p_polys.cc:814
long pLDeg1_Totaldegree(poly p, int *l, const ring r)
Definition p_polys.cc:978
long p_WFirstTotalDegree(poly p, const ring r)
Definition p_polys.cc:596
long pLDeg1_WFirstTotalDegree(poly p, int *l, const ring r)
Definition p_polys.cc:1041
long pLDeg1c_WFirstTotalDegree(poly p, int *l, const ring r)
Definition p_polys.cc:1071
long pLDeg1c_Deg(poly p, int *l, const ring r)
Definition p_polys.cc:944
long pLDeg1(poly p, int *l, const ring r)
Definition p_polys.cc:844
long pLDeg1_Deg(poly p, int *l, const ring r)
Definition p_polys.cc:913
long p_WTotaldegree(poly p, const ring r)
Definition p_polys.cc:613
long pLDeg1c(poly p, int *l, const ring r)
Definition p_polys.cc:880
long pLDeg1c_Totaldegree(poly p, int *l, const ring r)
Definition p_polys.cc:1008
long pLDeg0c(poly p, int *l, const ring r)
Definition p_polys.cc:773
long pLDeg0(poly p, int *l, const ring r)
Definition p_polys.cc:742
long p_Deg(poly a, const ring r)
Definition p_polys.cc:587
static long p_Totaldegree(poly p, const ring r)
Definition p_polys.h:1507
void rDebugPrint(const ring r)
Definition ring.cc:4154
static int rGetCurrSyzLimit(const ring r)
Definition ring.h:728
static BOOLEAN rIsSyzIndexRing(const ring r)
Definition ring.h:725

◆ kHomModDeg()

long kHomModDeg ( poly p,
const ring r )

Definition at line 2436 of file kstd1.cc.

2437{
2438 int i;
2439 long j=0;
2440
2441 for (i=r->N;i>0;i--)
2442 j+=p_GetExp(p,i,r)*(*kHomW)[i-1];
2443 if (kModW == NULL) return j;
2444 i = __p_GetComp(p,r);
2445 if (i==0) return j;
2446 return j+(*kModW)[i-1];
2447}
VAR intvec * kModW
Definition kstd1.cc:2424
#define __p_GetComp(p, r)
Definition monomials.h:63
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent @Note: the integer VarOffset encodes:
Definition p_polys.h:469

◆ kInterRed()

ideal kInterRed ( ideal F,
const ideal Q )

Definition at line 3814 of file kstd1.cc.

3815{
3816#ifdef HAVE_PLURAL
3817 if(rIsPluralRing(currRing)) return kInterRedOld(F,Q);
3818#endif
3821 )
3822 return kInterRedOld(F,Q);
3823
3824 //return kInterRedOld(F,Q);
3825
3826 BITSET save1;
3828 //si_opt_1|=Sy_bit(OPT_NOT_SUGAR);
3830 //si_opt_1&= ~Sy_bit(OPT_REDTAIL);
3831 //si_opt_1&= ~Sy_bit(OPT_REDSB);
3832 //extern char * showOption() ;
3833 //Print("%s\n",showOption());
3834
3835 int need_retry;
3836 int counter=3;
3837 ideal res, res1;
3838 int elems;
3839 ideal null=NULL;
3840 if ((Q==NULL) || (!TEST_OPT_REDSB))
3841 {
3842 elems=idElem(F);
3844 }
3845 else
3846 {
3847 ideal FF=idSimpleAdd(F,Q);
3849 idDelete(&FF);
3850 null=idInit(1,1);
3851 if (need_retry)
3853 else
3854 res1=kNF(null,Q,res);
3855 idDelete(&res);
3856 res=res1;
3857 need_retry=1;
3858 }
3859 if (idElem(res)<=1) need_retry=0;
3860 while (need_retry && (counter>0))
3861 {
3862 #ifdef KDEBUG
3863 if (TEST_OPT_DEBUG) { Print("retry counter %d\n",counter); }
3864 #endif
3866 int new_elems=idElem(res1);
3867 counter -= (new_elems >= elems);
3868 elems = new_elems;
3869 idDelete(&res);
3870 if (idElem(res1)<=1) need_retry=0;
3871 if ((Q!=NULL) && (TEST_OPT_REDSB))
3872 {
3873 if (need_retry)
3875 else
3876 res=kNF(null,Q,res1);
3877 idDelete(&res1);
3878 }
3879 else
3880 res = res1;
3881 if (idElem(res)<=1) need_retry=0;
3882 }
3883 if (null!=NULL) idDelete(&null);
3886 return res;
3887}
CanonicalForm res
Definition facAbsFact.cc:60
#define idDelete(H)
delete an ideal
Definition ideals.h:29
#define idSimpleAdd(A, B)
Definition ideals.h:42
ideal kInterRedBba(ideal F, ideal Q, int &need_retry)
Definition kstd1.cc:3554
ideal kInterRedOld(ideal F, const ideal Q)
Definition kstd1.cc:3462
#define KSTD_NF_LAZY
Definition kstd1.h:17
#define KSTD_NF_NONORM
Definition kstd1.h:21
VAR unsigned si_opt_1
Definition options.c:5
#define SI_SAVE_OPT1(A)
Definition options.h:21
#define SI_RESTORE_OPT1(A)
Definition options.h:24
#define OPT_REDTHROUGH
Definition options.h:82
#define Sy_bit(x)
Definition options.h:31
#define TEST_OPT_REDSB
Definition options.h:104
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition ring.h:405
static BOOLEAN rField_is_numeric(const ring r)
Definition ring.h:520
ideal idInit(int idsize, int rank)
initialise an ideal / module
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
static int idElem(const ideal F)
number of non-zero polys in F
#define BITSET
Definition structs.h:16

◆ kInterRedBba()

ideal kInterRedBba ( ideal F,
ideal Q,
int & need_retry )

Definition at line 3554 of file kstd1.cc.

3555{
3556 need_retry=0;
3557 int red_result = 1;
3558 int olddeg,reduc;
3560 // BOOLEAN toReset=FALSE;
3561 kStrategy strat=new skStrategy;
3562 tHomog h;
3563
3565 strat->LazyPass=20;
3566 else
3567 strat->LazyPass=2;
3568 strat->LazyDegree = 1;
3569 strat->ak = id_RankFreeModule(F,currRing);
3570 strat->syzComp = strat->ak;
3571 strat->kModW=kModW=NULL;
3572 strat->kHomW=kHomW=NULL;
3573 if (strat->ak == 0)
3574 {
3575 h = (tHomog)idHomIdeal(F,Q);
3576 }
3577 else if (!TEST_OPT_DEGBOUND)
3578 {
3579 h = (tHomog)idHomIdeal(F,Q);
3580 }
3581 else
3582 h = isNotHomog;
3583 if (h==isHomog)
3584 {
3585 strat->LazyPass*=2;
3586 }
3587 strat->homog=h;
3588#ifdef KDEBUG
3589 idTest(F);
3590#endif
3591
3592 initBuchMoraCrit(strat); /*set Gebauer, honey, sugarCrit*/
3594 initBuchMoraPosRing(strat);
3595 else
3596 initBuchMoraPos(strat);
3597 initBba(strat);
3598 /*set enterS, spSpolyShort, reduce, red, initEcart, initEcartPair*/
3599 strat->posInL=posInL0; /* ord according pComp */
3600
3601 /*Shdl=*/initBuchMora(F, Q, strat);
3602 reduc = olddeg = 0;
3603
3604#ifndef NO_BUCKETS
3606 strat->use_buckets = 1;
3607#endif
3608
3609 // redtailBBa against T for inhomogeneous input
3610 if (!TEST_OPT_OLDSTD)
3611 withT = ! strat->homog;
3612
3613 // strat->posInT = posInT_pLength;
3614 kTest_TS(strat);
3615
3616#ifdef HAVE_TAIL_RING
3618#endif
3619
3620 /* compute------------------------------------------------------- */
3621 while (strat->Ll >= 0)
3622 {
3623 #ifdef KDEBUG
3624 if (TEST_OPT_DEBUG) messageSets(strat);
3625 #endif
3626 if (strat->Ll== 0) strat->interpt=TRUE;
3627 /* picks the last element from the lazyset L */
3628 strat->P = strat->L[strat->Ll];
3629 strat->Ll--;
3630
3631 if (strat->P.p1 == NULL)
3632 {
3633 // for input polys, prepare reduction
3634 strat->P.PrepareRed(strat->use_buckets);
3635 }
3636
3637 if (strat->P.p == NULL && strat->P.t_p == NULL)
3638 {
3639 red_result = 0;
3640 }
3641 else
3642 {
3643 if (TEST_OPT_PROT)
3644 message(strat->P.pFDeg(),
3645 &olddeg,&reduc,strat, red_result);
3646
3647 /* reduction of the element chosen from L */
3648 red_result = strat->red(&strat->P,strat);
3649 }
3650
3651 // reduction to non-zero new poly
3652 if (red_result == 1)
3653 {
3654 /* statistic */
3655 if (TEST_OPT_PROT) PrintS("s");
3656
3657 // get the polynomial (canonicalize bucket, make sure P.p is set)
3658 strat->P.GetP(strat->lmBin);
3659
3660 int pos=posInS(strat,strat->sl,strat->P.p,strat->P.ecart);
3661
3662 // reduce the tail and normalize poly
3663 // in the ring case we cannot expect LC(f) = 1,
3664 // therefore we call pCleardenom instead of pNorm
3666 {
3667 strat->P.pCleardenom();
3668 if (0)
3669 //if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
3670 {
3671 strat->P.p = redtailBba(&(strat->P),pos-1,strat, withT);
3672 strat->P.pCleardenom();
3673 }
3674 }
3675 else
3676 {
3677 strat->P.pNorm();
3678 if (0)
3679 //if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
3680 strat->P.p = redtailBba(&(strat->P),pos-1,strat, withT);
3681 }
3682
3683#ifdef KDEBUG
3684 if (TEST_OPT_DEBUG){PrintS("new s:");strat->P.wrp();PrintLn();}
3685#endif
3686
3687 // enter into S, L, and T
3688 if ((!TEST_OPT_IDLIFT) || (pGetComp(strat->P.p) <= strat->syzComp))
3689 {
3690 enterT(strat->P, strat);
3691 // posInS only depends on the leading term
3692 strat->enterS(strat->P, pos, strat, strat->tl);
3693
3694 if (pos<strat->sl)
3695 {
3696 need_retry++;
3697 // move all "larger" elements fromS to L
3698 // remove them from T
3699 int ii=pos+1;
3700 for(;ii<=strat->sl;ii++)
3701 {
3702 LObject h;
3703 h.Clear();
3704 h.tailRing=strat->tailRing;
3705 h.p=strat->S[ii]; strat->S[ii]=NULL;
3706 strat->initEcart(&h);
3707 h.sev=strat->sevS[ii];
3708 int jj=strat->tl;
3709 while (jj>=0)
3710 {
3711 if (strat->T[jj].p==h.p)
3712 {
3713 strat->T[jj].p=NULL;
3714 if (jj<strat->tl)
3715 {
3716 memmove(&(strat->T[jj]),&(strat->T[jj+1]),
3717 (strat->tl-jj)*sizeof(strat->T[jj]));
3718 memmove(&(strat->sevT[jj]),&(strat->sevT[jj+1]),
3719 (strat->tl-jj)*sizeof(strat->sevT[jj]));
3720 }
3721 strat->tl--;
3722 break;
3723 }
3724 jj--;
3725 }
3726 int lpos=strat->posInL(strat->L,strat->Ll,&h,strat);
3727 enterL(&strat->L,&strat->Ll,&strat->Lmax,h,lpos);
3728 #ifdef KDEBUG
3729 if (TEST_OPT_DEBUG)
3730 {
3731 Print("move S[%d] -> L[%d]: ",ii,pos);
3732 p_wrp(h.p,currRing, strat->tailRing);
3733 PrintLn();
3734 }
3735 #endif
3736 }
3737 if (strat->fromQ!=NULL)
3738 {
3739 for(ii=pos+1;ii<=strat->sl;ii++) strat->fromQ[ii]=0;
3740 }
3741 strat->sl=pos;
3742 }
3743 }
3744 else
3745 {
3746 // clean P
3747 }
3748 kDeleteLcm(&strat->P);
3749 }
3750
3751#ifdef KDEBUG
3752 if (TEST_OPT_DEBUG)
3753 {
3754 messageSets(strat);
3755 }
3756 strat->P.Clear();
3757#endif
3758 //kTest_TS(strat);: i_r out of sync in kInterRedBba, but not used!
3759 }
3760#ifdef KDEBUG
3761 //if (TEST_OPT_DEBUG) messageSets(strat);
3762#endif
3763 /* complete reduction of the standard basis--------- */
3764
3765 if((need_retry<=0) && (TEST_OPT_REDSB))
3766 {
3767 completeReduce(strat);
3768 if (strat->completeReduce_retry)
3769 {
3770 // completeReduce needed larger exponents, retry
3771 // hopefully: kStratChangeTailRing already provided a larger tailRing
3772 // (otherwise: it will fail again)
3774 completeReduce(strat);
3775 if (strat->completeReduce_retry)
3776 {
3777#ifdef HAVE_TAIL_RING
3778 if(currRing->bitmask>strat->tailRing->bitmask)
3779 {
3780 // retry without T
3782 cleanT(strat);strat->tailRing=currRing;
3783 int i;
3784 for(i=strat->sl;i>=0;i--) strat->S_2_R[i]=-1;
3785 completeReduce(strat);
3786 }
3787 if (strat->completeReduce_retry)
3788#endif
3789 Werror("exponent bound is %ld",currRing->bitmask);
3790 }
3791 }
3792 }
3793 else if (TEST_OPT_PROT) PrintLn();
3794
3795
3796 /* release temp data-------------------------------- */
3797 exitBuchMora(strat);
3798// if (TEST_OPT_WEIGHTM)
3799// {
3800// pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
3801// if (ecartWeights)
3802// {
3803// omFreeSize((ADDRESS)ecartWeights,((currRing->N)+1)*sizeof(short));
3804// ecartWeights=NULL;
3805// }
3806// }
3807 //if (TEST_OPT_PROT) messageStat(0/*hilbcount*/,strat);
3808 if (Q!=NULL) updateResult(strat->Shdl,Q,strat);
3809 ideal res=strat->Shdl;
3810 strat->Shdl=NULL;
3811 delete strat;
3812 return res;
3813}
intvec * kModW
Definition kutil.h:335
int * S_2_R
Definition kutil.h:342
omBin lmBin
Definition kutil.h:344
polyset S
Definition kutil.h:306
unsigned long * sevT
Definition kutil.h:325
intvec * kHomW
Definition kutil.h:336
ideal Shdl
Definition kutil.h:303
intset fromQ
Definition kutil.h:321
char interpt
Definition kutil.h:371
char completeReduce_retry
Definition kutil.h:403
LObject P
Definition kutil.h:302
int Lmax
Definition kutil.h:351
int sl
Definition kutil.h:348
unsigned long * sevS
Definition kutil.h:322
#define idTest(id)
Definition ideals.h:47
static BOOLEAN idHomIdeal(ideal id, ideal Q=NULL)
Definition ideals.h:91
KINLINE poly redtailBba(poly p, int pos, kStrategy strat, BOOLEAN normalize)
Definition kInline.h:1213
void initBba(kStrategy strat)
Definition kstd1.cc:1689
VAR intvec * kHomW
Definition kstd1.cc:2424
void message(int i, int *reduc, int *olddeg, kStrategy strat, int red_result)
Definition kutil.cc:7511
void initBuchMora(ideal F, ideal Q, kStrategy strat)
Definition kutil.cc:9799
void enterL(LSet *set, int *length, int *LSetmax, LObject p, int at)
Definition kutil.cc:1279
void initBuchMoraPos(kStrategy strat)
Definition kutil.cc:9626
void exitBuchMora(kStrategy strat)
Definition kutil.cc:9884
int posInS(const kStrategy strat, const int length, const poly p, const int ecart_p)
Definition kutil.cc:4684
void cleanT(kStrategy strat)
Definition kutil.cc:564
void updateResult(ideal r, ideal Q, kStrategy strat)
Definition kutil.cc:10127
void kStratInitChangeTailRing(kStrategy strat)
Definition kutil.cc:11113
void initBuchMoraCrit(kStrategy strat)
Definition kutil.cc:9475
void completeReduce(kStrategy strat, BOOLEAN withT)
Definition kutil.cc:10339
void initBuchMoraPosRing(kStrategy strat)
Definition kutil.cc:9712
void messageSets(kStrategy strat)
Definition kutil.cc:7584
static void kDeleteLcm(LObject *P)
Definition kutil.h:880
#define TEST_OPT_OLDSTD
Definition options.h:123
#define TEST_OPT_NOT_BUCKETS
Definition options.h:105
#define pGetComp(p)
Component.
Definition polys.h:37
void Werror(const char *fmt,...)
Definition reporter.cc:189
static BOOLEAN rField_has_simple_inverse(const ring r)
Definition ring.h:553
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
tHomog
Definition structs.h:35
@ isHomog
Definition structs.h:37
@ isNotHomog
Definition structs.h:36

◆ kInterRedOld()

ideal kInterRedOld ( ideal F,
const ideal Q )

Definition at line 3462 of file kstd1.cc.

3463{
3464 int j;
3465 kStrategy strat = new skStrategy;
3466
3467 ideal tempF = F;
3468 ideal tempQ = Q;
3469
3470#ifdef HAVE_PLURAL
3471 if(rIsSCA(currRing))
3472 {
3473 const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
3474 const unsigned int m_iLastAltVar = scaLastAltVar(currRing);
3476
3477 // this should be done on the upper level!!! :
3478 // tempQ = SCAQuotient(currRing);
3479
3480 if(Q == currRing->qideal)
3482 }
3483#endif
3484
3485// if (TEST_OPT_PROT)
3486// {
3487// writeTime("start InterRed:");
3488// mflush();
3489// }
3490 //strat->syzComp = 0;
3491 strat->kAllAxis = (currRing->ppNoether) != NULL;
3492 strat->kNoether=pCopy((currRing->ppNoether));
3494 initBuchMoraCrit(strat);
3495 strat->NotUsedAxis = (BOOLEAN *)omAlloc(((currRing->N)+1)*sizeof(BOOLEAN));
3496 for (j=(currRing->N); j>0; j--) strat->NotUsedAxis[j] = TRUE;
3497 strat->enterS = enterSBba;
3498 strat->posInT = posInT17;
3499 strat->initEcart = initEcartNormal;
3500 strat->sl = -1;
3501 strat->tl = -1;
3502 strat->tmax = setmaxT;
3503 strat->T = initT();
3504 strat->R = initR();
3505 strat->sevT = initsevT();
3507 initS(tempF, tempQ, strat);
3508 if (TEST_OPT_REDSB)
3509 strat->noTailReduction=FALSE;
3510 updateS(TRUE,strat);
3512 completeReduce(strat);
3513 //else if (TEST_OPT_PROT) PrintLn();
3514 cleanT(strat);
3515 if (strat->kNoether!=NULL) pLmFree(&strat->kNoether);
3516 omFreeSize((ADDRESS)strat->T,strat->tmax*sizeof(TObject));
3517 omFreeSize((ADDRESS)strat->ecartS,IDELEMS(strat->Shdl)*sizeof(int));
3518 omFreeSize((ADDRESS)strat->sevS,IDELEMS(strat->Shdl)*sizeof(unsigned long));
3519 omFreeSize((ADDRESS)strat->NotUsedAxis,((currRing->N)+1)*sizeof(BOOLEAN));
3520 omfree(strat->sevT);
3521 omfree(strat->S_2_R);
3522 omfree(strat->R);
3523
3524 if (strat->fromQ)
3525 {
3526 for (j=IDELEMS(strat->Shdl)-1;j>=0;j--)
3527 {
3528 if(strat->fromQ[j]) pDelete(&strat->Shdl->m[j]);
3529 }
3530 omFreeSize((ADDRESS)strat->fromQ,IDELEMS(strat->Shdl)*sizeof(int));
3531 }
3532// if (TEST_OPT_PROT)
3533// {
3534// writeTime("end Interred:");
3535// mflush();
3536// }
3537 ideal shdl=strat->Shdl;
3539 if (strat->fromQ)
3540 {
3541 strat->fromQ=NULL;
3543 idDelete(&shdl);
3544 shdl=res;
3545 }
3546 delete(strat);
3547#ifdef HAVE_PLURAL
3548 if( tempF != F )
3550#endif
3551 return shdl;
3552}
intset ecartS
Definition kutil.h:309
TObject ** R
Definition kutil.h:340
int tmax
Definition kutil.h:350
KINLINE TSet initT()
Definition kInline.h:84
KINLINE TObject ** initR()
Definition kInline.h:95
KINLINE unsigned long * initsevT()
Definition kInline.h:100
ideal kInterRed(ideal F, const ideal Q)
Definition kstd1.cc:3814
void initS(ideal F, ideal Q, kStrategy strat)
Definition kutil.cc:7634
void updateS(BOOLEAN toT, kStrategy strat)
Definition kutil.cc:8593
#define setmaxT
Definition kutil.h:33
class sTObject TObject
Definition kutil.h:57
static bool rIsSCA(const ring r)
Definition nc.h:190
ideal id_KillSquares(const ideal id, const short iFirstAltVar, const short iLastAltVar, const ring r, const bool bSkipZeroes)
Definition sca.cc:1518
#define omfree(addr)
#define pDelete(p_ptr)
Definition polys.h:186
static void pLmFree(poly p)
frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced
Definition polys.h:70
ideal SCAQuotient(const ring r)
Definition sca.h:10
static short scaLastAltVar(ring r)
Definition sca.h:25
static short scaFirstAltVar(ring r)
Definition sca.h:18
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix

◆ kMin_std()

ideal kMin_std ( ideal F,
ideal Q,
tHomog h,
intvec ** w,
ideal & M,
intvec * hilb,
int syzComp,
int reduced )

Definition at line 3085 of file kstd1.cc.

3087{
3088 if(idIs0(F))
3089 {
3090 M=idInit(1,F->rank);
3091 return idInit(1,F->rank);
3092 }
3094 {
3095 ideal sb;
3096 sb = kStd(F, Q, h, w, hilb);
3098 if(IDELEMS(sb) <= IDELEMS(F))
3099 {
3100 M = idCopy(sb);
3101 idSkipZeroes(M);
3102 return(sb);
3103 }
3104 else
3105 {
3106 M = idCopy(F);
3107 idSkipZeroes(M);
3108 return(sb);
3109 }
3110 }
3111 ideal r=NULL;
3112 int Kstd1_OldDeg = Kstd1_deg,i;
3114 BOOLEAN b=currRing->pLexOrder,toReset=FALSE;
3117 kStrategy strat=new skStrategy;
3118
3120 strat->syzComp = syzComp;
3122 strat->LazyPass=20;
3123 else
3124 strat->LazyPass=2;
3125 strat->LazyDegree = 1;
3126 strat->minim=(reduced % 2)+1;
3127 strat->ak = id_RankFreeModule(F,currRing);
3128 if (delete_w)
3129 {
3130 temp_w=new intvec((strat->ak)+1);
3131 w = &temp_w;
3132 }
3133 if (h==testHomog)
3134 {
3135 if (strat->ak == 0)
3136 {
3137 h = (tHomog)idHomIdeal(F,Q);
3138 w=NULL;
3139 }
3140 else
3141 {
3142 h = (tHomog)idHomModule(F,Q,w);
3143 }
3144 }
3145 if (h==isHomog)
3146 {
3147 if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
3148 {
3149 kModW = *w;
3150 strat->kModW = *w;
3151 assume(currRing->pFDeg != NULL && currRing->pLDeg != NULL);
3152 strat->pOrigFDeg = currRing->pFDeg;
3153 strat->pOrigLDeg = currRing->pLDeg;
3155
3156 toReset = TRUE;
3157 if (reduced>1)
3158 {
3160 Kstd1_deg = -1;
3161 for (i=IDELEMS(F)-1;i>=0;i--)
3162 {
3163 if ((F->m[i]!=NULL) && (currRing->pFDeg(F->m[i],currRing)>=Kstd1_deg))
3164 Kstd1_deg = currRing->pFDeg(F->m[i],currRing)+1;
3165 }
3166 }
3167 }
3168 currRing->pLexOrder = TRUE;
3169 strat->LazyPass*=2;
3170 }
3171 strat->homog=h;
3172 ideal SB=NULL;
3174 {
3175 r=idMinBase(F,&SB); // SB and M via minbase
3176 strat->M=r;
3177 r=SB;
3178 }
3179 else
3180 {
3181 if (w!=NULL)
3182 r=bba(F,Q,*w,hilb,strat);
3183 else
3184 r=bba(F,Q,NULL,hilb,strat);
3185 }
3186#ifdef KDEBUG
3187 {
3188 int i;
3189 for (i=IDELEMS(r)-1; i>=0; i--) pTest(r->m[i]);
3190 }
3191#endif
3192 idSkipZeroes(r);
3193 if (toReset)
3194 {
3196 kModW = NULL;
3197 }
3198 currRing->pLexOrder = b;
3199 if ((delete_w)&&(temp_w!=NULL)) delete temp_w;
3200 if ((IDELEMS(r)==1) && (r->m[0]!=NULL) && pIsConstant(r->m[0]) && (strat->ak==0))
3201 {
3202 M=idInit(1,F->rank);
3203 M->m[0]=pOne();
3204 //if (strat->ak!=0) { pSetComp(M->m[0],strat->ak); pSetmComp(M->m[0]); }
3205 if (strat->M!=NULL) idDelete(&strat->M);
3206 }
3207 else if (strat->M==NULL)
3208 {
3209 M=idInit(1,F->rank);
3210 WarnS("no minimal generating set computed");
3211 }
3212 else
3213 {
3214 idSkipZeroes(strat->M);
3215 M=strat->M;
3216 }
3217 delete(strat);
3218 if (reduced>2)
3219 {
3221 if (!oldDegBound)
3222 si_opt_1 &= ~Sy_bit(OPT_DEGBOUND);
3223 }
3224 else
3225 {
3226 if (IDELEMS(M)>IDELEMS(r))
3227 {
3228 idDelete(&M);
3229 M=idCopy(r);
3230 }
3231 }
3232 return r;
3233}
CanonicalForm b
Definition cfModGcd.cc:4111
int minim
Definition kutil.h:357
ideal M
Definition kutil.h:305
#define WarnS
Definition emacs.cc:78
const CanonicalForm & w
Definition facAbsFact.cc:51
ideal idMinBase(ideal h1, ideal *SB)
Definition ideals.cc:51
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
static BOOLEAN idHomModule(ideal m, ideal Q, intvec **w)
Definition ideals.h:96
ideal idCopy(ideal A)
Definition ideals.h:60
long kModDeg(poly p, const ring r)
Definition kstd1.cc:2426
ideal kStd(ideal F, ideal Q, tHomog h, intvec **w, intvec *hilb, int syzComp, int newIdeal, intvec *vw, s_poly_proc_t sp)
Definition kstd1.cc:2483
EXTERN_VAR int Kstd1_deg
Definition kstd1.h:50
ideal bba(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
Definition kstd2.cc:2626
#define TEST_OPT_RETURN_SB
Definition options.h:112
#define OPT_DEGBOUND
Definition options.h:90
#define pTest(p)
Definition polys.h:414
#define pIsConstant(p)
like above, except that Comp must be 0
Definition polys.h:238
#define pOne()
Definition polys.h:315
#define M
Definition sirandom.c:25
@ testHomog
Definition structs.h:38

◆ kModDeg()

long kModDeg ( poly p,
const ring r )

Definition at line 2426 of file kstd1.cc.

2427{
2428 long o=p_WDegree(p, r);
2429 long i=__p_GetComp(p, r);
2430 if (i==0) return o;
2431 //assume((i>0) && (i<=kModW->length()));
2432 if (i<=kModW->length())
2433 return o+(*kModW)[i-1];
2434 return o;
2435}
long p_WDegree(poly p, const ring r)
Definition p_polys.cc:717

◆ kMoraUseBucket()

static BOOLEAN kMoraUseBucket ( kStrategy strat)
static

Definition at line 3890 of file kstd1.cc.

3891{
3892#ifdef MORA_USE_BUCKETS
3894 return FALSE;
3895 if (strat->red == redFirst)
3896 {
3897#ifdef NO_LDEG
3898 if (strat->syzComp==0)
3899 return TRUE;
3900#else
3901 if ((strat->homog || strat->honey) && (strat->syzComp==0))
3902 return TRUE;
3903#endif
3904 }
3905 else
3906 {
3907 #ifdef HAVE_RINGS
3908 assume(strat->red == redEcart || strat->red == redRiloc || strat->red == redRiloc_Z);
3909 #else
3910 assume(strat->red == redEcart);
3911 #endif
3912 if (strat->honey && (strat->syzComp==0))
3913 return TRUE;
3914 }
3915#endif
3916 return FALSE;
3917}

◆ kNF() [1/2]

ideal kNF ( ideal F,
ideal Q,
ideal p,
int syzComp,
int lazyReduce )

Definition at line 3333 of file kstd1.cc.

3334{
3335 ideal res;
3336 if (TEST_OPT_PROT)
3337 {
3338 Print("(S:%d)",IDELEMS(p));mflush();
3339 }
3340 if (idIs0(p))
3341 return idInit(IDELEMS(p),si_max(p->rank,F->rank));
3342
3343 ideal pp = p;
3344#ifdef HAVE_PLURAL
3345 if(rIsSCA(currRing))
3346 {
3347 const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
3348 const unsigned int m_iLastAltVar = scaLastAltVar(currRing);
3350
3351 if(Q == currRing->qideal)
3353 }
3354#endif
3355
3356 if ((Q!=NULL)&&(idIs0(Q))) Q=NULL;
3357
3358 if ((idIs0(F))&&(Q==NULL))
3359 {
3360#ifdef HAVE_PLURAL
3361 if(p != pp)
3362 return pp;
3363#endif
3364 return idCopy(p); /*F+Q=0*/
3365 }
3366
3367 kStrategy strat=new skStrategy;
3368 strat->syzComp = syzComp;
3370 if (strat->ak>0) // only for module case, see Tst/Short/bug_reduce.tst
3371 {
3372 strat->ak = si_max(strat->ak,(int)F->rank);
3373 }
3374
3376 {
3377#ifdef HAVE_SHIFTBBA
3378 if (currRing->isLPring)
3379 {
3380 WerrorS("No local ordering possible for shift algebra");
3381 return(NULL);
3382 }
3383#endif
3384 res=kNF1(F,Q,pp,strat,lazyReduce);
3385 }
3386 else
3387 res=kNF2(F,Q,pp,strat,lazyReduce);
3388 delete(strat);
3389
3390#ifdef HAVE_PLURAL
3391 if(pp != p)
3393#endif
3394
3395 return res;
3396}
static int si_max(const int a, const int b)
Definition auxiliary.h:124
CanonicalForm FACTORY_PUBLIC pp(const CanonicalForm &)
CanonicalForm pp ( const CanonicalForm & f )
Definition cf_gcd.cc:676
void WerrorS(const char *s)
Definition feFopen.cc:24
poly kNF1(ideal F, ideal Q, poly q, kStrategy strat, int lazyReduce)
Definition kstd1.cc:2126
poly kNF2(ideal F, ideal Q, poly q, kStrategy strat, int lazyReduce)
Definition kstd2.cc:3950

◆ kNF() [2/2]

poly kNF ( ideal F,
ideal Q,
poly p,
int syzComp,
int lazyReduce )

Definition at line 3235 of file kstd1.cc.

3236{
3237 if (p==NULL)
3238 return NULL;
3239
3240 poly pp = p;
3241
3242#ifdef HAVE_PLURAL
3243 if(rIsSCA(currRing))
3244 {
3245 const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
3246 const unsigned int m_iLastAltVar = scaLastAltVar(currRing);
3248
3249 if(Q == currRing->qideal)
3251 }
3252#endif
3253 if((Q!=NULL) &&(idIs0(Q))) Q=NULL;
3254
3255 if ((idIs0(F))&&(Q==NULL))
3256 {
3257#ifdef HAVE_PLURAL
3258 if(p != pp)
3259 return pp;
3260#endif
3261 return pCopy(p); /*F+Q=0*/
3262 }
3263
3264 kStrategy strat=new skStrategy;
3265 strat->syzComp = syzComp;
3267 poly res;
3268
3270 {
3271#ifdef HAVE_SHIFTBBA
3272 if (currRing->isLPring)
3273 {
3274 WerrorS("No local ordering possible for shift algebra");
3275 return(NULL);
3276 }
3277#endif
3278 res=kNF1(F,Q,pp,strat,lazyReduce);
3279 }
3280 else
3281 res=kNF2(F,Q,pp,strat,lazyReduce);
3282 delete(strat);
3283
3284#ifdef HAVE_PLURAL
3285 if(pp != p)
3286 p_Delete(&pp, currRing);
3287#endif
3288 return res;
3289}
poly p_KillSquares(const poly p, const short iFirstAltVar, const short iLastAltVar, const ring r)
Definition sca.cc:1463
static void p_Delete(poly *p, const ring r)
Definition p_polys.h:901
#define pMaxComp(p)
Definition polys.h:299

◆ kNF1() [1/2]

ideal kNF1 ( ideal F,
ideal Q,
ideal q,
kStrategy strat,
int lazyReduce )

Definition at line 2271 of file kstd1.cc.

2272{
2273 assume(!idIs0(q));
2274 assume(!(idIs0(F)&&(Q==NULL)));
2275
2276// lazy_reduce flags: can be combined by |
2277//#define KSTD_NF_LAZY 1
2278 // do only a reduction of the leading term
2279//#define KSTD_NF_ECART 2
2280 // only local: reduce even with bad ecart
2281 poly p;
2282 int i;
2283 int j;
2284 int o;
2285 LObject h;
2286 ideal res;
2287 BITSET save1;
2289
2290 //if (idIs0(q)) return idInit(IDELEMS(q),si_max(q->rank,F->rank));
2291 //if ((idIs0(F))&&(Q==NULL))
2292 // return idCopy(q); /*F=0*/
2293 //strat->ak = si_max(idRankFreeModule(F),idRankFreeModule(q));
2294 /*- creating temp data structures------------------- -*/
2295 //strat->kAllAxis = (currRing->ppNoether) != NULL;
2296 strat->kNoether=pCopy((currRing->ppNoether));
2299 && (0<Kstd1_deg)
2300 && ((strat->kNoether==NULL)
2302 {
2303 pLmDelete(&strat->kNoether);
2304 strat->kNoether=pOne();
2305 pSetExp(strat->kNoether,1, Kstd1_deg+1);
2306 pSetm(strat->kNoether);
2307 //strat->kAllAxis=TRUE;
2308 }
2309 initBuchMoraCrit(strat);
2311 initBuchMoraPosRing(strat);
2312 else
2313 initBuchMoraPos(strat);
2314 initMora(F,strat);
2315 strat->enterS = enterSMoraNF;
2316 /*- set T -*/
2317 strat->tl = -1;
2318 strat->tmax = setmaxT;
2319 strat->T = initT();
2320 strat->R = initR();
2321 strat->sevT = initsevT();
2322 /*- set S -*/
2323 strat->sl = -1;
2324 /*- init local data struct.-------------------------- -*/
2325 /*Shdl=*/initS(F,Q,strat);
2326 if ((strat->ak!=0)
2327 && (strat->kNoether!=NULL))
2328 {
2329 if (strat->ak!=1)
2330 {
2331 pSetComp(strat->kNoether,1);
2332 pSetmComp(strat->kNoether);
2333 poly p=pHead(strat->kNoether);
2334 pSetComp(p,strat->ak);
2335 pSetmComp(p);
2336 p=pAdd(strat->kNoether,p);
2337 strat->kNoether=pNext(p);
2339 }
2340 }
2341 if (((lazyReduce & KSTD_NF_LAZY)==0)
2342 && (!rField_is_Ring(currRing)))
2343 {
2344 for (i=strat->sl; i>=0; i--)
2345 pNorm(strat->S[i]);
2346 }
2347 /*- compute------------------------------------------- -*/
2348 res=idInit(IDELEMS(q),strat->ak);
2349 for (i=0; i<IDELEMS(q); i++)
2350 {
2351 if (q->m[i]!=NULL)
2352 {
2353 p = pCopy(q->m[i]);
2354 deleteHC(&p,&o,&j,strat);
2355 if (p!=NULL)
2356 {
2357 /*- puts the elements of S also to T -*/
2358 for (j=0; j<=strat->sl; j++)
2359 {
2360 h.p = strat->S[j];
2361 h.ecart = strat->ecartS[j];
2362 h.pLength = h.length = pLength(h.p);
2363 if (strat->sevS[j] == 0) strat->sevS[j] = pGetShortExpVector(h.p);
2364 else assume(strat->sevS[j] == pGetShortExpVector(h.p));
2365 h.sev = strat->sevS[j];
2366 h.SetpFDeg();
2368 enterT_strong(h,strat);
2369 else
2370 enterT(h,strat);
2371 }
2372 if (TEST_OPT_PROT) { PrintS("r"); mflush(); }
2374 {
2375 p = redMoraNFRing(p,strat, lazyReduce);
2376 }
2377 else
2378 p = redMoraNF(p,strat, lazyReduce);
2379 if ((p!=NULL)&&((lazyReduce & KSTD_NF_LAZY)==0))
2380 {
2381 if (TEST_OPT_PROT) { PrintS("t"); mflush(); }
2382 p = redtail(p,strat->sl,strat);
2383 }
2384 cleanT(strat);
2385 }
2386 res->m[i]=p;
2387 }
2388 //else
2389 // res->m[i]=NULL;
2390 }
2391 /*- release temp data------------------------------- -*/
2392 assume(strat->L==NULL); /*strat->L unused */
2393 assume(strat->B==NULL); /*strat->B unused */
2394 omFreeSize((ADDRESS)strat->T,strat->tmax*sizeof(TObject));
2395 omFreeSize((ADDRESS)strat->ecartS,IDELEMS(strat->Shdl)*sizeof(int));
2396 omFreeSize((ADDRESS)strat->sevS,IDELEMS(strat->Shdl)*sizeof(unsigned long));
2397 omFreeSize((ADDRESS)strat->NotUsedAxis,((currRing->N)+1)*sizeof(BOOLEAN));
2398 omFree(strat->sevT);
2399 omFree(strat->S_2_R);
2400 omFree(strat->R);
2401 if ((Q!=NULL)&&(strat->fromQ!=NULL))
2402 {
2404 omFreeSize((ADDRESS)strat->fromQ,i*sizeof(int));
2405 strat->fromQ=NULL;
2406 }
2407 if (strat->kNoether!=NULL) pLmFree(&strat->kNoether);
2408// if ((TEST_OPT_WEIGHTM)&&(F!=NULL))
2409// {
2410// pFDeg=strat->pOrigFDeg;
2411// pLDeg=strat->pOrigLDeg;
2412// if (ecartWeights)
2413// {
2414// omFreeSize((ADDRESS *)&ecartWeights,((currRing->N)+1)*sizeof(short));
2415// ecartWeights=NULL;
2416// }
2417// }
2418 idDelete(&strat->Shdl);
2420 if (TEST_OPT_PROT) PrintLn();
2421 return res;
2422}
LSet B
Definition kutil.h:328
void initMora(ideal F, kStrategy strat)
Definition kstd1.cc:1819
void enterSMoraNF(LObject &p, int atS, kStrategy strat, int atR=-1)
Definition kstd1.cc:1681
static poly redMoraNFRing(poly h, kStrategy strat, int flag)
Definition kstd1.cc:1083
poly redtail(LObject *L, int end_pos, kStrategy strat)
Definition kutil.cc:6882
void deleteHC(LObject *L, kStrategy strat, BOOLEAN fromNext)
Definition kutil.cc:293
#define setmaxTinc
Definition kutil.h:34
#define omFree(addr)
#define OPT_REDTAIL
Definition options.h:91
#define TEST_OPT_STAIRCASEBOUND
Definition options.h:115
static void p_LmDelete(poly p, const ring r)
Definition p_polys.h:723
#define pAdd(p, q)
Definition polys.h:203
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL
Definition polys.h:67
#define pSetm(p)
Definition polys.h:271
void pNorm(poly p)
Definition polys.h:362
#define pSetComp(p, v)
Definition polys.h:38
#define pLmDelete(p)
assume p != NULL, deletes Lm(p)->coef and Lm(p)
Definition polys.h:76
#define pGetShortExpVector(a)
returns the "Short Exponent Vector" – used to speed up divisibility tests (see polys-impl....
Definition polys.h:152
#define pSetmComp(p)
TODO:
Definition polys.h:273
#define pSetExp(p, i, v)
Definition polys.h:42
#define pWTotaldegree(p)
Definition polys.h:283

◆ kNF1() [2/2]

poly kNF1 ( ideal F,
ideal Q,
poly q,
kStrategy strat,
int lazyReduce )

Definition at line 2126 of file kstd1.cc.

2127{
2128 assume(q!=NULL);
2129 assume(!(idIs0(F)&&(Q==NULL)));
2130
2131// lazy_reduce flags: can be combined by |
2132//#define KSTD_NF_LAZY 1
2133 // do only a reduction of the leading term
2134//#define KSTD_NF_ECART 2
2135 // only local: reduce even with bad ecart
2136 poly p;
2137 int i;
2138 int j;
2139 int o;
2140 LObject h;
2141 BITSET save1;
2143
2144 //if ((idIs0(F))&&(Q==NULL))
2145 // return pCopy(q); /*F=0*/
2146 //strat->ak = si_max(idRankFreeModule(F),pMaxComp(q));
2147 /*- creating temp data structures------------------- -*/
2148 //strat->kAllAxis = (currRing->ppNoether) != NULL;
2149 strat->kNoether = pCopy((currRing->ppNoether));
2152 si_opt_1&=~Sy_bit(OPT_INTSTRATEGY);
2154 && (! TEST_V_DEG_STOP)
2155 && (0<Kstd1_deg)
2156 && ((strat->kNoether==NULL)
2158 {
2159 pLmDelete(&strat->kNoether);
2160 strat->kNoether=pOne();
2161 pSetExp(strat->kNoether,1, Kstd1_deg+1);
2162 pSetm(strat->kNoether);
2163 // strat->kAllAxis=TRUE;
2164 }
2165 initBuchMoraCrit(strat);
2167 initBuchMoraPosRing(strat);
2168 else
2169 initBuchMoraPos(strat);
2170 initMora(F,strat);
2171 strat->enterS = enterSMoraNF;
2172 /*- set T -*/
2173 strat->tl = -1;
2174 strat->tmax = setmaxT;
2175 strat->T = initT();
2176 strat->R = initR();
2177 strat->sevT = initsevT();
2178 /*- set S -*/
2179 strat->sl = -1;
2180 /*- init local data struct.-------------------------- -*/
2181 /*Shdl=*/initS(F,Q,strat);
2182 if ((strat->ak!=0)
2183 && (strat->kAllAxis)) /*never true for ring-cf*/
2184 {
2185 if (strat->ak!=1)
2186 {
2187 pSetComp(strat->kNoether,1);
2188 pSetmComp(strat->kNoether);
2189 poly p=pHead(strat->kNoether);
2190 pSetComp(p,strat->ak);
2191 pSetmComp(p);
2192 p=pAdd(strat->kNoether,p);
2193 strat->kNoether=pNext(p);
2195 }
2196 }
2197 if (((lazyReduce & KSTD_NF_LAZY)==0)
2198 && (!rField_is_Ring(currRing)))
2199 {
2200 for (i=strat->sl; i>=0; i--)
2201 pNorm(strat->S[i]);
2202 }
2203 /*- puts the elements of S also to T -*/
2204 for (i=0; i<=strat->sl; i++)
2205 {
2206 h.p = strat->S[i];
2207 h.ecart = strat->ecartS[i];
2208 if (strat->sevS[i] == 0) strat->sevS[i] = pGetShortExpVector(h.p);
2209 else assume(strat->sevS[i] == pGetShortExpVector(h.p));
2210 h.length = pLength(h.p);
2211 h.sev = strat->sevS[i];
2212 h.SetpFDeg();
2213 enterT(h,strat);
2214 }
2215#ifdef KDEBUG
2216// kDebugPrint(strat);
2217#endif
2218 /*- compute------------------------------------------- -*/
2219 p = pCopy(q);
2220 deleteHC(&p,&o,&j,strat);
2221 kTest(strat);
2222 if (TEST_OPT_PROT) { PrintS("r"); mflush(); }
2223 if (BVERBOSE(23)) kDebugPrint(strat);
2225 {
2226 if (p!=NULL) p = redMoraNFRing(p,strat, lazyReduce & KSTD_NF_ECART);
2227 }
2228 else
2229 {
2230 if (p!=NULL) p = redMoraNF(p,strat, lazyReduce & KSTD_NF_ECART);
2231 }
2232 if ((p!=NULL)&&((lazyReduce & KSTD_NF_LAZY)==0))
2233 {
2234 if (TEST_OPT_PROT) { PrintS("t"); mflush(); }
2235 p = redtail(p,strat->sl,strat);
2236 }
2237 /*- release temp data------------------------------- -*/
2238 cleanT(strat);
2239 assume(strat->L==NULL); /*strat->L unused */
2240 assume(strat->B==NULL); /*strat->B unused */
2241 omFreeSize((ADDRESS)strat->T,strat->tmax*sizeof(TObject));
2242 omFreeSize((ADDRESS)strat->ecartS,IDELEMS(strat->Shdl)*sizeof(int));
2243 omFreeSize((ADDRESS)strat->sevS,IDELEMS(strat->Shdl)*sizeof(unsigned long));
2244 omFreeSize((ADDRESS)strat->NotUsedAxis,((currRing->N)+1)*sizeof(BOOLEAN));
2245 omFree(strat->sevT);
2246 omFree(strat->S_2_R);
2247 omFree(strat->R);
2248
2249 if ((Q!=NULL)&&(strat->fromQ!=NULL))
2250 {
2251 i=((IDELEMS(Q)+IDELEMS(F)+15)/16)*16;
2252 omFreeSize((ADDRESS)strat->fromQ,i*sizeof(int));
2253 strat->fromQ=NULL;
2254 }
2255 if (strat->kNoether!=NULL) pLmFree(&strat->kNoether);
2256// if ((TEST_OPT_WEIGHTM)&&(F!=NULL))
2257// {
2258// pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
2259// if (ecartWeights)
2260// {
2261// omFreeSize((ADDRESS *)&ecartWeights,((currRing->N)+1)*sizeof(short));
2262// ecartWeights=NULL;
2263// }
2264// }
2265 idDelete(&strat->Shdl);
2267 if (TEST_OPT_PROT) PrintLn();
2268 return p;
2269}
void kDebugPrint(kStrategy strat)
Definition kutil.cc:11559
#define KSTD_NF_ECART
Definition kstd1.h:19
BOOLEAN kTest(kStrategy strat)
Definition kutil.cc:1011
#define OPT_INTSTRATEGY
Definition options.h:92
#define BVERBOSE(a)
Definition options.h:35
#define TEST_V_DEG_STOP
Definition options.h:137

◆ kNFBound() [1/2]

ideal kNFBound ( ideal F,
ideal Q,
ideal p,
int bound,
int syzComp,
int lazyReduce )

Definition at line 3398 of file kstd1.cc.

3399{
3400 ideal res;
3401 if (TEST_OPT_PROT)
3402 {
3403 Print("(S:%d)",IDELEMS(p));mflush();
3404 }
3405 if (idIs0(p))
3406 return idInit(IDELEMS(p),si_max(p->rank,F->rank));
3407
3408 ideal pp = p;
3409#ifdef HAVE_PLURAL
3410 if(rIsSCA(currRing))
3411 {
3412 const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
3413 const unsigned int m_iLastAltVar = scaLastAltVar(currRing);
3415
3416 if(Q == currRing->qideal)
3418 }
3419#endif
3420
3421 if ((idIs0(F))&&(Q==NULL))
3422 {
3423#ifdef HAVE_PLURAL
3424 if(p != pp)
3425 return pp;
3426#endif
3427 return idCopy(p); /*F+Q=0*/
3428 }
3429
3430 kStrategy strat=new skStrategy;
3431 strat->syzComp = syzComp;
3433 if (strat->ak>0) // only for module case, see Tst/Short/bug_reduce.tst
3434 {
3435 strat->ak = si_max(strat->ak,(int)F->rank);
3436 }
3437
3438 res=kNF2Bound(F,Q,pp,bound,strat,lazyReduce);
3439 delete(strat);
3440
3441#ifdef HAVE_PLURAL
3442 if(pp != p)
3444#endif
3445
3446 return res;
3447}
static CanonicalForm bound(const CFMatrix &M)
Definition cf_linsys.cc:460
poly kNF2Bound(ideal F, ideal Q, poly q, int bound, kStrategy strat, int lazyReduce)
Definition kstd2.cc:4032

◆ kNFBound() [2/2]

poly kNFBound ( ideal F,
ideal Q,
poly p,
int bound,
int syzComp,
int lazyReduce )

Definition at line 3291 of file kstd1.cc.

3292{
3293 if (p==NULL)
3294 return NULL;
3295
3296 poly pp = p;
3297
3298#ifdef HAVE_PLURAL
3299 if(rIsSCA(currRing))
3300 {
3301 const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
3302 const unsigned int m_iLastAltVar = scaLastAltVar(currRing);
3304
3305 if(Q == currRing->qideal)
3307 }
3308#endif
3309
3310 if ((idIs0(F))&&(Q==NULL))
3311 {
3312#ifdef HAVE_PLURAL
3313 if(p != pp)
3314 return pp;
3315#endif
3316 return pCopy(p); /*F+Q=0*/
3317 }
3318
3319 kStrategy strat=new skStrategy;
3320 strat->syzComp = syzComp;
3322 poly res;
3323 res=kNF2Bound(F,Q,pp,bound,strat,lazyReduce);
3324 delete(strat);
3325
3326#ifdef HAVE_PLURAL
3327 if(pp != p)
3328 p_Delete(&pp, currRing);
3329#endif
3330 return res;
3331}

◆ kOptimizeLDeg()

static void kOptimizeLDeg ( pLDegProc ldeg,
kStrategy strat )
static

Definition at line 100 of file kstd1.cc.

101{
102// if (strat->ak == 0 && !rIsSyzIndexRing(currRing))
103 strat->length_pLength = TRUE;
104// else
105// strat->length_pLength = FALSE;
106
107 if ((ldeg == pLDeg0c /*&& !rIsSyzIndexRing(currRing)*/) ||
108 (ldeg == pLDeg0 && strat->ak == 0))
109 {
110 strat->LDegLast = TRUE;
111 }
112 else
113 {
114 strat->LDegLast = FALSE;
115 }
116}
char LDegLast
Definition kutil.h:385
char length_pLength
Definition kutil.h:387

◆ kSba()

ideal kSba ( ideal F,
ideal Q,
tHomog h,
intvec ** w,
int sbaOrder,
int arri,
intvec * hilb,
int syzComp,
int newIdeal,
intvec * vw )

Definition at line 2684 of file kstd1.cc.

2686{
2687 if(idIs0(F))
2688 return idInit(1,F->rank);
2690 {
2691 ideal r;
2692 BOOLEAN b=currRing->pLexOrder,toReset=FALSE;
2694 kStrategy strat=new skStrategy;
2695 strat->sbaOrder = sbaOrder;
2696 if (arri!=0)
2697 {
2698 strat->rewCrit1 = arriRewDummy;
2699 strat->rewCrit2 = arriRewCriterion;
2701 }
2702 else
2703 {
2707 }
2708
2710 strat->syzComp = syzComp;
2711 if (TEST_OPT_SB_1)
2712 //if(!rField_is_Ring(currRing)) // always true here
2713 strat->newIdeal = newIdeal;
2715 strat->LazyPass=20;
2716 else
2717 strat->LazyPass=2;
2718 strat->LazyDegree = 1;
2722 strat->ak = id_RankFreeModule(F,currRing);
2723 strat->kModW=kModW=NULL;
2724 strat->kHomW=kHomW=NULL;
2725 if (vw != NULL)
2726 {
2727 currRing->pLexOrder=FALSE;
2728 strat->kHomW=kHomW=vw;
2729 strat->pOrigFDeg = currRing->pFDeg;
2730 strat->pOrigLDeg = currRing->pLDeg;
2732 toReset = TRUE;
2733 }
2734 if (h==testHomog)
2735 {
2736 if (strat->ak == 0)
2737 {
2738 h = (tHomog)idHomIdeal(F,Q);
2739 w=NULL;
2740 }
2741 else if (!TEST_OPT_DEGBOUND)
2742 {
2743 if (w!=NULL)
2744 h = (tHomog)idHomModule(F,Q,w);
2745 else
2746 h = (tHomog)idHomIdeal(F,Q);
2747 }
2748 }
2749 currRing->pLexOrder=b;
2750 if (h==isHomog)
2751 {
2752 if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
2753 {
2754 strat->kModW = kModW = *w;
2755 if (vw == NULL)
2756 {
2757 strat->pOrigFDeg = currRing->pFDeg;
2758 strat->pOrigLDeg = currRing->pLDeg;
2760 toReset = TRUE;
2761 }
2762 }
2763 currRing->pLexOrder = TRUE;
2764 if (hilb==NULL) strat->LazyPass*=2;
2765 }
2766 strat->homog=h;
2767 #ifdef KDEBUG
2768 idTest(F);
2769 if(Q != NULL)
2770 idTest(Q);
2771 #endif
2772 #ifdef HAVE_PLURAL
2774 {
2775 const BOOLEAN bIsSCA = rIsSCA(currRing) && strat->z2homog; // for Z_2 prod-crit
2776 strat->no_prod_crit = ! bIsSCA;
2777 if (w!=NULL)
2778 r = nc_GB(F, Q, *w, hilb, strat, currRing);
2779 else
2780 r = nc_GB(F, Q, NULL, hilb, strat, currRing);
2781 }
2782 else
2783 #endif
2784 {
2786 {
2787 if (w!=NULL)
2788 r=mora(F,Q,*w,hilb,strat);
2789 else
2790 r=mora(F,Q,NULL,hilb,strat);
2791 }
2792 else
2793 {
2794 strat->sigdrop = FALSE;
2795 if (w!=NULL)
2796 r=sba(F,Q,*w,hilb,strat);
2797 else
2798 r=sba(F,Q,NULL,hilb,strat);
2799 }
2800 }
2801 #ifdef KDEBUG
2802 idTest(r);
2803 #endif
2804 if (toReset)
2805 {
2806 kModW = NULL;
2808 }
2809 currRing->pLexOrder = b;
2810 //Print("%d reductions canceled \n",strat->cel);
2811 //delete(strat);
2812 if ((delete_w)&&(w!=NULL)&&(*w!=NULL)) delete *w;
2813 return r;
2814 }
2815 else
2816 {
2817 //--------------------------RING CASE-------------------------
2818 assume(sbaOrder == 1);
2819 assume(arri == 0);
2820 ideal r;
2821 r = idCopy(F);
2822 int sbaEnterS = -1;
2823 bool sigdrop = TRUE;
2824 //This is how we set the SBA algorithm;
2825 int totalsbaruns = 1,blockedreductions = 20,blockred = 0,loops = 0;
2826 while(sigdrop && (loops < totalsbaruns || totalsbaruns == -1)
2827 && (blockred <= blockedreductions))
2828 {
2829 loops++;
2830 if(loops == 1)
2831 sigdrop = FALSE;
2832 BOOLEAN b=currRing->pLexOrder,toReset=FALSE;
2834 kStrategy strat=new skStrategy;
2835 strat->sbaEnterS = sbaEnterS;
2836 strat->sigdrop = sigdrop;
2837 #if 0
2838 strat->blockred = blockred;
2839 #else
2840 strat->blockred = 0;
2841 #endif
2843 //printf("\nsbaEnterS beginning = %i\n",strat->sbaEnterS);
2844 //printf("\nsigdrop beginning = %i\n",strat->sigdrop);
2845 strat->sbaOrder = sbaOrder;
2846 if (arri!=0)
2847 {
2848 strat->rewCrit1 = arriRewDummy;
2849 strat->rewCrit2 = arriRewCriterion;
2851 }
2852 else
2853 {
2857 }
2858
2860 strat->syzComp = syzComp;
2861 if (TEST_OPT_SB_1)
2863 strat->newIdeal = newIdeal;
2865 strat->LazyPass=20;
2866 else
2867 strat->LazyPass=2;
2868 strat->LazyDegree = 1;
2872 strat->ak = id_RankFreeModule(F,currRing);
2873 strat->kModW=kModW=NULL;
2874 strat->kHomW=kHomW=NULL;
2875 if (vw != NULL)
2876 {
2877 currRing->pLexOrder=FALSE;
2878 strat->kHomW=kHomW=vw;
2879 strat->pOrigFDeg = currRing->pFDeg;
2880 strat->pOrigLDeg = currRing->pLDeg;
2882 toReset = TRUE;
2883 }
2884 if (h==testHomog)
2885 {
2886 if (strat->ak == 0)
2887 {
2888 h = (tHomog)idHomIdeal(F,Q);
2889 w=NULL;
2890 }
2891 else if (!TEST_OPT_DEGBOUND)
2892 {
2893 if (w!=NULL)
2894 h = (tHomog)idHomModule(F,Q,w);
2895 else
2896 h = (tHomog)idHomIdeal(F,Q);
2897 }
2898 }
2899 currRing->pLexOrder=b;
2900 if (h==isHomog)
2901 {
2902 if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
2903 {
2904 strat->kModW = kModW = *w;
2905 if (vw == NULL)
2906 {
2907 strat->pOrigFDeg = currRing->pFDeg;
2908 strat->pOrigLDeg = currRing->pLDeg;
2910 toReset = TRUE;
2911 }
2912 }
2913 currRing->pLexOrder = TRUE;
2914 if (hilb==NULL) strat->LazyPass*=2;
2915 }
2916 strat->homog=h;
2917 #ifdef KDEBUG
2918 idTest(F);
2919 if(Q != NULL)
2920 idTest(Q);
2921 #endif
2922 #ifdef HAVE_PLURAL
2924 {
2925 const BOOLEAN bIsSCA = rIsSCA(currRing) && strat->z2homog; // for Z_2 prod-crit
2926 strat->no_prod_crit = ! bIsSCA;
2927 if (w!=NULL)
2928 r = nc_GB(F, Q, *w, hilb, strat, currRing);
2929 else
2930 r = nc_GB(F, Q, NULL, hilb, strat, currRing);
2931 }
2932 else
2933 #endif
2934 {
2936 {
2937 if (w!=NULL)
2938 r=mora(F,Q,*w,hilb,strat);
2939 else
2940 r=mora(F,Q,NULL,hilb,strat);
2941 }
2942 else
2943 {
2944 if (w!=NULL)
2945 r=sba(r,Q,*w,hilb,strat);
2946 else
2947 {
2948 r=sba(r,Q,NULL,hilb,strat);
2949 }
2950 }
2951 }
2952 #ifdef KDEBUG
2953 idTest(r);
2954 #endif
2955 if (toReset)
2956 {
2957 kModW = NULL;
2959 }
2960 currRing->pLexOrder = b;
2961 //Print("%d reductions canceled \n",strat->cel);
2962 sigdrop = strat->sigdrop;
2963 sbaEnterS = strat->sbaEnterS;
2964 blockred = strat->blockred;
2965 delete(strat);
2966 if ((delete_w)&&(w!=NULL)&&(*w!=NULL)) delete *w;
2967 }
2968 // Go to std
2969 if(sigdrop || blockred > blockedreductions)
2970 {
2971 r = kStd(r, Q, h, w, hilb, syzComp, newIdeal, vw);
2972 }
2973 return r;
2974 }
2975}
bool sigdrop
Definition kutil.h:359
BOOLEAN(* rewCrit1)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition kutil.h:293
BOOLEAN(* rewCrit3)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition kutil.h:295
int blockred
Definition kutil.h:364
unsigned sbaOrder
Definition kutil.h:316
int blockredmax
Definition kutil.h:365
int newIdeal
Definition kutil.h:356
char z2homog
Definition kutil.h:374
char no_prod_crit
Definition kutil.h:394
void(* enterOnePair)(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR)
Definition kutil.h:290
BOOLEAN(* rewCrit2)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition kutil.h:294
int sbaEnterS
Definition kutil.h:362
KINLINE BOOLEAN arriRewDummy(poly, unsigned long, poly, kStrategy, int)
Definition kInline.h:1263
static ideal nc_GB(const ideal F, const ideal Q, const intvec *w, const intvec *hilb, kStrategy strat, const ring r)
Definition nc.h:27
ideal mora(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
Definition kstd1.cc:1888
ideal sba(ideal F0, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
Definition kstd2.cc:2984
BOOLEAN arriRewCriterionPre(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int)
Definition kutil.cc:6688
BOOLEAN arriRewCriterion(poly, unsigned long, poly, kStrategy strat, int start=0)
Definition kutil.cc:6663
void enterOnePairNormal(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR=-1)
Definition kutil.cc:1951
BOOLEAN faugereRewCriterion(poly sig, unsigned long not_sevSig, poly, kStrategy strat, int start=0)
Definition kutil.cc:6604
#define TEST_OPT_SB_1
Definition options.h:119

◆ kStd()

ideal kStd ( ideal F,
ideal Q,
tHomog h,
intvec ** w,
intvec * hilb,
int syzComp,
int newIdeal,
intvec * vw,
s_poly_proc_t sp )

Definition at line 2483 of file kstd1.cc.

2485{
2486 if(idIs0(F))
2487 return idInit(1,F->rank);
2488
2489 if((Q!=NULL)&&(idIs0(Q))) Q=NULL;
2490#ifdef HAVE_SHIFTBBA
2491 if(rIsLPRing(currRing)) return kStdShift(F, Q, h, w, hilb, syzComp, newIdeal, vw, FALSE);
2492#endif
2493
2494 /* test HC precomputation*/
2495 poly save_noether=currRing->ppNoether;
2496 int ak = id_RankFreeModule(F,currRing);
2497 if((ak==0)
2498 && (h!=isHomog)
2499 && (w==NULL)
2500 && (hilb==NULL)
2501 && (vw==NULL)
2502 && (newIdeal==0)
2503 && (sp==NULL)
2507 currRing->ppNoether=kTryHC(F,Q);
2508
2509 ideal r;
2510 BOOLEAN b=currRing->pLexOrder,toReset=FALSE;
2512 kStrategy strat=new skStrategy;
2513
2514 strat->s_poly=sp;
2516 strat->syzComp = syzComp;
2517 if (TEST_OPT_SB_1
2519 )
2520 strat->newIdeal = newIdeal;
2522 strat->LazyPass=20;
2523 else
2524 strat->LazyPass=2;
2525 strat->LazyDegree = 1;
2526 strat->ak = ak;
2527 strat->kModW=kModW=NULL;
2528 strat->kHomW=kHomW=NULL;
2529 if (vw != NULL)
2530 {
2531 currRing->pLexOrder=FALSE;
2532 strat->kHomW=kHomW=vw;
2533 strat->pOrigFDeg = currRing->pFDeg;
2534 strat->pOrigLDeg = currRing->pLDeg;
2536 toReset = TRUE;
2537 }
2538 if (h==testHomog)
2539 {
2540 if (strat->ak == 0)
2541 {
2542 h = (tHomog)idHomIdeal(F,Q);
2543 w=NULL;
2544 }
2545 else if (!TEST_OPT_DEGBOUND)
2546 {
2547 if (w!=NULL)
2548 h = (tHomog)idHomModule(F,Q,w);
2549 else
2550 h = (tHomog)idHomIdeal(F,Q);
2551 }
2552 }
2553 currRing->pLexOrder=b;
2554 if (h==isHomog)
2555 {
2556 if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
2557 {
2558 strat->kModW = kModW = *w;
2559 if (vw == NULL)
2560 {
2561 strat->pOrigFDeg = currRing->pFDeg;
2562 strat->pOrigLDeg = currRing->pLDeg;
2564 toReset = TRUE;
2565 }
2566 }
2567 currRing->pLexOrder = TRUE;
2568 if (hilb==NULL) strat->LazyPass*=2;
2569 }
2570 strat->homog=h;
2571#ifdef KDEBUG
2572 idTest(F);
2573 if (Q!=NULL) idTest(Q);
2574#endif
2575#ifdef HAVE_PLURAL
2577 {
2578 const BOOLEAN bIsSCA = rIsSCA(currRing) && strat->z2homog; // for Z_2 prod-crit
2579 strat->no_prod_crit = ! bIsSCA;
2580 if (w!=NULL)
2581 r = nc_GB(F, Q, *w, hilb, strat, currRing);
2582 else
2583 r = nc_GB(F, Q, NULL, hilb, strat, currRing);
2584 }
2585 else
2586#endif
2587 {
2588 #if PRE_INTEGER_CHECK
2589 //the preinteger check strategy is not for modules
2590 if(nCoeff_is_Z(currRing->cf) && strat->ak <= 0)
2591 {
2592 ideal FCopy = idCopy(F);
2593 poly pFmon = preIntegerCheck(FCopy, Q);
2594 if(pFmon != NULL)
2595 {
2597 strat->kModW=kModW=NULL;
2598 if (h==testHomog)
2599 {
2600 if (strat->ak == 0)
2601 {
2603 w=NULL;
2604 }
2605 else if (!TEST_OPT_DEGBOUND)
2606 {
2607 if (w!=NULL)
2609 else
2611 }
2612 }
2613 currRing->pLexOrder=b;
2614 if (h==isHomog)
2615 {
2616 if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
2617 {
2618 strat->kModW = kModW = *w;
2619 if (vw == NULL)
2620 {
2621 strat->pOrigFDeg = currRing->pFDeg;
2622 strat->pOrigLDeg = currRing->pLDeg;
2624 toReset = TRUE;
2625 }
2626 }
2627 currRing->pLexOrder = TRUE;
2628 if (hilb==NULL) strat->LazyPass*=2;
2629 }
2630 strat->homog=h;
2631 }
2632 omTestMemory(1);
2633 if(w == NULL)
2634 {
2636 r=mora(FCopy,Q,NULL,hilb,strat);
2637 else
2638 r=bba(FCopy,Q,NULL,hilb,strat);
2639 }
2640 else
2641 {
2643 r=mora(FCopy,Q,*w,hilb,strat);
2644 else
2645 r=bba(FCopy,Q,*w,hilb,strat);
2646 }
2647 idDelete(&FCopy);
2648 }
2649 else
2650 #endif
2651 {
2652 if(w==NULL)
2653 {
2655 r=mora(F,Q,NULL,hilb,strat);
2656 else
2657 r=bba(F,Q,NULL,hilb,strat);
2658 }
2659 else
2660 {
2662 r=mora(F,Q,*w,hilb,strat);
2663 else
2664 r=bba(F,Q,*w,hilb,strat);
2665 }
2666 }
2667 }
2668#ifdef KDEBUG
2669 idTest(r);
2670#endif
2671 if (toReset)
2672 {
2673 kModW = NULL;
2675 }
2676 currRing->pLexOrder = b;
2677//Print("%d reductions canceled \n",strat->cel);
2678 delete(strat);
2679 if ((delete_w)&&(w!=NULL)&&(*w!=NULL)) delete *w;
2680 currRing->ppNoether=save_noether;
2681 return r;
2682}
s_poly_proc_t s_poly
Definition kutil.h:300
static FORCE_INLINE BOOLEAN nCoeff_is_Z(const coeffs r)
Definition coeffs.h:820
BOOLEAN idInsertPoly(ideal h1, poly h2)
insert h2 into h1 (if h2 is not the zero polynomial) return TRUE iff h2 was indeed inserted
ideal kStdShift(ideal F, ideal Q, tHomog h, intvec **w, intvec *hilb, int syzComp, int newIdeal, intvec *vw, BOOLEAN rightGB)
Definition kstd1.cc:2978
static poly kTryHC(ideal F, ideal Q)
Definition kstd1.cc:2449
poly preIntegerCheck(const ideal Forig, const ideal Q)
used for GB over ZZ: look for constant and monomial elements in the ideal background: any known const...
Definition kutil.cc:10595
omError_t omTestMemory(int check_level)
Definition omDebug.c:94
BOOLEAN rOrd_is_ds(const ring r)
Definition ring.cc:2035
static BOOLEAN rIsLPRing(const ring r)
Definition ring.h:416
static BOOLEAN rField_is_Q(const ring r)
Definition ring.h:511

◆ kStdShift()

ideal kStdShift ( ideal F,
ideal Q,
tHomog h,
intvec ** w,
intvec * hilb,
int syzComp,
int newIdeal,
intvec * vw,
BOOLEAN rightGB )

Definition at line 2978 of file kstd1.cc.

2980{
2982 assume(idIsInV(F));
2983 ideal r;
2984 BOOLEAN b=currRing->pLexOrder,toReset=FALSE;
2986 kStrategy strat=new skStrategy;
2987
2988 strat->rightGB = rightGB;
2989
2991 strat->syzComp = syzComp;
2992 if (TEST_OPT_SB_1)
2994 strat->newIdeal = newIdeal;
2996 strat->LazyPass=20;
2997 else
2998 strat->LazyPass=2;
2999 strat->LazyDegree = 1;
3000 strat->ak = id_RankFreeModule(F,currRing);
3001 strat->kModW=kModW=NULL;
3002 strat->kHomW=kHomW=NULL;
3003 if (vw != NULL)
3004 {
3005 currRing->pLexOrder=FALSE;
3006 strat->kHomW=kHomW=vw;
3007 strat->pOrigFDeg = currRing->pFDeg;
3008 strat->pOrigLDeg = currRing->pLDeg;
3010 toReset = TRUE;
3011 }
3012 if (h==testHomog)
3013 {
3014 if (strat->ak == 0)
3015 {
3016 h = (tHomog)idHomIdeal(F,Q);
3017 w=NULL;
3018 }
3019 else if (!TEST_OPT_DEGBOUND)
3020 {
3021 if (w!=NULL)
3022 h = (tHomog)idHomModule(F,Q,w);
3023 else
3024 h = (tHomog)idHomIdeal(F,Q);
3025 }
3026 }
3027 currRing->pLexOrder=b;
3028 if (h==isHomog)
3029 {
3030 if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
3031 {
3032 strat->kModW = kModW = *w;
3033 if (vw == NULL)
3034 {
3035 strat->pOrigFDeg = currRing->pFDeg;
3036 strat->pOrigLDeg = currRing->pLDeg;
3038 toReset = TRUE;
3039 }
3040 }
3041 currRing->pLexOrder = TRUE;
3042 if (hilb==NULL) strat->LazyPass*=2;
3043 }
3044 strat->homog=h;
3045#ifdef KDEBUG
3046 idTest(F);
3047#endif
3049 {
3050 /* error: no local ord yet with shifts */
3051 WerrorS("No local ordering possible for shift algebra");
3052 return(NULL);
3053 }
3054 else
3055 {
3056 /* global ordering */
3057 if (w!=NULL)
3058 r=bbaShift(F,Q,*w,hilb,strat);
3059 else
3060 r=bbaShift(F,Q,NULL,hilb,strat);
3061 }
3062#ifdef KDEBUG
3063 idTest(r);
3064#endif
3065 if (toReset)
3066 {
3067 kModW = NULL;
3069 }
3070 currRing->pLexOrder = b;
3071//Print("%d reductions canceled \n",strat->cel);
3072 delete(strat);
3073 if ((delete_w)&&(w!=NULL)&&(*w!=NULL)) delete *w;
3074 assume(idIsInV(r));
3075 return r;
3076}
char rightGB
Definition kutil.h:369
ideal bbaShift(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
Definition kstd2.cc:4591
#define idIsInV(I)
Definition shiftop.h:49

◆ kTryHC()

static poly kTryHC ( ideal F,
ideal Q )
static

Definition at line 2449 of file kstd1.cc.

2450{
2451 if (TEST_OPT_PROT) PrintS("try HC in Zp ring\n");
2452 // create Zp_ring
2455 nKillChar(Zp_ring->cf);
2456 Zp_ring->cf=nInitChar(n_Zp, (void*)(long)32003);
2458 // map data
2462 ideal QQ=NULL;
2464 // call std
2466 // clean
2467 idDelete(&FF);
2468 if (QQ!=NULL) idDelete(&QQ);
2469 idDelete(&res);
2470 // map back
2472 poly p=NULL;
2473 if (Zp_ring->ppNoether!=NULL)
2474 {
2476 Zp_ring->ppNoether=NULL;
2477 if (TEST_OPT_PROT) PrintS("HC found in Zp ring\n");
2478 }
2480 return p;
2481}
@ n_Zp
\F{p < 2^31}
Definition coeffs.h:29
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
Definition coeffs.h:704
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition numbers.cc:419
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition coeffs.h:80
void nKillChar(coeffs r)
undo all initialisations
Definition numbers.cc:574
poly p_PermPoly(poly p, const int *perm, const ring oldRing, const ring dst, nMapFunc nMap, const int *par_perm, int OldPar, BOOLEAN use_mult)
Definition p_polys.cc:4152
BOOLEAN rComplete(ring r, int force)
this needs to be called whenever a new ring is created: new fields in ring are created (like VarOffse...
Definition ring.cc:3466
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
Definition ring.cc:1423
void rDelete(ring r)
unconditionally deletes fields in r
Definition ring.cc:452
ideal id_PermIdeal(ideal I, int R, int C, const int *perm, const ring src, const ring dst, nMapFunc nMap, const int *par_perm, int P, BOOLEAN use_mult)
mapping ideals/matrices to other rings

◆ missingAxis()

void missingAxis ( int * last,
kStrategy strat )

Definition at line 1284 of file kstd1.cc.

1285{
1286 int i = 0;
1287 int k = 0;
1288
1289 *last = 0;
1291 {
1292 loop
1293 {
1294 i++;
1295 if (i > (currRing->N)) break;
1296 if (strat->NotUsedAxis[i])
1297 {
1298 *last = i;
1299 k++;
1300 }
1301 if (k>1)
1302 {
1303 *last = 0;
1304 break;
1305 }
1306 }
1307 }
1308}
int k
Definition cfEzgcd.cc:99
BOOLEAN rHasMixedOrdering(const ring r)
Definition ring.h:768
#define loop
Definition structs.h:75

◆ mora()

ideal mora ( ideal F,
ideal Q,
intvec * w,
intvec * hilb,
kStrategy strat )

Definition at line 1888 of file kstd1.cc.

1889{
1890 int olddeg = 0;
1891 int reduc = 0;
1892 int red_result = 1;
1893 int hilbeledeg=1,hilbcount=0;
1894 BITSET save1;
1897 {
1898 si_opt_1 &= ~Sy_bit(OPT_REDSB);
1899 si_opt_1 &= ~Sy_bit(OPT_REDTAIL);
1900 }
1901
1902 strat->update = TRUE;
1903 /*- setting global variables ------------------- -*/
1904 initBuchMoraCrit(strat);
1905 initHilbCrit(F,Q,&hilb,strat);
1906 initMora(F,strat);
1908 initBuchMoraPosRing(strat);
1909 else
1910 initBuchMoraPos(strat);
1911 /*Shdl=*/initBuchMora(F,Q,strat);
1912 if (TEST_OPT_FASTHC) missingAxis(&strat->lastAxis,strat);
1913 /*updateS in initBuchMora has Hecketest
1914 * and could have put strat->kHEdgdeFound FALSE*/
1915 if (TEST_OPT_FASTHC && (strat->lastAxis) && strat->posInLOldFlag)
1916 {
1917 strat->posInLOld = strat->posInL;
1918 strat->posInLOldFlag = FALSE;
1919 strat->posInL = posInL10;
1920 updateL(strat);
1921 reorderL(strat);
1922 }
1923 kTest_TS(strat);
1924 strat->use_buckets = kMoraUseBucket(strat);
1925
1926#ifdef HAVE_TAIL_RING
1927 if (strat->homog && strat->red == redFirst)
1928 if(!idIs0(F) &&(!rField_is_Ring(currRing)))
1930#endif
1931
1932 if (BVERBOSE(23))
1933 {
1934 kDebugPrint(strat);
1935 }
1936//deleteInL(strat->L,&strat->Ll,1,strat);
1937//deleteInL(strat->L,&strat->Ll,0,strat);
1938
1939 /*- compute-------------------------------------------*/
1940 while (strat->Ll >= 0)
1941 {
1942 #ifdef KDEBUG
1943 if (TEST_OPT_DEBUG) messageSets(strat);
1944 #endif
1945 if (siCntrlc)
1946 {
1947 while (strat->Ll >= 0)
1948 deleteInL(strat->L,&strat->Ll,strat->Ll,strat);
1949 strat->noClearS=TRUE;
1950 }
1952 && (strat->L[strat->Ll].ecart+strat->L[strat->Ll].GetpFDeg()> Kstd1_deg))
1953 {
1954 /*
1955 * stops computation if
1956 * - 24 (degBound)
1957 * && upper degree is bigger than Kstd1_deg
1958 */
1959 while ((strat->Ll >= 0)
1960 && (strat->L[strat->Ll].p1!=NULL) && (strat->L[strat->Ll].p2!=NULL)
1961 && (strat->L[strat->Ll].ecart+strat->L[strat->Ll].GetpFDeg()> Kstd1_deg)
1962 )
1963 {
1964 deleteInL(strat->L,&strat->Ll,strat->Ll,strat);
1965 //if (TEST_OPT_PROT)
1966 //{
1967 // PrintS("D"); mflush();
1968 //}
1969 }
1970 if (strat->Ll<0) break;
1971 else strat->noClearS=TRUE;
1972 }
1973 strat->P = strat->L[strat->Ll];/*- picks the last element from the lazyset L -*/
1974 if (strat->Ll==0) strat->interpt=TRUE;
1975 strat->Ll--;
1976 // create the real Spoly
1977 if (pNext(strat->P.p) == strat->tail)
1978 {
1979 /*- deletes the short spoly and computes -*/
1981 pLmDelete(strat->P.p);
1982 else
1983 pLmFree(strat->P.p);
1984 strat->P.p = NULL;
1985 poly m1 = NULL, m2 = NULL;
1986 // check that spoly creation is ok
1987 while (strat->tailRing != currRing &&
1988 !kCheckSpolyCreation(&(strat->P), strat, m1, m2))
1989 {
1990 assume(m1 == NULL && m2 == NULL);
1991 // if not, change to a ring where exponents are large enough
1992 kStratChangeTailRing(strat);
1993 }
1994 /* create the real one */
1995 ksCreateSpoly(&(strat->P), strat->kNoetherTail(), strat->use_buckets,
1996 strat->tailRing, m1, m2, strat->R);
1997 if (!strat->use_buckets)
1998 strat->P.SetLength(strat->length_pLength);
1999 }
2000 else if (strat->P.p1 == NULL)
2001 {
2002 // for input polys, prepare reduction (buckets !)
2003 strat->P.SetLength(strat->length_pLength);
2004 strat->P.PrepareRed(strat->use_buckets);
2005 }
2006
2007 // the s-poly
2008 if (!strat->P.IsNull())
2009 {
2010 // might be NULL from noether !!!
2011 if (TEST_OPT_PROT)
2012 message(strat->P.ecart+strat->P.GetpFDeg(),&olddeg,&reduc,strat, red_result);
2013 // reduce
2014 red_result = strat->red(&strat->P,strat);
2015 }
2016
2017 // the reduced s-poly
2018 if (! strat->P.IsNull())
2019 {
2020 strat->P.GetP();
2021 // statistics
2022 if (TEST_OPT_PROT) PrintS("s");
2023 // normalization
2025 strat->P.pCleardenom();
2026 else
2027 strat->P.pNorm();
2028 // tailreduction
2029 strat->P.p = redtail(&(strat->P),strat->sl,strat);
2030 if (strat->P.p==NULL)
2031 {
2032 WerrorS("exponent overflow - wrong ordering");
2033 return(idInit(1,1));
2034 }
2035 // set ecart -- might have changed because of tail reductions
2036 if ((!strat->noTailReduction) && (!strat->honey))
2037 strat->initEcart(&strat->P);
2038 // cancel unit
2039 cancelunit(&strat->P);
2040 // for char 0, clear denominators
2041 if ((strat->P.p->next==NULL) /* i.e. cancelunit did something*/
2043 strat->P.pCleardenom();
2044
2045 strat->P.SetShortExpVector();
2046 enterT(strat->P,strat);
2047 // build new pairs
2049 superenterpairs(strat->P.p,strat->sl,strat->P.ecart,0,strat, strat->tl);
2050 else
2051 enterpairs(strat->P.p,strat->sl,strat->P.ecart,0,strat, strat->tl);
2052 // put in S
2053 strat->enterS(strat->P,
2054 posInS(strat,strat->sl,strat->P.p, strat->P.ecart),
2055 strat, strat->tl);
2056 // apply hilbert criterion
2057 if (hilb!=NULL)
2058 {
2059 if (strat->homog==isHomog)
2061 else
2063 }
2064
2065 // clear strat->P
2066 kDeleteLcm(&strat->P);
2067
2068#ifdef KDEBUG
2069 // make sure kTest_TS does not complain about strat->P
2070 strat->P.Clear();
2071#endif
2072 }
2073 if (strat->kAllAxis)
2074 {
2075 if ((TEST_OPT_FINDET)
2076 || ((TEST_OPT_MULTBOUND) && (scMult0Int(strat->Shdl,NULL) < Kstd1_mu)))
2077 {
2078 // obachman: is this still used ???
2079 /*
2080 * stops computation if strat->kAllAxis and
2081 * - 27 (finiteDeterminacyTest)
2082 * or
2083 * - 23
2084 * (multBound)
2085 * && multiplicity of the ideal is smaller then a predefined number mu
2086 */
2087 while (strat->Ll >= 0) deleteInL(strat->L,&strat->Ll,strat->Ll,strat);
2088 }
2089 }
2090 kTest_TS(strat);
2091 }
2092 /*- complete reduction of the standard basis------------------------ -*/
2093 if (TEST_OPT_REDSB) completeReduce(strat);
2094 else if (TEST_OPT_PROT) PrintLn();
2095 /*- release temp data------------------------------- -*/
2096 exitBuchMora(strat);
2097 /*- polynomials used for HECKE: HC, noether -*/
2098 if (TEST_OPT_FINDET)
2099 {
2100 if (strat->kNoether!=NULL)
2101 Kstd1_mu=currRing->pFDeg(strat->kNoether,currRing);
2102 else
2103 Kstd1_mu=-1;
2104 }
2105 if (strat->kNoether!=NULL) pLmFree(&strat->kNoether);
2106 if (strat->kNoether!=NULL) pLmDelete(&strat->kNoether);
2107 omFreeSize((ADDRESS)strat->NotUsedAxis,((currRing->N)+1)*sizeof(BOOLEAN));
2109// if (TEST_OPT_WEIGHTM)
2110// {
2111// pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
2112// if (ecartWeights)
2113// {
2114// omFreeSize((ADDRESS)ecartWeights,((currRing->N)+1)*sizeof(short));
2115// ecartWeights=NULL;
2116// }
2117// }
2118 if(nCoeff_is_Z(currRing->cf))
2119 finalReduceByMon(strat);
2120 if (Q!=NULL) updateResult(strat->Shdl,Q,strat);
2122 idTest(strat->Shdl);
2123 return (strat->Shdl);
2124}
char noClearS
Definition kutil.h:402
long scMult0Int(ideal S, ideal Q)
Definition hdegree.cc:950
void khCheckLocInhom(ideal Q, intvec *w, intvec *hilb, int &count, kStrategy strat)
Definition khstd.cc:244
void khCheck(ideal Q, intvec *w, intvec *hilb, int &eledeg, int &count, kStrategy strat)
Definition khstd.cc:28
void ksCreateSpoly(LObject *Pair, poly spNoether, int use_buckets, ring tailRing, poly m1, poly m2, TObject **R)
Definition kspoly.cc:1208
EXTERN_VAR int Kstd1_mu
Definition kstd1.h:50
void enterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
Definition kutil.cc:4508
void initHilbCrit(ideal, ideal, intvec **hilb, kStrategy strat)
Definition kutil.cc:9457
BOOLEAN kStratChangeTailRing(kStrategy strat, LObject *L, TObject *T, unsigned long expbound)
Definition kutil.cc:11020
BOOLEAN kCheckSpolyCreation(LObject *L, kStrategy strat, poly &m1, poly &m2)
Definition kutil.cc:10533
void superenterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
Definition kutil.cc:4477
void deleteInL(LSet set, int *length, int j, kStrategy strat)
Definition kutil.cc:1214
void messageStat(int hilbcount, kStrategy strat)
Definition kutil.cc:7552
void finalReduceByMon(kStrategy strat)
used for GB over ZZ: final reduction by constant elements background: any known constant element of i...
Definition kutil.cc:10927
void cancelunit(LObject *L, BOOLEAN inNF)
Definition kutil.cc:372
VAR BOOLEAN siCntrlc
Definition options.c:14
#define OPT_REDSB
Definition options.h:76
#define TEST_OPT_MULTBOUND
Definition options.h:114

◆ posInL10()

int posInL10 ( const LSet set,
const int length,
LObject * p,
const kStrategy strat )

Definition at line 1365 of file kstd1.cc.

1366{
1367 int j,dp,dL;
1368
1369 if (length<0) return 0;
1370 if (hasPurePower(p,strat->lastAxis,&dp,strat))
1371 {
1372 int op= p->GetpFDeg() +p->ecart;
1373 for (j=length; j>=0; j--)
1374 {
1375 if (!hasPurePower(&(set[j]),strat->lastAxis,&dL,strat))
1376 return j+1;
1377 if (dp < dL)
1378 return j+1;
1379 if ((dp == dL)
1380 && (set[j].GetpFDeg()+set[j].ecart >= op))
1381 return j+1;
1382 }
1383 }
1384 j=length;
1385 loop
1386 {
1387 if (j<0) break;
1388 if (!hasPurePower(&(set[j]),strat->lastAxis,&dL,strat)) break;
1389 j--;
1390 }
1391 return strat->posInLOld(set,j,p,strat);
1392}

◆ redEcart()

int redEcart ( LObject * h,
kStrategy strat )

Definition at line 169 of file kstd1.cc.

170{
171 int i,at,ei,li,ii;
172 int j = 0;
173 int pass = 0;
174 long d,reddeg;
175
176 d = h->GetpFDeg()+ h->ecart;
177 reddeg = strat->LazyDegree+d;
178 h->SetShortExpVector();
179 loop
180 {
181 j = kFindDivisibleByInT(strat, h);
182 if (j < 0)
183 {
184 if (strat->honey) h->SetLength(strat->length_pLength);
185 return 1;
186 }
187
188 ei = strat->T[j].ecart;
189 ii = j;
190
191 if (ei > h->ecart && ii < strat->tl)
192 {
193 unsigned long not_sev=~h->sev;
194 poly h_t= h->GetLmTailRing();
195 li = strat->T[j].length;
196 if (li<=0) li=strat->T[j].GetpLength();
197 // the polynomial to reduce with (up to the moment) is;
198 // pi with ecart ei and length li
199 // look for one with smaller ecart
200 i = j;
201 loop
202 {
203 /*- takes the first possible with respect to ecart -*/
204 i++;
205#if 1
206 if (i > strat->tl) break;
207 if (strat->T[i].length<=0) strat->T[i].GetpLength();
208 if ((strat->T[i].ecart < ei || (strat->T[i].ecart == ei &&
209 strat->T[i].length < li))
210 &&
211 p_LmShortDivisibleBy(strat->T[i].GetLmTailRing(), strat->sevT[i], h_t, not_sev, strat->tailRing))
212#else
213 j = kFindDivisibleByInT(strat, h, i);
214 if (j < 0) break;
215 i = j;
216 if (strat->T[i].ecart < ei || (strat->T[i].ecart == ei &&
217 strat->T[i].length < li))
218#endif
219 {
220 // the polynomial to reduce with is now
221 ii = i;
222 ei = strat->T[i].ecart;
223 if (ei <= h->ecart) break;
224 li = strat->T[i].length;
225 }
226 }
227 }
228
229 // end of search: have to reduce with pi
230 if (ei > h->ecart)
231 {
232 // It is not possible to reduce h with smaller ecart;
233 // if possible h goes to the lazy-set L,i.e
234 // if its position in L would be not the last one
235 strat->fromT = TRUE;
236 if (!TEST_OPT_REDTHROUGH && strat->Ll >= 0) /*- L is not empty -*/
237 {
238 h->SetLmCurrRing();
239 if (strat->honey && strat->posInLDependsOnLength)
240 h->SetLength(strat->length_pLength);
241 assume(h->FDeg == h->pFDeg());
242 at = strat->posInL(strat->L,strat->Ll,h,strat);
243 if (at <= strat->Ll)
244 {
245 /*- h will not become the next element to reduce -*/
246 enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
247#ifdef KDEBUG
248 if (TEST_OPT_DEBUG) Print(" ecart too big; -> L%d\n",at);
249#endif
250 h->Clear();
251 strat->fromT = FALSE;
252 return -1;
253 }
254 }
255 }
256
257 // now we finally can reduce
258 doRed(h,&(strat->T[ii]),strat->fromT,strat,FALSE);
259 strat->fromT=FALSE;
260
261 // are we done ???
262 if (h->IsNull())
263 {
265 kDeleteLcm(h);
266 h->Clear();
267 return 0;
268 }
269 if (TEST_OPT_IDLIFT)
270 {
271 if (h->p!=NULL)
272 {
273 if(p_GetComp(h->p,currRing)>strat->syzComp)
274 {
275 h->Delete();
276 return 0;
277 }
278 }
279 else if (h->t_p!=NULL)
280 {
281 if(p_GetComp(h->t_p,strat->tailRing)>strat->syzComp)
282 {
283 h->Delete();
284 return 0;
285 }
286 }
287 }
288 #if 0
289 else if ((strat->syzComp > 0)&&(!TEST_OPT_REDTAIL_SYZ))
290 {
291 if (h->p!=NULL)
292 {
293 if(p_GetComp(h->p,currRing)>strat->syzComp)
294 {
295 return 1;
296 }
297 }
298 else if (h->t_p!=NULL)
299 {
300 if(p_GetComp(h->t_p,strat->tailRing)>strat->syzComp)
301 {
302 return 1;
303 }
304 }
305 }
306 #endif
307
308 // done ? NO!
309 h->SetShortExpVector();
310 h->SetpFDeg();
311 if (strat->honey)
312 {
313 if (ei <= h->ecart)
314 h->ecart = d-h->GetpFDeg();
315 else
316 h->ecart = d-h->GetpFDeg()+ei-h->ecart;
317 }
318 else
319 // this has the side effect of setting h->length
320 h->ecart = h->pLDeg(strat->LDegLast) - h->GetpFDeg();
321#if 0
322 if (strat->syzComp!=0)
323 {
324 if ((strat->syzComp>0) && (h->Comp() > strat->syzComp))
325 {
326 assume(h->MinComp() > strat->syzComp);
327 if (strat->honey) h->SetLength();
328#ifdef KDEBUG
329 if (TEST_OPT_DEBUG) PrintS(" > syzComp\n");
330#endif
331 return -2;
332 }
333 }
334#endif
335 /*- try to reduce the s-polynomial -*/
336 pass++;
337 d = h->GetpFDeg()+h->ecart;
338 /*
339 *test whether the polynomial should go to the lazyset L
340 *-if the degree jumps
341 *-if the number of pre-defined reductions jumps
342 */
343 if (!TEST_OPT_REDTHROUGH && (strat->Ll >= 0)
344 && ((d >= reddeg) || (pass > strat->LazyPass)))
345 {
346 h->SetLmCurrRing();
347 if (strat->honey && strat->posInLDependsOnLength)
348 h->SetLength(strat->length_pLength);
349 assume(h->FDeg == h->pFDeg());
350 at = strat->posInL(strat->L,strat->Ll,h,strat);
351 if (at <= strat->Ll)
352 {
353 int dummy=strat->sl;
354 if (kFindDivisibleByInS(strat, &dummy, h) < 0)
355 {
356 if (strat->honey && !strat->posInLDependsOnLength)
357 h->SetLength(strat->length_pLength);
358 return 1;
359 }
360 enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
361#ifdef KDEBUG
362 if (TEST_OPT_DEBUG) Print(" degree jumped; ->L%d\n",at);
363#endif
364 h->Clear();
365 return -1;
366 }
367 }
368 else if ((TEST_OPT_PROT) && (strat->Ll < 0) && (d >= reddeg))
369 {
370 Print(".%ld",d);mflush();
371 reddeg = d+1;
372 if (h->pTotalDeg()+h->ecart >= (int)strat->tailRing->bitmask)
373 {
374 strat->overflow=TRUE;
375 //Print("OVERFLOW in redEcart d=%ld, max=%ld",d,strat->tailRing->bitmask);
376 h->GetP();
377 at = strat->posInL(strat->L,strat->Ll,h,strat);
378 enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
379 h->Clear();
380 return -1;
381 }
382 }
383 }
384}
int length() const
char fromT
Definition kutil.h:379
char overflow
Definition kutil.h:404
static int doRed(LObject *h, TObject *with, BOOLEAN intoT, kStrategy strat, bool redMoraNF)
Definition kstd1.cc:119
int kFindDivisibleByInS(const kStrategy strat, int *max_ind, LObject *L)
return -1 if no divisor is found number of first divisor in S, otherwise
Definition kstd2.cc:421
int kFindDivisibleByInT(const kStrategy strat, const LObject *L, const int start)
return -1 if no divisor is found number of first divisor in T, otherwise
Definition kstd2.cc:321
#define p_GetComp(p, r)
Definition monomials.h:64
#define TEST_OPT_REDTHROUGH
Definition options.h:122
#define TEST_OPT_REDTAIL_SYZ
Definition options.h:117
static BOOLEAN p_LmShortDivisibleBy(poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, const ring r)
Definition p_polys.h:1910

◆ redFirst()

int redFirst ( LObject * h,
kStrategy strat )

Definition at line 797 of file kstd1.cc.

798{
799 if (strat->tl<0) return 1;
800 if (h->IsNull()) return 0;
801
802 int at;
803 long reddeg,d;
804 int pass = 0;
805 int cnt = RED_CANONICALIZE;
806 int j = 0;
807
808 if (! strat->homog)
809 {
810 d = h->GetpFDeg() + h->ecart;
811 reddeg = strat->LazyDegree+d;
812 }
813 h->SetShortExpVector();
814 loop
815 {
816 j = kFindDivisibleByInT(strat, h);
817 if (j < 0)
818 {
819 h->SetDegStuffReturnLDeg(strat->LDegLast);
820 return 1;
821 }
822
824 strat->T[j].pNorm();
825#ifdef KDEBUG
826 if (TEST_OPT_DEBUG)
827 {
828 PrintS("reduce ");
829 h->wrp();
830 PrintS(" with ");
831 strat->T[j].wrp();
832 }
833#endif
834 ksReducePoly(h, &(strat->T[j]), strat->kNoetherTail(), NULL, NULL, strat);
835#ifdef KDEBUG
836 if (TEST_OPT_DEBUG)
837 {
838 PrintS(" to ");
839 wrp(h->p);
840 PrintLn();
841 }
842#endif
843 if (h->IsNull())
844 {
846 kDeleteLcm(h);
847 h->Clear();
848 return 0;
849 }
850 if (TEST_OPT_IDLIFT)
851 {
852 if (h->p!=NULL)
853 {
854 if(p_GetComp(h->p,currRing)>strat->syzComp)
855 {
856 h->Delete();
857 return 0;
858 }
859 }
860 else if (h->t_p!=NULL)
861 {
862 if(p_GetComp(h->t_p,strat->tailRing)>strat->syzComp)
863 {
864 h->Delete();
865 return 0;
866 }
867 }
868 }
869 #if 0
870 else if ((strat->syzComp > 0)&&(!TEST_OPT_REDTAIL_SYZ))
871 {
872 if (h->p!=NULL)
873 {
874 if(p_GetComp(h->p,currRing)>strat->syzComp)
875 {
876 return 1;
877 }
878 }
879 else if (h->t_p!=NULL)
880 {
881 if(p_GetComp(h->t_p,strat->tailRing)>strat->syzComp)
882 {
883 return 1;
884 }
885 }
886 }
887 #endif
888 h->SetShortExpVector();
889
890#if 0
891 if ((strat->syzComp!=0) && !strat->honey)
892 {
893 if ((strat->syzComp>0) &&
894 (h->Comp() > strat->syzComp))
895 {
896 assume(h->MinComp() > strat->syzComp);
897#ifdef KDEBUG
898 if (TEST_OPT_DEBUG) PrintS(" > syzComp\n");
899#endif
900 if (strat->homog)
901 h->SetDegStuffReturnLDeg(strat->LDegLast);
902 return -2;
903 }
904 }
905#endif
906 if (!strat->homog)
907 {
908 if (!TEST_OPT_OLDSTD && strat->honey)
909 {
910 h->SetpFDeg();
911 if (strat->T[j].ecart <= h->ecart)
912 h->ecart = d - h->GetpFDeg();
913 else
914 h->ecart = d - h->GetpFDeg() + strat->T[j].ecart - h->ecart;
915
916 d = h->GetpFDeg() + h->ecart;
917 }
918 else
919 d = h->SetDegStuffReturnLDeg(strat->LDegLast);
920 /*- try to reduce the s-polynomial -*/
921 cnt--;
922 pass++;
923 /*
924 *test whether the polynomial should go to the lazyset L
925 *-if the degree jumps
926 *-if the number of pre-defined reductions jumps
927 */
928 if (!TEST_OPT_REDTHROUGH && (strat->Ll >= 0)
929 && ((d >= reddeg) || (pass > strat->LazyPass)))
930 {
931 h->SetLmCurrRing();
932 if (strat->posInLDependsOnLength)
933 h->SetLength(strat->length_pLength);
934 at = strat->posInL(strat->L,strat->Ll,h,strat);
935 if (at <= strat->Ll)
936 {
937 int dummy=strat->sl;
938 if (kFindDivisibleByInS(strat,&dummy, h) < 0)
939 return 1;
940 enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
941#ifdef KDEBUG
942 if (TEST_OPT_DEBUG) Print(" degree jumped; ->L%d\n",at);
943#endif
944 h->Clear();
945 return -1;
946 }
947 }
948 if (UNLIKELY(cnt==0))
949 {
950 h->CanonicalizeP();
952 //if (TEST_OPT_PROT) { PrintS("!");mflush(); }
953 }
954 if ((TEST_OPT_PROT) && (strat->Ll < 0) && (d >= reddeg))
955 {
956 reddeg = d+1;
957 Print(".%ld",d);mflush();
958 if (h->pTotalDeg()+h->ecart >= (int)strat->tailRing->bitmask)
959 {
960 strat->overflow=TRUE;
961 //Print("OVERFLOW in redFirst d=%ld, max=%ld",d,strat->tailRing->bitmask);
962 h->GetP();
963 at = strat->posInL(strat->L,strat->Ll,h,strat);
964 enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
965 h->Clear();
966 return -1;
967 }
968 }
969 }
970 }
971}
#define UNLIKELY(X)
Definition auxiliary.h:404
#define RED_CANONICALIZE
Definition kutil.h:36
void wrp(poly p)
Definition polys.h:310

◆ redMoraNF()

static poly redMoraNF ( poly h,
kStrategy strat,
int flag )
static

Definition at line 978 of file kstd1.cc.

979{
980 LObject H;
981 H.p = h;
982 int j = 0;
983 int z = 10;
984 int o = H.SetpFDeg();
985 H.ecart = currRing->pLDeg(H.p,&H.length,currRing)-o;
986 if ((flag & 2) == 0) cancelunit(&H,TRUE);
987 H.sev = pGetShortExpVector(H.p);
988 loop
989 {
990 if (j > strat->tl)
991 {
992 return H.p;
993 }
994 if (TEST_V_DEG_STOP)
995 {
996 if (kModDeg(H.p)>Kstd1_deg) pLmDelete(&H.p);
997 if (H.p==NULL) return NULL;
998 }
999 unsigned long not_sev = ~ H.sev;
1000 if (p_LmShortDivisibleBy(strat->T[j].GetLmTailRing(), strat->sevT[j], H.GetLmTailRing(), not_sev, strat->tailRing)
1001 )
1002 {
1003 /*- remember the found T-poly -*/
1004 // poly pi = strat->T[j].p;
1005 int ei = strat->T[j].ecart;
1006 int li = strat->T[j].length;
1007 int ii = j;
1008 /*
1009 * the polynomial to reduce with (up to the moment) is;
1010 * pi with ecart ei and length li
1011 */
1012 loop
1013 {
1014 /*- look for a better one with respect to ecart -*/
1015 /*- stop, if the ecart is small enough (<=ecart(H)) -*/
1016 j++;
1017 if (j > strat->tl) break;
1018 if (ei <= H.ecart) break;
1019 if (((strat->T[j].ecart < ei)
1020 || ((strat->T[j].ecart == ei)
1021 && (strat->T[j].length < li)))
1022 && pLmShortDivisibleBy(strat->T[j].p,strat->sevT[j], H.p, not_sev)
1023 )
1024 {
1025 /*
1026 * the polynomial to reduce with is now;
1027 */
1028 // pi = strat->T[j].p;
1029 ei = strat->T[j].ecart;
1030 li = strat->T[j].length;
1031 ii = j;
1032 }
1033 }
1034 /*
1035 * end of search: have to reduce with pi
1036 */
1037 z++;
1038 if (z>10)
1039 {
1040 pNormalize(H.p);
1041 z=0;
1042 }
1043 if ((ei > H.ecart) && (strat->kNoether==NULL))
1044 {
1045 /*
1046 * It is not possible to reduce h with smaller ecart;
1047 * we have to reduce with bad ecart: H has to enter in T
1048 */
1049 LObject L= H;
1050 L.Copy();
1051 H.GetP();
1052 H.length=H.pLength=pLength(H.p);
1053 ksReducePoly(&L, &(strat->T[ii]), strat->kNoetherTail(), NULL, NULL, strat,
1054 (flag & KSTD_NF_NONORM)==0);
1055 enterT(H,strat);
1056 H = L;
1057 }
1058 else
1059 {
1060 /*
1061 * we reduce with good ecart, h need not to be put to T
1062 */
1063 ksReducePoly(&H, &(strat->T[ii]), strat->kNoetherTail(), NULL, NULL, strat,
1064 (flag & KSTD_NF_NONORM)==0);
1065 }
1066 if (H.p == NULL)
1067 return NULL;
1068 /*- try to reduce the s-polynomial -*/
1069 o = H.SetpFDeg();
1070 if ((flag & KSTD_NF_ECART) == 0) cancelunit(&H,TRUE);
1071 H.ecart = currRing->pLDeg(H.p,&(H.length),currRing)-o;
1072 j = 0;
1073 H.sev = pGetShortExpVector(H.p);
1074 }
1075 else
1076 {
1077 j++;
1078 }
1079 }
1080}
CanonicalForm H
Definition facAbsFact.cc:60
#define pLmShortDivisibleBy(a, sev_a, b, not_sev_b)
Divisibility tests based on Short Exponent vectors sev_a == pGetShortExpVector(a) not_sev_b == ~ pGet...
Definition polys.h:146
#define pNormalize(p)
Definition polys.h:317

◆ redMoraNFRing()

static poly redMoraNFRing ( poly h,
kStrategy strat,
int flag )
static

Definition at line 1083 of file kstd1.cc.

1084{
1085 LObject H;
1086 H.p = h;
1087 int j0, j = 0;
1088 int docoeffred = 0;
1089 poly T0p = strat->T[0].p;
1090 int T0ecart = strat->T[0].ecart;
1091 int o = H.SetpFDeg();
1092 H.ecart = currRing->pLDeg(H.p,&H.length,currRing)-o;
1093 if ((flag & KSTD_NF_ECART) == 0) cancelunit(&H,TRUE);
1094 H.sev = pGetShortExpVector(H.p);
1095 unsigned long not_sev = ~ H.sev;
1096 if (strat->T[0].GetpFDeg() == 0 && strat->T[0].length <= 2)
1097 {
1098 docoeffred = 1; // euclidean ring required: n_QuotRem
1099 if (currRing->cf->cfQuotRem==ndQuotRem)
1100 {
1101 docoeffred = 0;
1102 }
1103 }
1104 loop
1105 {
1106 /* cut down the lead coefficients, only possible if the degree of
1107 * T[0] is 0 (constant). This is only efficient if T[0] is short, thus
1108 * we ask for the length of T[0] to be <= 2 */
1109 if (docoeffred)
1110 {
1111 j0 = kTestDivisibleByT0_Z(strat, &H);
1112 if ((j0 == 0)
1113 && (n_DivBy(pGetCoeff(H.p), pGetCoeff(T0p), currRing->cf) == FALSE)
1114 && (T0ecart <= H.ecart))
1115 {
1116 /* not(lc(reducer) | lc(poly)) && not(lc(poly) | lc(reducer))
1117 * => we try to cut down the lead coefficient at least */
1118 /* first copy T[j0] in order to multiply it with a coefficient later on */
1119 number mult, rest;
1120 TObject tj = strat->T[0];
1121 tj.Copy();
1122 /* compute division with remainder of lc(h) and lc(T[j]) */
1124 &rest, currRing->cf);
1125 /* set corresponding new lead coefficient already. we do not
1126 * remove the lead term in ksReducePolyLC, but only apply
1127 * a lead coefficient reduction */
1128 tj.Mult_nn(mult);
1129 ksReducePolyLC(&H, &tj, NULL, &rest, strat);
1130 tj.Delete();
1131 tj.Clear();
1132 }
1133 }
1134 if (j > strat->tl)
1135 {
1136 return H.p;
1137 }
1138 if (TEST_V_DEG_STOP)
1139 {
1140 if (kModDeg(H.p)>Kstd1_deg) pLmDelete(&H.p);
1141 if (H.p==NULL) return NULL;
1142 }
1143 if (p_LmShortDivisibleBy(strat->T[j].GetLmTailRing(), strat->sevT[j], H.GetLmTailRing(), not_sev, strat->tailRing)
1144 && (n_DivBy(H.p->coef, strat->T[j].p->coef,strat->tailRing->cf))
1145 )
1146 {
1147 /*- remember the found T-poly -*/
1148 // poly pi = strat->T[j].p;
1149 int ei = strat->T[j].ecart;
1150 int li = strat->T[j].length;
1151 int ii = j;
1152 /*
1153 * the polynomial to reduce with (up to the moment) is;
1154 * pi with ecart ei and length li
1155 */
1156 loop
1157 {
1158 /*- look for a better one with respect to ecart -*/
1159 /*- stop, if the ecart is small enough (<=ecart(H)) -*/
1160 j++;
1161 if (j > strat->tl) break;
1162 if (ei <= H.ecart) break;
1163 if (((strat->T[j].ecart < ei)
1164 || ((strat->T[j].ecart == ei)
1165 && (strat->T[j].length < li)))
1166 && pLmShortDivisibleBy(strat->T[j].p,strat->sevT[j], H.p, not_sev)
1167 && (n_DivBy(H.p->coef, strat->T[j].p->coef,strat->tailRing->cf))
1168 )
1169 {
1170 /*
1171 * the polynomial to reduce with is now;
1172 */
1173 // pi = strat->T[j].p;
1174 ei = strat->T[j].ecart;
1175 li = strat->T[j].length;
1176 ii = j;
1177 }
1178 }
1179 /*
1180 * end of search: have to reduce with pi
1181 */
1182 if ((ei > H.ecart) && (strat->kNoether==NULL))
1183 {
1184 /*
1185 * It is not possible to reduce h with smaller ecart;
1186 * we have to reduce with bad ecart: H has to enter in T
1187 */
1188 LObject L= H;
1189 L.Copy();
1190 H.GetP();
1191 H.length=H.pLength=pLength(H.p);
1192 ksReducePoly(&L, &(strat->T[ii]), strat->kNoetherTail(), NULL, NULL, strat,
1193 (flag & KSTD_NF_NONORM)==0);
1194 enterT_strong(H,strat);
1195 H = L;
1196 }
1197 else
1198 {
1199 /*
1200 * we reduce with good ecart, h need not to be put to T
1201 */
1202 ksReducePoly(&H, &(strat->T[ii]), strat->kNoetherTail(), NULL, NULL, strat,
1203 (flag & KSTD_NF_NONORM)==0);
1204 }
1205 if (H.p == NULL)
1206 return NULL;
1207 /*- try to reduce the s-polynomial -*/
1208 o = H.SetpFDeg();
1209 if ((flag &2 ) == 0) cancelunit(&H,TRUE);
1210 H.ecart = currRing->pLDeg(H.p,&(H.length),currRing)-o;
1211 j = 0;
1212 H.sev = pGetShortExpVector(H.p);
1213 not_sev = ~ H.sev;
1214 }
1215 else
1216 {
1217 j++;
1218 }
1219 }
1220}
static FORCE_INLINE number n_QuotRem(number a, number b, number *q, const coeffs r)
Definition coeffs.h:685
static FORCE_INLINE BOOLEAN n_DivBy(number a, number b, const coeffs r)
test whether 'a' is divisible 'b'; for r encoding a field: TRUE iff 'b' does not represent zero in Z:...
Definition coeffs.h:757
int ksReducePolyLC(LObject *PR, TObject *PW, poly spNoether, number *coef, kStrategy strat)
Definition kspoly.cc:481
int kTestDivisibleByT0_Z(const kStrategy strat, const LObject *L)
tests if T[0] divides the leading monomial of L, returns -1 if not
Definition kstd2.cc:146
void mult(unsigned long *result, unsigned long *a, unsigned long *b, unsigned long p, int dega, int degb)
Definition minpoly.cc:647
number ndQuotRem(number a, number b, number *r, const coeffs R)
Definition numbers.cc:356

◆ redRiloc()

int redRiloc ( LObject * h,
kStrategy strat )

Definition at line 387 of file kstd1.cc.

388{
389 int i,at,ei,li,ii;
390 int j = 0;
391 int pass = 0;
392 long d,reddeg;
393
394 d = h->GetpFDeg()+ h->ecart;
395 reddeg = strat->LazyDegree+d;
396 h->SetShortExpVector();
397 loop
398 {
399 j = kFindDivisibleByInT(strat, h);
400 if (j < 0)
401 {
402 // over ZZ: cleanup coefficients by complete reduction with monomials
403 postReduceByMon(h, strat);
404 if(h->p == NULL)
405 {
406 kDeleteLcm(h);
407 h->Clear();
408 return 0;
409 }
410 if (strat->honey) h->SetLength(strat->length_pLength);
411 if(strat->tl >= 0)
412 h->i_r1 = strat->tl;
413 else
414 h->i_r1 = -1;
415 if (h->GetLmTailRing() == NULL)
416 {
417 kDeleteLcm(h);
418 h->Clear();
419 return 0;
420 }
421 return 1;
422 }
423
424 ei = strat->T[j].ecart;
425 ii = j;
426 if (ei > h->ecart && ii < strat->tl)
427 {
428 li = strat->T[j].length;
429 // the polynomial to reduce with (up to the moment) is;
430 // pi with ecart ei and length li
431 // look for one with smaller ecart
432 i = j;
433 loop
434 {
435 /*- takes the first possible with respect to ecart -*/
436 i++;
437#if 1
438 if (i > strat->tl) break;
439 if ((strat->T[i].ecart < ei || (strat->T[i].ecart == ei &&
440 strat->T[i].length < li))
441 &&
442 p_LmShortDivisibleBy(strat->T[i].GetLmTailRing(), strat->sevT[i], h->GetLmTailRing(), ~h->sev, strat->tailRing)
443 &&
444 n_DivBy(h->p->coef,strat->T[i].p->coef,strat->tailRing->cf))
445#else
446 j = kFindDivisibleByInT(strat, h, i);
447 if (j < 0) break;
448 i = j;
449 if (strat->T[i].ecart < ei || (strat->T[i].ecart == ei &&
450 strat->T[i].length < li))
451#endif
452 {
453 // the polynomial to reduce with is now
454 ii = i;
455 ei = strat->T[i].ecart;
456 if (ei <= h->ecart) break;
457 li = strat->T[i].length;
458 }
459 }
460 }
461
462 // end of search: have to reduce with pi
463 if (ei > h->ecart)
464 {
465 // It is not possible to reduce h with smaller ecart;
466 // if possible h goes to the lazy-set L,i.e
467 // if its position in L would be not the last one
468 strat->fromT = TRUE;
469 if (!TEST_OPT_REDTHROUGH && strat->Ll >= 0) /*- L is not empty -*/
470 {
471 h->SetLmCurrRing();
472 if (strat->honey && strat->posInLDependsOnLength)
473 h->SetLength(strat->length_pLength);
474 assume(h->FDeg == h->pFDeg());
475 at = strat->posInL(strat->L,strat->Ll,h,strat);
476 if (at <= strat->Ll && pLmCmp(h->p, strat->L[strat->Ll].p) != 0 && !nEqual(h->p->coef, strat->L[strat->Ll].p->coef))
477 {
478 /*- h will not become the next element to reduce -*/
479 enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
480 #ifdef KDEBUG
481 if (TEST_OPT_DEBUG) Print(" ecart too big; -> L%d\n",at);
482 #endif
483 h->Clear();
484 strat->fromT = FALSE;
485 return -1;
486 }
487 }
488 doRed(h,&(strat->T[ii]),strat->fromT,strat,TRUE);
489 }
490 else
491 {
492 // now we finally can reduce
493 doRed(h,&(strat->T[ii]),strat->fromT,strat,FALSE);
494 }
495 strat->fromT=FALSE;
496 // are we done ???
497 if (h->IsNull())
498 {
499 kDeleteLcm(h);
500 h->Clear();
501 return 0;
502 }
503
504 // NO!
505 h->SetShortExpVector();
506 h->SetpFDeg();
507 if (strat->honey)
508 {
509 if (ei <= h->ecart)
510 h->ecart = d-h->GetpFDeg();
511 else
512 h->ecart = d-h->GetpFDeg()+ei-h->ecart;
513 }
514 else
515 // this has the side effect of setting h->length
516 h->ecart = h->pLDeg(strat->LDegLast) - h->GetpFDeg();
517 /*- try to reduce the s-polynomial -*/
518 pass++;
519 d = h->GetpFDeg()+h->ecart;
520 /*
521 *test whether the polynomial should go to the lazyset L
522 *-if the degree jumps
523 *-if the number of pre-defined reductions jumps
524 */
525 if (!TEST_OPT_REDTHROUGH && (strat->Ll >= 0)
526 && ((d >= reddeg) || (pass > strat->LazyPass)))
527 {
528 h->SetLmCurrRing();
529 if (strat->honey && strat->posInLDependsOnLength)
530 h->SetLength(strat->length_pLength);
531 assume(h->FDeg == h->pFDeg());
532 at = strat->posInL(strat->L,strat->Ll,h,strat);
533 if (at <= strat->Ll)
534 {
535 int dummy=strat->sl;
536 if (kFindDivisibleByInS(strat, &dummy, h) < 0)
537 {
538 if (strat->honey && !strat->posInLDependsOnLength)
539 h->SetLength(strat->length_pLength);
540 return 1;
541 }
542 enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
543#ifdef KDEBUG
544 if (TEST_OPT_DEBUG) Print(" degree jumped; ->L%d\n",at);
545#endif
546 h->Clear();
547 return -1;
548 }
549 }
550 else if ((TEST_OPT_PROT) && (strat->Ll < 0) && (d >= reddeg))
551 {
552 Print(".%ld",d);mflush();
553 reddeg = d+1;
554 if (h->pTotalDeg()+h->ecart >= (int)strat->tailRing->bitmask)
555 {
556 strat->overflow=TRUE;
557 //Print("OVERFLOW in redEcart d=%ld, max=%ld",d,strat->tailRing->bitmask);
558 h->GetP();
559 at = strat->posInL(strat->L,strat->Ll,h,strat);
560 enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
561 h->Clear();
562 return -1;
563 }
564 }
565 }
566}
void postReduceByMon(LObject *h, kStrategy strat)
used for GB over ZZ: intermediate reduction by monomial elements background: any known constant eleme...
Definition kutil.cc:10762
#define nEqual(n1, n2)
Definition numbers.h:20
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
Definition polys.h:105

◆ redRiloc_Z()

int redRiloc_Z ( LObject * h,
kStrategy strat )

Definition at line 568 of file kstd1.cc.

569{
570 int i,at,ei,li,ii;
571 int j = 0;
572 int pass = 0;
573 long d,reddeg;
574 int docoeffred = 0;
575 poly T0p = strat->T[0].p;
576 int T0ecart = strat->T[0].ecart;
577
578
579 d = h->GetpFDeg()+ h->ecart;
580 reddeg = strat->LazyDegree+d;
581 h->SetShortExpVector();
582 if ((strat->tl>=0)
583 &&strat->T[0].GetpFDeg() == 0
584 && strat->T[0].length <= 2)
585 {
586 docoeffred = 1;
587 }
588 loop
589 {
590 /* cut down the lead coefficients, only possible if the degree of
591 * T[0] is 0 (constant). This is only efficient if T[0] is short, thus
592 * we ask for the length of T[0] to be <= 2 */
593 if (docoeffred)
594 {
595 j = kTestDivisibleByT0_Z(strat, h);
596 if (j == 0 && n_DivBy(pGetCoeff(h->p), pGetCoeff(T0p), currRing->cf) == FALSE
597 && T0ecart <= h->ecart)
598 {
599 /* not(lc(reducer) | lc(poly)) && not(lc(poly) | lc(reducer))
600 * => we try to cut down the lead coefficient at least */
601 /* first copy T[j] in order to multiply it with a coefficient later on */
603 TObject tj = strat->T[0];
604 tj.Copy();
605 /* compute division with remainder of lc(h) and lc(T[j]) */
607 &rest, currRing->cf);
608 /* set corresponding new lead coefficient already. we do not
609 * remove the lead term in ksReducePolyLC, but only apply
610 * a lead coefficient reduction */
611 tj.Mult_nn(mult);
612 ksReducePolyLC(h, &tj, NULL, &rest, strat);
613 tj.Delete();
614 tj.Clear();
615 if (n_IsZero(pGetCoeff(h->GetP()),currRing->cf))
616 {
617 h->LmDeleteAndIter();
618 }
619 }
620 }
621 j = kFindDivisibleByInT(strat, h);
622 if (j < 0)
623 {
624 // over ZZ: cleanup coefficients by complete reduction with monomials
625 postReduceByMon(h, strat);
626 if(h->p == NULL)
627 {
628 kDeleteLcm(h);
629 h->Clear();
630 return 0;
631 }
632 if (strat->honey) h->SetLength(strat->length_pLength);
633 if(strat->tl >= 0)
634 h->i_r1 = strat->tl;
635 else
636 h->i_r1 = -1;
637 if (h->GetLmTailRing() == NULL)
638 {
639 kDeleteLcm(h);
640 h->Clear();
641 return 0;
642 }
643 return 1;
644 }
645
646 ei = strat->T[j].ecart;
647 ii = j;
648#if 1
649 if (ei > h->ecart && ii < strat->tl)
650 {
651 li = strat->T[j].length;
652 // the polynomial to reduce with (up to the moment) is;
653 // pi with ecart ei and length li
654 // look for one with smaller ecart
655 i = j;
656 loop
657 {
658 /*- takes the first possible with respect to ecart -*/
659 i++;
660#if 1
661 if (i > strat->tl) break;
662 if ((strat->T[i].ecart < ei || (strat->T[i].ecart == ei &&
663 strat->T[i].length < li))
664 &&
665 p_LmShortDivisibleBy(strat->T[i].GetLmTailRing(), strat->sevT[i], h->GetLmTailRing(), ~h->sev, strat->tailRing)
666 &&
667 n_DivBy(h->p->coef,strat->T[i].p->coef,strat->tailRing->cf))
668#else
669 j = kFindDivisibleByInT(strat, h, i);
670 if (j < 0) break;
671 i = j;
672 if (strat->T[i].ecart < ei || (strat->T[i].ecart == ei &&
673 strat->T[i].length < li))
674#endif
675 {
676 // the polynomial to reduce with is now
677 ii = i;
678 ei = strat->T[i].ecart;
679 if (ei <= h->ecart) break;
680 li = strat->T[i].length;
681 }
682 }
683 }
684#endif
685
686 // end of search: have to reduce with pi
687 if (ei > h->ecart)
688 {
689 // It is not possible to reduce h with smaller ecart;
690 // if possible h goes to the lazy-set L,i.e
691 // if its position in L would be not the last one
692 strat->fromT = TRUE;
693 if (!TEST_OPT_REDTHROUGH && strat->Ll >= 0) /*- L is not empty -*/
694 {
695 h->SetLmCurrRing();
696 if (strat->honey && strat->posInLDependsOnLength)
697 h->SetLength(strat->length_pLength);
698 assume(h->FDeg == h->pFDeg());
699 at = strat->posInL(strat->L,strat->Ll,h,strat);
700 if (at <= strat->Ll && pLmCmp(h->p, strat->L[strat->Ll].p) != 0 && !nEqual(h->p->coef, strat->L[strat->Ll].p->coef))
701 {
702 /*- h will not become the next element to reduce -*/
703 enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
704#ifdef KDEBUG
705 if (TEST_OPT_DEBUG) Print(" ecart too big; -> L%d\n",at);
706#endif
707 h->Clear();
708 strat->fromT = FALSE;
709 return -1;
710 }
711 }
712 doRed(h,&(strat->T[ii]),strat->fromT,strat,TRUE);
713 }
714 else
715 {
716 // now we finally can reduce
717 doRed(h,&(strat->T[ii]),strat->fromT,strat,FALSE);
718 }
719 strat->fromT=FALSE;
720 // are we done ???
721 if (h->IsNull())
722 {
723 kDeleteLcm(h);
724 h->Clear();
725 return 0;
726 }
727
728 // NO!
729 h->SetShortExpVector();
730 h->SetpFDeg();
731 if (strat->honey)
732 {
733 if (ei <= h->ecart)
734 h->ecart = d-h->GetpFDeg();
735 else
736 h->ecart = d-h->GetpFDeg()+ei-h->ecart;
737 }
738 else
739 // this has the side effect of setting h->length
740 h->ecart = h->pLDeg(strat->LDegLast) - h->GetpFDeg();
741 /*- try to reduce the s-polynomial -*/
742 pass++;
743 d = h->GetpFDeg()+h->ecart;
744 /*
745 *test whether the polynomial should go to the lazyset L
746 *-if the degree jumps
747 *-if the number of pre-defined reductions jumps
748 */
749 if (!TEST_OPT_REDTHROUGH && (strat->Ll >= 0)
750 && ((d >= reddeg) || (pass > strat->LazyPass)))
751 {
752 h->SetLmCurrRing();
753 if (strat->honey && strat->posInLDependsOnLength)
754 h->SetLength(strat->length_pLength);
755 assume(h->FDeg == h->pFDeg());
756 at = strat->posInL(strat->L,strat->Ll,h,strat);
757 if (at <= strat->Ll)
758 {
759 int dummy=strat->sl;
760 if (kFindDivisibleByInS(strat, &dummy, h) < 0)
761 {
762 if (strat->honey && !strat->posInLDependsOnLength)
763 h->SetLength(strat->length_pLength);
764 return 1;
765 }
766 enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
767#ifdef KDEBUG
768 if (TEST_OPT_DEBUG) Print(" degree jumped; ->L%d\n",at);
769#endif
770 h->Clear();
771 return -1;
772 }
773 }
774 else if ((TEST_OPT_PROT) && (strat->Ll < 0) && (d >= reddeg))
775 {
776 Print(".%ld",d);mflush();
777 reddeg = d+1;
778 if (h->pTotalDeg()+h->ecart >= (int)strat->tailRing->bitmask)
779 {
780 strat->overflow=TRUE;
781 //Print("OVERFLOW in redEcart d=%ld, max=%ld",d,strat->tailRing->bitmask);
782 h->GetP();
783 at = strat->posInL(strat->L,strat->Ll,h,strat);
784 enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
785 h->Clear();
786 return -1;
787 }
788 }
789 }
790}
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
Definition coeffs.h:468

◆ reorderL()

void reorderL ( kStrategy strat)

Definition at line 1226 of file kstd1.cc.

1227{
1228 int i,j,at;
1229 LObject p;
1230
1231 for (i=1; i<=strat->Ll; i++)
1232 {
1233 at = strat->posInL(strat->L,i-1,&(strat->L[i]),strat);
1234 if (at != i)
1235 {
1236 p = strat->L[i];
1237 for (j=i-1; j>=at; j--) strat->L[j+1] = strat->L[j];
1238 strat->L[at] = p;
1239 }
1240 }
1241}

◆ reorderT()

void reorderT ( kStrategy strat)

Definition at line 1246 of file kstd1.cc.

1247{
1248 int i,j,at;
1249 TObject p;
1250 unsigned long sev;
1251
1252
1253 for (i=1; i<=strat->tl; i++)
1254 {
1255 if (strat->T[i-1].length > strat->T[i].length)
1256 {
1257 p = strat->T[i];
1258 sev = strat->sevT[i];
1259 at = i-1;
1260 loop
1261 {
1262 at--;
1263 if (at < 0) break;
1264 if (strat->T[i].length > strat->T[at].length) break;
1265 }
1266 for (j = i-1; j>at; j--)
1267 {
1268 strat->T[j+1]=strat->T[j];
1269 strat->sevT[j+1]=strat->sevT[j];
1270 strat->R[strat->T[j+1].i_r] = &(strat->T[j+1]);
1271 }
1272 strat->T[at+1]=p;
1273 strat->sevT[at+1] = sev;
1274 strat->R[p.i_r] = &(strat->T[at+1]);
1275 }
1276 }
1277}

◆ updateL()

void updateL ( kStrategy strat)

Definition at line 1398 of file kstd1.cc.

1399{
1400 LObject p;
1401 int dL;
1402 int j=strat->Ll;
1403 loop
1404 {
1405 if (j<0) break;
1406 if (hasPurePower(&(strat->L[j]),strat->lastAxis,&dL,strat))
1407 {
1408 p=strat->L[strat->Ll];
1409 strat->L[strat->Ll]=strat->L[j];
1410 strat->L[j]=p;
1411 break;
1412 }
1413 j--;
1414 }
1415 if (j<0)
1416 {
1417 j=strat->Ll;
1418 loop
1419 {
1420 if (j<0) break;
1421 if (pNext(strat->L[j].p) == strat->tail)
1422 {
1424 pLmDelete(strat->L[j].p); /*deletes the short spoly and computes*/
1425 else
1426 pLmFree(strat->L[j].p); /*deletes the short spoly and computes*/
1427 strat->L[j].p = NULL;
1428 poly m1 = NULL, m2 = NULL;
1429 // check that spoly creation is ok
1430 while (strat->tailRing != currRing &&
1431 !kCheckSpolyCreation(&(strat->L[j]), strat, m1, m2))
1432 {
1433 assume(m1 == NULL && m2 == NULL);
1434 // if not, change to a ring where exponents are at least
1435 // large enough
1436 kStratChangeTailRing(strat);
1437 }
1438 /* create the real one */
1439 ksCreateSpoly(&(strat->L[j]), strat->kNoetherTail(), FALSE,
1440 strat->tailRing, m1, m2, strat->R);
1441
1442 strat->L[j].SetLmCurrRing();
1443 if (!strat->honey)
1444 strat->initEcart(&strat->L[j]);
1445 else
1446 strat->L[j].SetLength(strat->length_pLength);
1447
1448 BOOLEAN pp = hasPurePower(&(strat->L[j]),strat->lastAxis,&dL,strat);
1449
1450 if (strat->use_buckets) strat->L[j].PrepareRed(TRUE);
1451
1452 if (pp)
1453 {
1454 p=strat->L[strat->Ll];
1455 strat->L[strat->Ll]=strat->L[j];
1456 strat->L[j]=p;
1457 break;
1458 }
1459 }
1460 j--;
1461 }
1462 }
1463}

◆ updateLHC()

void updateLHC ( kStrategy strat)

Definition at line 1469 of file kstd1.cc.

1470{
1471
1472 int i = 0;
1473 kTest_TS(strat);
1474 while (i <= strat->Ll)
1475 {
1476 if (pNext(strat->L[i].p) == strat->tail)
1477 {
1478 /*- deletes the int spoly and computes -*/
1479 if (pLmCmp(strat->L[i].p,strat->kNoether) == -1)
1480 {
1482 pLmDelete(strat->L[i].p);
1483 else
1484 pLmFree(strat->L[i].p);
1485 strat->L[i].p = NULL;
1486 }
1487 else
1488 {
1490 pLmDelete(strat->L[i].p);
1491 else
1492 pLmFree(strat->L[i].p);
1493 strat->L[i].p = NULL;
1494 poly m1 = NULL, m2 = NULL;
1495 // check that spoly creation is ok
1496 while (strat->tailRing != currRing &&
1497 !kCheckSpolyCreation(&(strat->L[i]), strat, m1, m2))
1498 {
1499 assume(m1 == NULL && m2 == NULL);
1500 // if not, change to a ring where exponents are at least
1501 // large enough
1502 kStratChangeTailRing(strat);
1503 }
1504 /* create the real one */
1505 ksCreateSpoly(&(strat->L[i]), strat->kNoetherTail(), FALSE,
1506 strat->tailRing, m1, m2, strat->R);
1507 if (! strat->L[i].IsNull())
1508 {
1509 strat->L[i].SetLmCurrRing();
1510 strat->L[i].SetpFDeg();
1511 strat->L[i].ecart
1512 = strat->L[i].pLDeg(strat->LDegLast) - strat->L[i].GetpFDeg();
1513 if (strat->use_buckets) strat->L[i].PrepareRed(TRUE);
1514 }
1515 }
1516 }
1517 deleteHC(&(strat->L[i]), strat);
1518 if (strat->L[i].IsNull())
1519 deleteInL(strat->L,&strat->Ll,i,strat);
1520 else
1521 {
1522#ifdef KDEBUG
1523 kTest_L(&(strat->L[i]), strat, TRUE, i, strat->T, strat->tl);
1524#endif
1525 i++;
1526 }
1527 }
1528 kTest_TS(strat);
1529}

◆ updateT()

void updateT ( kStrategy strat)

Definition at line 1535 of file kstd1.cc.

1536{
1537 int i = 0;
1538 LObject p;
1539
1540 while (i <= strat->tl)
1541 {
1542 p = strat->T[i];
1543 deleteHC(&p,strat, TRUE);
1544 /*- tries to cancel a unit: -*/
1545 cancelunit(&p);
1546 if (TEST_OPT_INTSTRATEGY) /* deleteHC and/or cancelunit may have changed p*/
1547 p.pCleardenom();
1548 if (p.p != strat->T[i].p)
1549 {
1550 strat->sevT[i] = pGetShortExpVector(p.p);
1551 p.SetpFDeg();
1552 }
1553 strat->T[i] = p;
1554 i++;
1555 }
1556}

Variable Documentation

◆ kHomW

VAR intvec * kHomW

Definition at line 2424 of file kstd1.cc.

◆ kModW

VAR intvec* kModW

Definition at line 2424 of file kstd1.cc.

◆ kOptions

VAR BITSET kOptions
Initial value:
#define OPT_SUGARCRIT
Definition options.h:80
#define OPT_PROT
Definition options.h:75
#define OPT_INFREDTAIL
Definition options.h:94
#define OPT_WEIGHTM
Definition options.h:97
#define OPT_NOT_SUGAR
Definition options.h:78
#define OPT_NOTREGULARITY
Definition options.h:96
#define OPT_INTERRUPT
Definition options.h:79
#define OPT_FASTHC
Definition options.h:85
#define OPT_OLDSTD
Definition options.h:86

Definition at line 45 of file kstd1.cc.

◆ validOpts

VAR BITSET validOpts

Definition at line 60 of file kstd1.cc.