#include <string.h>
#include <omalloc/omalloc.h>
#include <omalloc/omallocClass.h>
#include <misc/mylimits.h>
#include <kernel/polys.h>
#include <polys/operations/pShallowCopyDelete.h>
#include <kernel/structs.h>
#include <kernel/GBEngine/kstd1.h>
#include <kernel/GBEngine/kInline.h>
#include <kernel/GBEngine/shiftgb.h>

Data Structures
struct	denominator_list_s

class	sTObject

class	sLObject

class	skStrategy

Macros
#define	HAVE_TAIL_RING

#define	setmax 16

#define	setmaxL ((4096-12)/sizeof(LObject))

#define	setmaxLinc ((4096)/sizeof(LObject))

#define	setmaxT 64

#define	setmaxTinc 32

#define	KINLINE

#define	NO_KINLINE 1

#define	ALLOW_PROD_CRIT(A) (!(A)->no_prod_crit)

#define	messageSets(s) do {} while (0)

#define	kTest(A) (TRUE)

#define	kTest_TS(A) (TRUE)

#define	kTest_T(T) (TRUE)

#define	kTest_S(T) (TRUE)

#define	kTest_L(T) (TRUE)

Typedefs
typedef int *	intset

typedef int64	wlen_type

typedef wlen_type *	wlen_set

typedef class sTObject	TObject

typedef class sLObject	LObject

typedef TObject *	TSet

typedef LObject *	LSet

typedef denominator_list_s *	denominator_list

Functions
void	deleteHC (poly p, int e, int *l, kStrategy strat)

void	deleteHC (LObject *L, kStrategy strat, BOOLEAN fromNext=FALSE)

void	deleteInS (int i, kStrategy strat)

void	deleteInSSba (int i, kStrategy strat)

void	cleanT (kStrategy strat)

static LSet	initL (int nr=setmaxL)

void	deleteInL (LSet set, int *length, int j, kStrategy strat)

void	enterL (LSet set, int length, int *LSetmax, LObject p, int at)

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

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

void	initEcartPairBba (LObject *Lp, poly f, poly g, int ecartF, int ecartG)

void	initEcartPairMora (LObject *Lp, poly f, poly g, int ecartF, int ecartG)

int	posInS (const kStrategy strat, const int length, const poly p, const int ecart_p)

int	posInT0 (const TSet set, const int length, LObject &p)

int	posInT1 (const TSet set, const int length, LObject &p)

int	posInT2 (const TSet set, const int length, LObject &p)

int	posInT11 (const TSet set, const int length, LObject &p)

int	posInTSig (const TSet set, const int length, LObject &p)

int	posInT110 (const TSet set, const int length, LObject &p)

int	posInT13 (const TSet set, const int length, LObject &p)

int	posInT15 (const TSet set, const int length, LObject &p)

int	posInT17 (const TSet set, const int length, LObject &p)

int	posInT19 (const TSet set, const int length, LObject &p)

int	posInT_EcartpLength (const TSet set, const int length, LObject &p)

void	reorderS (int *suc, kStrategy strat)

int	posInLF5C (const LSet set, const int length, LObject *L, const kStrategy strat)

int	posInLSig (const LSet set, const int length, LObject *L, const kStrategy strat)

int	posInLRing (const LSet set, const int length, LObject *L, const kStrategy strat)

int	posInSyz (const kStrategy strat, const poly sig)

int	posInL0 (const LSet set, const int length, LObject *L, const kStrategy strat)

int	posInL11 (const LSet set, const int length, LObject *L, const kStrategy strat)

int	posInL11Ring (const LSet set, const int length, LObject *L, const kStrategy strat)

int	posInL11Ringls (const LSet set, const int length, LObject *L, const kStrategy strat)

int	posInL13 (const LSet set, const int length, LObject *L, const kStrategy strat)

int	posInL15 (const LSet set, const int length, LObject *L, const kStrategy strat)

int	posInL17 (const LSet set, const int length, LObject *L, const kStrategy strat)

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

int	posInL110 (const LSet set, const int length, LObject *L, const kStrategy strat)

KINLINE poly	redtailBba (poly p, int pos, kStrategy strat, BOOLEAN normalize=FALSE)

KINLINE poly	redtailBba_Z (poly p, int pos, kStrategy strat)

poly	redtailBba_Z (LObject *L, int pos, kStrategy strat)

poly	redtailBba (LObject *L, int pos, kStrategy strat, BOOLEAN withT=FALSE, BOOLEAN normalize=FALSE)

poly	redtailSba (LObject *L, int pos, kStrategy strat, BOOLEAN withT=FALSE, BOOLEAN normalize=FALSE)

poly	redtailBba (TObject *T, int pos, kStrategy strat)

poly	redtail (poly p, int pos, kStrategy strat)

poly	redtail (LObject *L, int pos, kStrategy strat)

poly	redNF (poly h, int &max_ind, int nonorm, kStrategy strat)

int	redNF0 (LObject *P, kStrategy strat)

poly	redNFTail (poly h, const int sl, kStrategy strat)

int	redHoney (LObject *h, kStrategy strat)

int	redRing (LObject *h, kStrategy strat)

int	redRiloc (LObject *h, kStrategy strat)

void	enterExtendedSpoly (poly h, kStrategy strat)

void	superenterpairs (poly h, int k, int ecart, int pos, kStrategy strat, int atR=-1)

poly	kCreateZeroPoly (long exp[], long cabsind, poly *t_p, ring leadRing, ring tailRing)

long	ind2 (long arg)

long	ind_fact_2 (long arg)

long	twoPow (long arg)

ideal	createG0 ()

int	redLazy (LObject *h, kStrategy strat)

int	redHomog (LObject *h, kStrategy strat)

int	redSig (LObject *h, kStrategy strat)

void	enterpairsSig (poly h, poly hSig, int from, int k, int ec, int pos, kStrategy strat, int atR=-1)

void	enterpairs (poly h, int k, int ec, int pos, kStrategy strat, int atR=-1)

void	entersets (LObject h)

void	pairs ()

BOOLEAN	enterOneStrongPoly (int i, poly p, int, int, kStrategy strat, int atR=-1, bool enterTstrong=FALSE)

void	message (int i, int reduc, int olddeg, kStrategy strat, int red_result)

void	messageStat (int hilbcount, kStrategy strat)

void	initEcartNormal (TObject *h)

void	initEcartBBA (TObject *h)

void	initS (ideal F, ideal Q, kStrategy strat)

void	initSL (ideal F, ideal Q, kStrategy strat)

void	initSLSba (ideal F, ideal Q, kStrategy strat)

void	initSyzRules (kStrategy strat)

void	updateS (BOOLEAN toT, kStrategy strat)

void	enterSyz (LObject &p, kStrategy strat, int atT)

void	enterT (LObject &p, kStrategy strat, int atT=-1)

void	enterT_strong (LObject &p, kStrategy strat, int atT=-1)

void	cancelunit (LObject *p, BOOLEAN inNF=FALSE)

void	HEckeTest (poly pp, kStrategy strat)

void	initBuchMoraCrit (kStrategy strat)

void	initSbaCrit (kStrategy strat)

void	initHilbCrit (ideal F, ideal Q, intvec **hilb, kStrategy strat)

void	initBuchMoraPos (kStrategy strat)

void	initSbaPos (kStrategy strat)

void	initBuchMora (ideal F, ideal Q, kStrategy strat)

void	initSbaBuchMora (ideal F, ideal Q, kStrategy strat)

void	exitBuchMora (kStrategy strat)

void	exitSba (kStrategy strat)

void	updateResult (ideal r, ideal Q, kStrategy strat)

void	completeReduce (kStrategy strat, BOOLEAN withT=FALSE)

void	kFreeStrat (kStrategy strat)

void	enterOnePairNormal (int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR)

void	enterOnePairLift (int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR)

void	enterOnePairSig (int i, poly p, poly pSig, int ecart, int isFromQ, kStrategy strat, int atR)

void	chainCritNormal (poly p, int ecart, kStrategy strat)

void	chainCritOpt_1 (poly, int, kStrategy strat)

void	chainCritSig (poly p, int ecart, kStrategy strat)

BOOLEAN	homogTest (polyset F, int Fmax)

BOOLEAN	newHEdge (kStrategy strat)

BOOLEAN	syzCriterion (poly sig, unsigned long not_sevSig, kStrategy strat)

BOOLEAN	syzCriterionInc (poly sig, unsigned long not_sevSig, kStrategy strat)

KINLINE BOOLEAN	arriRewDummy (poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)

BOOLEAN	arriRewCriterion (poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)

BOOLEAN	arriRewCriterionPre (poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)

BOOLEAN	faugereRewCriterion (poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)

BOOLEAN	findMinLMPair (poly sig, unsigned long not_sevSig, kStrategy strat, int start)

int	kFindInT (poly p, TSet T, int tlength)
	returns index of p in TSet, or -1 if not found More...

int	kFindDivisibleByInT (const kStrategy strat, const LObject *L, const int start=0)
	return -1 if no divisor is found number of first divisor in T, otherwise More...

int	kFindDivisibleByInS (const kStrategy strat, int max_ind, LObject L)
	return -1 if no divisor is found number of first divisor in S, otherwise More...

int	kFindNextDivisibleByInS (const kStrategy strat, int start, int max_ind, LObject *L)

TObject *	kFindDivisibleByInS (kStrategy strat, int pos, LObject L, TObject T, long ecart=LONG_MAX)

KINLINE TSet	initT ()

KINLINE TObject **	initR ()

KINLINE unsigned long *	initsevT ()

KINLINE poly	k_LmInit_currRing_2_tailRing (poly p, ring tailRing, omBin bin)

KINLINE poly	k_LmInit_tailRing_2_currRing (poly p, ring tailRing, omBin bin)

KINLINE poly	k_LmShallowCopyDelete_currRing_2_tailRing (poly p, ring tailRing, omBin bin)

KINLINE poly	k_LmShallowCopyDelete_tailRing_2_currRing (poly p, ring tailRing, omBin bin)

KINLINE poly	k_LmInit_currRing_2_tailRing (poly p, ring tailRing)

KINLINE poly	k_LmInit_tailRing_2_currRing (poly p, ring tailRing)

KINLINE poly	k_LmShallowCopyDelete_currRing_2_tailRing (poly p, ring tailRing)

KINLINE poly	k_LmShallowCopyDelete_tailRing_2_currRing (poly p, ring tailRing)

KINLINE BOOLEAN	k_GetLeadTerms (const poly p1, const poly p2, const ring p_r, poly &m1, poly &m2, const ring m_r)

KINLINE void	k_GetStrongLeadTerms (const poly p1, const poly p2, const ring leadRing, poly &m1, poly &m2, poly &lcm, const ring taiRing)

poly	kFindZeroPoly (poly input_p, ring leadRing, ring tailRing)

ideal	bba (ideal F, ideal Q, intvec w, intvec hilb, kStrategy strat)

ideal	sba (ideal F, ideal Q, intvec w, intvec hilb, kStrategy strat)

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

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

void	initBba (ideal F, kStrategy strat)

void	initSba (ideal F, kStrategy strat)

void	f5c (kStrategy strat, int &olddeg, int &minimcnt, int &hilbeledeg, int &hilbcount, int &srmax, int &lrmax, int &reduc, ideal Q, intvec w, intvec hilb)

int	ksReducePoly (LObject PR, TObject PW, poly spNoether=NULL, number *coef=NULL, kStrategy strat=NULL)

int	ksReducePolySig (LObject PR, TObject PW, long idx, poly spNoether=NULL, number *coef=NULL, kStrategy strat=NULL)

int	ksReducePolyTail (LObject PR, TObject PW, poly Current, poly spNoether=NULL)

KINLINE int	ksReducePolyTail (LObject PR, TObject PW, LObject *Red)

void	ksCreateSpoly (LObject Pair, poly spNoether=NULL, int use_buckets=0, ring tailRing=currRing, poly m1=NULL, poly m2=NULL, TObject *R=NULL)

poly	ksCreateShortSpoly (poly p1, poly p2, ring tailRing)

KINLINE poly	ksOldSpolyRed (poly p1, poly p2, poly spNoether=NULL)

KINLINE poly	ksOldSpolyRedNew (poly p1, poly p2, poly spNoether=NULL)

KINLINE poly	ksOldCreateSpoly (poly p1, poly p2, poly spNoether=NULL, ring r=currRing)

KINLINE void	ksOldSpolyTail (poly p1, poly q, poly q2, poly spNoether, ring r=currRing)

BOOLEAN	kCheckSpolyCreation (LObject *L, kStrategy strat, poly &m1, poly &m2)

BOOLEAN	kCheckStrongCreation (int atR, poly m1, int atS, poly m2, kStrategy strat)

poly	preIntegerCheck (ideal F, ideal Q)
	used for GB over ZZ: look for constant and monomial elements in the ideal background: any known constant element of ideal suppresses intermediate coefficient swell More...

void	postReduceByMon (LObject *h, kStrategy strat)
	used for GB over ZZ: intermediate reduction by monomial elements background: any known constant element of ideal suppresses intermediate coefficient swell More...

void	finalReduceByMon (kStrategy strat)
	used for GB over ZZ: final reduction by constant elements background: any known constant element of ideal suppresses intermediate coefficient swell and beautifies output More...

BOOLEAN	kStratChangeTailRing (kStrategy strat, LObject L=NULL, TObject T=NULL, unsigned long new_expbound=0)

void	kStratInitChangeTailRing (kStrategy strat)

void	kDebugPrint (kStrategy strat)
	Output some debug info about a given strategy. More...

ring	sbaRing (kStrategy strat, const ring r=currRing, BOOLEAN complete=TRUE, int sgn=1)

KINLINE void	clearS (poly p, unsigned long p_sev, int at, int k, kStrategy strat)

poly	pMove2CurrTail (poly p, kStrategy strat)

poly	pMoveCurrTail2poly (poly p, kStrategy strat)

poly	pCopyL2p (LObject h, kStrategy strat)

void	enterTShift (LObject p, kStrategy strat, int atT, int uptodeg, int lV)

void	initBuchMoraShift (ideal F, ideal Q, kStrategy strat)

void	enterOnePairManyShifts (int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int uptodeg, int lV)

void	enterOnePairSelfShifts (poly qq, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int uptodeg, int lV)

void	enterOnePairShift (poly q, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int ecartq, int qisFromQ, int shiftcount, int ifromS, int uptodeg, int lV)

void	enterpairsShift (poly h, int k, int ecart, int pos, kStrategy strat, int atR, int uptodeg, int lV)

void	initenterpairsShift (poly h, int k, int ecart, int isFromQ, kStrategy strat, int atR, int uptodeg, int lV)

void	updateSShift (kStrategy strat, int uptodeg, int lV)

void	initBbaShift (ideal F, kStrategy strat)

poly	redtailBbaShift (LObject *L, int pos, kStrategy strat, BOOLEAN withT, BOOLEAN normalize)

int	redFirstShift (LObject *h, kStrategy strat)

ideal	freegb (ideal I, int uptodeg, int lVblock)

ideal	bbaShift (ideal F, ideal Q, intvec w, intvec hilb, kStrategy strat, int uptodeg, int lV)

Variables
denominator_list	DENOMINATOR_LIST

int	strat_nr

int	HCord

int(*	test_PosInT )(const TSet T, const int tl, LObject &h)

int(*	test_PosInL )(const LSet set, const int length, LObject *L, const kStrategy strat)

Data Structure Documentation

struct denominator_list_s

Definition at line 67 of file kutil.h.

Data Fields
number	n
denominator_list	next

Macro Definition Documentation

#define ALLOW_PROD_CRIT ( A ) (!(A)->no_prod_crit)

Definition at line 385 of file kutil.h.

#define HAVE_TAIL_RING

Definition at line 25 of file kutil.h.

#define KINLINE

Definition at line 51 of file kutil.h.

#define kTest ( A ) (TRUE)

Definition at line 619 of file kutil.h.

#define kTest_L ( T ) (TRUE)

Definition at line 623 of file kutil.h.

#define kTest_S ( T ) (TRUE)

Definition at line 622 of file kutil.h.

#define kTest_T ( T ) (TRUE)

Definition at line 621 of file kutil.h.

#define kTest_TS ( A ) (TRUE)

Definition at line 620 of file kutil.h.

#define messageSets ( s ) do {} while (0)

Definition at line 508 of file kutil.h.

#define NO_KINLINE 1

Definition at line 52 of file kutil.h.

#define setmax 16

Definition at line 28 of file kutil.h.

#define setmaxL ((4096-12)/sizeof(LObject))

Definition at line 29 of file kutil.h.

#define setmaxLinc ((4096)/sizeof(LObject))

Definition at line 30 of file kutil.h.

#define setmaxT 64

Definition at line 32 of file kutil.h.

#define setmaxTinc 32

Definition at line 33 of file kutil.h.

Typedef Documentation

typedef denominator_list_s* denominator_list

Definition at line 65 of file kutil.h.

typedef int* intset

Definition at line 55 of file kutil.h.

typedef class sLObject LObject

Definition at line 60 of file kutil.h.

typedef LObject* LSet

Definition at line 62 of file kutil.h.

typedef class sTObject TObject

Definition at line 59 of file kutil.h.

typedef TObject* TSet

Definition at line 61 of file kutil.h.

typedef wlen_type* wlen_set

Definition at line 57 of file kutil.h.

typedef int64 wlen_type

Definition at line 56 of file kutil.h.

Function Documentation

BOOLEAN arriRewCriterion	(	poly	sig,
		unsigned long	not_sevSig,
		poly	lm,
		kStrategy	strat,
		int	start
	)

Definition at line 5806 of file kutil.cc.

 {
   poly p1 = pOne();
   poly p2 = pOne();
   for (int ii=strat->sl; ii>start; ii--)
   {
     if (p_LmShortDivisibleBy(strat->sig[ii], strat->sevSig[ii], strat->P.sig, ~strat->P.sevSig, currRing))
     {
       p_ExpVectorSum(p1,strat->P.sig,strat->S[ii],currRing);
       p_ExpVectorSum(p2,strat->sig[ii],strat->P.p,currRing);
       if (!(pLmCmp(p1,p2) == 1))
       {
         pDelete(&p1);
         pDelete(&p2);
         return TRUE;
       }
     }
   }
   pDelete(&p1);
   pDelete(&p2);
   return FALSE;
 }

BOOLEAN arriRewCriterionPre	(	poly	sig,
		unsigned long	not_sevSig,
		poly	lm,
		kStrategy	strat,
		int	start
	)

Definition at line 5829 of file kutil.cc.

 {
   int found = -1;
   for (int i=strat->Bl; i>-1; i--) {
     if (pLmEqual(strat->B[i].sig,sig)) {
       found = i;
       break;
     }
   }
   if (found != -1) {
     if (pLmCmp(lm,strat->B[found].GetLmCurrRing()) == -1) {
       deleteInL(strat->B,&strat->Bl,found,strat);
     } else {
       return TRUE;
     }
   }
   poly p1 = pOne();
   poly p2 = pOne();
   for (int ii=strat->sl; ii>-1; ii--)
   {
     if (p_LmShortDivisibleBy(strat->sig[ii], strat->sevSig[ii], sig, not_sevSig, currRing))
     {
       p_ExpVectorSum(p1,sig,strat->S[ii],currRing);
       p_ExpVectorSum(p2,strat->sig[ii],lm,currRing);
       if (!(pLmCmp(p1,p2) == 1))
       {
         pDelete(&p1);
         pDelete(&p2);
         return TRUE;
       }
     }
   }
   pDelete(&p1);
   pDelete(&p2);
   return FALSE;
 }

KINLINE BOOLEAN arriRewDummy	(	poly	sig,
		unsigned long	not_sevSig,
		poly	lm,
		kStrategy	strat,
		int	start
	)

Definition at line 1172 of file kInline.h.

 {
   return FALSE;
 }

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

Definition at line 1466 of file kstd2.cc.

 {
   int   red_result = 1;
   int   olddeg,reduc;
   int hilbeledeg=1,hilbcount=0,minimcnt=0;
   BOOLEAN withT = FALSE;
   BITSET save;
   SI_SAVE_OPT1(save);
 
   initBuchMoraCrit(strat); /*set Gebauer, honey, sugarCrit*/
   initBuchMoraPos(strat);
   initHilbCrit(F,Q,&hilb,strat);
   initBba(F,strat);
   /*set enterS, spSpolyShort, reduce, red, initEcart, initEcartPair*/
   /*Shdl=*/initBuchMora(F, Q,strat);
   if (strat->minim>0) strat->M=idInit(IDELEMS(F),F->rank);
   reduc = olddeg = 0;
 
 #ifndef NO_BUCKETS
   if (!TEST_OPT_NOT_BUCKETS)
     strat->use_buckets = 1;
 #endif
   // redtailBBa against T for inhomogenous input
   if (!TEST_OPT_OLDSTD)
     withT = ! strat->homog;
 
   // strat->posInT = posInT_pLength;
   kTest_TS(strat);
 
 #ifdef KDEBUG
 #if MYTEST
   if (TEST_OPT_DEBUG)
   {
     PrintS("bba start GB: currRing: ");
     // rWrite(currRing);PrintLn();
     rDebugPrint(currRing);
     PrintLn();
   }
 #endif /* MYTEST */
 #endif /* KDEBUG */
 
 #ifdef HAVE_TAIL_RING
   if(!idIs0(F) &&(!rField_is_Ring(currRing)))  // create strong gcd poly computes with tailring and S[i] ->to be fixed
     kStratInitChangeTailRing(strat);
 #endif
   if (BVERBOSE(23))
   {
     if (test_PosInT!=NULL) strat->posInT=test_PosInT;
     if (test_PosInL!=NULL) strat->posInL=test_PosInL;
     kDebugPrint(strat);
   }
 
 
 #ifdef KDEBUG
   //kDebugPrint(strat);
 #endif
   /* compute------------------------------------------------------- */
   while (strat->Ll >= 0)
   {
     #if ADIDEBUG
     printf("\n      ------------------------NEW LOOP\n");
     printf("\nShdl = \n");
     #if 0
     idPrint(strat->Shdl);
     #else
     for(int ii = 0; ii<=strat->sl;ii++)
         p_Write(strat->S[ii],strat->tailRing);
     #endif
     printf("\n   list   L\n");
     int iii;
     #if 1
     for(iii = 0; iii<= strat->Ll; iii++)
     {
         printf("L[%i]:",iii);
         p_Write(strat->L[iii].p, currRing);
         p_Write(strat->L[iii].p1, currRing);
         p_Write(strat->L[iii].p2, currRing);
     }
     #else
     {
         printf("L[%i]:",strat->Ll);
         p_Write(strat->L[strat->Ll].p, strat->tailRing);
         p_Write(strat->L[strat->Ll].p1, strat->tailRing);
         p_Write(strat->L[strat->Ll].p2, strat->tailRing);
     }
     #endif
     #if 1
     for(iii = 0; iii<= strat->Bl; iii++)
     {
         printf("B[%i]:",iii);
         p_Write(strat->B[iii].p, /*strat->tailRing*/currRing);
         p_Write(strat->B[iii].p1, /*strat->tailRing*/currRing);
         p_Write(strat->B[iii].p2, strat->tailRing);
     }
     #endif
     getchar();
     #endif
     #ifdef KDEBUG
       if (TEST_OPT_DEBUG) messageSets(strat);
     #endif
     if (strat->Ll== 0) strat->interpt=TRUE;
     if (TEST_OPT_DEGBOUND
         && ((strat->honey && (strat->L[strat->Ll].ecart+currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg))
             || ((!strat->honey) && (currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg))))
     {
       /*
        *stops computation if
        * 24 IN test and the degree +ecart of L[strat->Ll] is bigger then
        *a predefined number Kstd1_deg
        */
       while ((strat->Ll >= 0)
         && (strat->L[strat->Ll].p1!=NULL) && (strat->L[strat->Ll].p2!=NULL)
         && ((strat->honey && (strat->L[strat->Ll].ecart+currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg))
             || ((!strat->honey) && (currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg)))
         )
         deleteInL(strat->L,&strat->Ll,strat->Ll,strat);
       if (strat->Ll<0) break;
       else strat->noClearS=TRUE;
     }
     /* picks the last element from the lazyset L */
     strat->P = strat->L[strat->Ll];
     strat->Ll--;
 
     if (pNext(strat->P.p) == strat->tail)
     {
       // deletes the short spoly
 #ifdef HAVE_RINGS
       if (rField_is_Ring(currRing))
         pLmDelete(strat->P.p);
       else
 #endif
         pLmFree(strat->P.p);
       strat->P.p = NULL;
       poly m1 = NULL, m2 = NULL;
 
       // check that spoly creation is ok
       while (strat->tailRing != currRing &&
              !kCheckSpolyCreation(&(strat->P), strat, m1, m2))
       {
         assume(m1 == NULL && m2 == NULL);
         // if not, change to a ring where exponents are at least
         // large enough
         if (!kStratChangeTailRing(strat))
         {
           WerrorS("OVERFLOW...");
           break;
         }
       }
       // create the real one
       ksCreateSpoly(&(strat->P), NULL, strat->use_buckets,
                     strat->tailRing, m1, m2, strat->R);
     }
     else if (strat->P.p1 == NULL)
     {
       if (strat->minim > 0)
         strat->P.p2=p_Copy(strat->P.p, currRing, strat->tailRing);
       // for input polys, prepare reduction
       strat->P.PrepareRed(strat->use_buckets);
     }
 
     if (strat->P.p == NULL && strat->P.t_p == NULL)
     {
       red_result = 0;
     }
     else
     {
       if (TEST_OPT_PROT)
         message((strat->honey ? strat->P.ecart : 0) + strat->P.pFDeg(),
                 &olddeg,&reduc,strat, red_result);
 
       /* reduction of the element chosen from L */
       #if ADIDEBUG
       printf("\nBefore \n");pWrite(strat->P.p);
       #endif
       red_result = strat->red(&strat->P,strat);
       #if ADIDEBUG
       printf("\nAfter \n");pWrite(strat->P.p);
       #endif
       if (errorreported)  break;
     }
 
     if (strat->overflow)
     {
       if (!kStratChangeTailRing(strat)) { Werror("OVERFLOW.."); break;}
     }
 
     // reduction to non-zero new poly
     if (red_result == 1)
     {
       // get the polynomial (canonicalize bucket, make sure P.p is set)
       strat->P.GetP(strat->lmBin);
       // in the homogeneous case FDeg >= pFDeg (sugar/honey)
       // but now, for entering S, T, we reset it
       // in the inhomogeneous case: FDeg == pFDeg
       if (strat->homog) strat->initEcart(&(strat->P));
 
       /* statistic */
       if (TEST_OPT_PROT) PrintS("s");
 
       int pos=posInS(strat,strat->sl,strat->P.p,strat->P.ecart);
 
 #ifdef KDEBUG
 #if MYTEST
       PrintS("New S: "); p_DebugPrint(strat->P.p, currRing); PrintLn();
 #endif /* MYTEST */
 #endif /* KDEBUG */
 
       // reduce the tail and normalize poly
       // in the ring case we cannot expect LC(f) = 1,
       // therefore we call pContent instead of pNorm
       if ((TEST_OPT_INTSTRATEGY) || (rField_is_Ring(currRing)))
       {
         strat->P.pCleardenom();
         if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
         {
           strat->P.p = redtailBba(&(strat->P),pos-1,strat, withT);
           strat->P.pCleardenom();
         }
       }
       else
       {
         strat->P.pNorm();
         if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
           strat->P.p = redtailBba(&(strat->P),pos-1,strat, withT);
       }
 
 #ifdef KDEBUG
       if (TEST_OPT_DEBUG){PrintS("new s:");strat->P.wrp();PrintLn();}
 #if MYTEST
       PrintS("New (reduced) S: "); p_DebugPrint(strat->P.p, currRing); PrintLn();
 #endif /* MYTEST */
 #endif /* KDEBUG */
 
       // min_std stuff
       if ((strat->P.p1==NULL) && (strat->minim>0))
       {
         if (strat->minim==1)
         {
           strat->M->m[minimcnt]=p_Copy(strat->P.p,currRing,strat->tailRing);
           p_Delete(&strat->P.p2, currRing, strat->tailRing);
         }
         else
         {
           strat->M->m[minimcnt]=strat->P.p2;
           strat->P.p2=NULL;
         }
         if (strat->tailRing!=currRing && pNext(strat->M->m[minimcnt])!=NULL)
           pNext(strat->M->m[minimcnt])
             = strat->p_shallow_copy_delete(pNext(strat->M->m[minimcnt]),
                                            strat->tailRing, currRing,
                                            currRing->PolyBin);
         minimcnt++;
       }
 
       // enter into S, L, and T
       if ((!TEST_OPT_IDLIFT) || (pGetComp(strat->P.p) <= strat->syzComp))
       {
         enterT(strat->P, strat);
 #ifdef HAVE_RINGS
         if (rField_is_Ring(currRing))
           superenterpairs(strat->P.p,strat->sl,strat->P.ecart,pos,strat, strat->tl);
         else
 #endif
           enterpairs(strat->P.p,strat->sl,strat->P.ecart,pos,strat, strat->tl);
         // posInS only depends on the leading term
         #if ADIDEBUG
         printf("\nThis element is added to S\n");
         p_Write(strat->P.p, strat->tailRing);p_Write(strat->P.p1, strat->tailRing);p_Write(strat->P.p2, strat->tailRing);
         #endif
         strat->enterS(strat->P, pos, strat, strat->tl);
 #if 0
         int pl=pLength(strat->P.p);
         if (pl==1)
         {
           //if (TEST_OPT_PROT)
           //PrintS("<1>");
         }
         else if (pl==2)
         {
           //if (TEST_OPT_PROT)
           //PrintS("<2>");
         }
 #endif
       }
       if (strat->s_poly!=NULL)
       {
         if (strat->s_poly(strat))
         {
           // we are called AFTER enterS, i.e. if we change P
           // we have it also to S/T
           // and add pairs
           int pos=posInS(strat,strat->sl,strat->P.p,strat->P.ecart);
           enterT(strat->P, strat);
           #ifdef HAVE_RINGS
           if (rField_is_Ring(currRing))
             superenterpairs(strat->P.p,strat->sl,strat->P.ecart,pos,strat, strat->tl);
           else
           #endif
             enterpairs(strat->P.p,strat->sl,strat->P.ecart,pos,strat, strat->tl);
           strat->enterS(strat->P, pos, strat, strat->tl);
         }
       }
 
       if (hilb!=NULL) khCheck(Q,w,hilb,hilbeledeg,hilbcount,strat);
 //      Print("[%d]",hilbeledeg);
       if (strat->P.lcm!=NULL)
 #ifdef HAVE_RINGS
         pLmDelete(strat->P.lcm);
 #else
         pLmFree(strat->P.lcm);
 #endif
     }
     else if (strat->P.p1 == NULL && strat->minim > 0)
     {
       p_Delete(&strat->P.p2, currRing, strat->tailRing);
     }
 
 #ifdef KDEBUG
     memset(&(strat->P), 0, sizeof(strat->P));
 #endif /* KDEBUG */
     kTest_TS(strat);
   }
 #ifdef KDEBUG
 #if MYTEST
   PrintS("bba finish GB: currRing: "); rWrite(currRing);
 #endif /* MYTEST */
   if (TEST_OPT_DEBUG) messageSets(strat);
 #endif /* KDEBUG */
 
   if (TEST_OPT_SB_1)
   {
     #ifdef HAVE_RINGS
     if(!rField_is_Ring(currRing))
     #endif
     {
       int k=1;
       int j;
       while(k<=strat->sl)
       {
         j=0;
         loop
         {
           if (j>=k) break;
           clearS(strat->S[j],strat->sevS[j],&k,&j,strat);
           j++;
         }
         k++;
       }
     }
   }
   /* complete reduction of the standard basis--------- */
   if (TEST_OPT_REDSB)
   {
     completeReduce(strat);
 #ifdef HAVE_TAIL_RING
     if (strat->completeReduce_retry)
     {
       // completeReduce needed larger exponents, retry
       // to reduce with S (instead of T)
       // and in currRing (instead of strat->tailRing)
       cleanT(strat);strat->tailRing=currRing;
       int i;
       for(i=strat->sl;i>=0;i--) strat->S_2_R[i]=-1;
       completeReduce(strat);
     }
 #endif
   }
   else if (TEST_OPT_PROT) PrintLn();
   #ifdef HAVE_RINGS
   if(nCoeff_is_Ring_Z(currRing->cf))
     finalReduceByMon(strat);
   if(rField_is_Ring(currRing))
   {
     for(int i = 0;i<=strat->sl;i++)
     {
       if(!nGreaterZero(pGetCoeff(strat->S[i])))
       {
         strat->S[i] = pNeg(strat->S[i]);
       }
     }
   }
   #endif
   /* release temp data-------------------------------- */
   exitBuchMora(strat);
 //  if (TEST_OPT_WEIGHTM)
 //  {
 //    pRestoreDegProcs(currRing,pFDegOld, pLDegOld);
 //    if (ecartWeights)
 //    {
 //      omFreeSize((ADDRESS)ecartWeights,((currRing->N)+1)*sizeof(short));
 //      ecartWeights=NULL;
 //    }
 //  }
   if ((TEST_OPT_PROT) || (TEST_OPT_DEBUG)) messageStat(hilbcount,strat);
   SI_RESTORE_OPT1(save);
   if (Q!=NULL) updateResult(strat->Shdl,Q,strat);
 
 #ifdef KDEBUG
 #if MYTEST
   PrintS("bba_end: currRing: "); rWrite(currRing);
 #endif /* MYTEST */
 #endif /* KDEBUG */
   idTest(strat->Shdl);
 
   return (strat->Shdl);
 }

ideal bbaShift	(	ideal	F,
		ideal	Q,
		intvec *	w,
		intvec *	hilb,
		kStrategy	strat,
		int	uptodeg,
		int	lV
	)

Definition at line 3065 of file kstd2.cc.

 {
   int   red_result = 1;
   int   olddeg,reduc;
   int hilbeledeg=1,hilbcount=0,minimcnt=0;
   BOOLEAN withT = TRUE; // very important for shifts
 
   initBuchMoraCrit(strat); /*set Gebauer, honey, sugarCrit, NO CHANGES */
   initBuchMoraPos(strat); /*NO CHANGES YET: perhaps later*/
   initHilbCrit(F,Q,&hilb,strat); /*NO CHANGES*/
   initBbaShift(F,strat); /* DONE */
   /*set enterS, spSpolyShort, reduce, red, initEcart, initEcartPair*/
   /*Shdl=*/initBuchMoraShift(F, Q,strat); /* updateS with no toT, i.e. no init for T */
   updateSShift(strat,uptodeg,lV); /* initializes T */
 
   if (strat->minim>0) strat->M=idInit(IDELEMS(F),F->rank);
   reduc = olddeg = 0;
   strat->lV=lV;
 
 #ifndef NO_BUCKETS
   if (!TEST_OPT_NOT_BUCKETS)
     strat->use_buckets = 1;
 #endif
 
   // redtailBBa against T for inhomogenous input
   //  if (!TEST_OPT_OLDSTD)
   //    withT = ! strat->homog;
 
   // strat->posInT = posInT_pLength;
   kTest_TS(strat);
 
 #ifdef HAVE_TAIL_RING
   kStratInitChangeTailRing(strat);
 #endif
 
   /* compute------------------------------------------------------- */
   while (strat->Ll >= 0)
   {
 #ifdef KDEBUG
     if (TEST_OPT_DEBUG) messageSets(strat);
 #endif
     if (strat->Ll== 0) strat->interpt=TRUE;
     if (TEST_OPT_DEGBOUND
         && ((strat->honey && (strat->L[strat->Ll].ecart+currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg))
             || ((!strat->honey) && (currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg))))
     {
       /*
        *stops computation if
        * 24 IN test and the degree +ecart of L[strat->Ll] is bigger then
        *a predefined number Kstd1_deg
        */
       while ((strat->Ll >= 0)
         && (strat->L[strat->Ll].p1!=NULL) && (strat->L[strat->Ll].p2!=NULL)
         && ((strat->honey && (strat->L[strat->Ll].ecart+currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg))
             || ((!strat->honey) && (currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg)))
         )
         deleteInL(strat->L,&strat->Ll,strat->Ll,strat);
       if (strat->Ll<0) break;
       else strat->noClearS=TRUE;
     }
     /* picks the last element from the lazyset L */
     strat->P = strat->L[strat->Ll];
     strat->Ll--;
 
     if (pNext(strat->P.p) == strat->tail)
     {
       // deletes the short spoly
       pLmFree(strat->P.p);
       strat->P.p = NULL;
       poly m1 = NULL, m2 = NULL;
 
       // check that spoly creation is ok
       while (strat->tailRing != currRing &&
              !kCheckSpolyCreation(&(strat->P), strat, m1, m2))
       {
         assume(m1 == NULL && m2 == NULL);
         // if not, change to a ring where exponents are at least
         // large enough
         kStratChangeTailRing(strat);
       }
       // create the real one
       ksCreateSpoly(&(strat->P), NULL, strat->use_buckets,
                     strat->tailRing, m1, m2, strat->R);
     }
     else if (strat->P.p1 == NULL)
     {
       if (strat->minim > 0)
         strat->P.p2=p_Copy(strat->P.p, currRing, strat->tailRing);
       // for input polys, prepare reduction
       strat->P.PrepareRed(strat->use_buckets);
     }
 
     poly qq;
 
     /* here in the nonhomog case we shrink the new spoly */
 
     if ( ! strat->homog)
     {
       strat->P.GetP(strat->lmBin); // because shifts are counted with .p structure
       /* in the nonhomog case we have to shrink the polynomial */
       assume(strat->P.t_p!=NULL);
       qq = p_Shrink(strat->P.t_p, lV, strat->tailRing); // direct shrink
       if (qq != NULL)
       {
          /* we're here if Shrink is nonzero */
         //         strat->P.p =  NULL;
         //        strat->P.Delete(); /* deletes P.p and P.t_p */ //error
         strat->P.p   =  NULL; // is not set by Delete
         strat->P.t_p =  qq;
         strat->P.GetP(strat->lmBin);
         // update sev and length
         strat->initEcart(&(strat->P));
         strat->P.sev = pGetShortExpVector(strat->P.p);
 //         strat->P.FDeg = strat->P.pFDeg();
 //         strat->P.length = strat->P.pLDeg();
 //         strat->P.pLength =strat->P.GetpLength(); //pLength(strat->P.p);
       }
       else
       {
          /* Shrink is zero, like y(1)*y(2) - y(1)*y(3)*/
 #ifdef KDEBUG
          if (TEST_OPT_DEBUG){PrintS("nonzero s shrinks to 0");PrintLn();}
 #endif
          //         strat->P.Delete();  // cause error
          strat->P.p = NULL;
          strat->P.t_p = NULL;
            //         strat->P.p = NULL; // or delete strat->P.p ?
        }
     }
       /* end shrinking poly in the nonhomog case */
 
     if (strat->P.p == NULL && strat->P.t_p == NULL)
     {
       red_result = 0;
     }
     else
     {
       if (TEST_OPT_PROT)
         message((strat->honey ? strat->P.ecart : 0) + strat->P.pFDeg(),
                 &olddeg,&reduc,strat, red_result);
 
       /* reduction of the element chosen from L */
       red_result = strat->red(&strat->P,strat);
     }
 
     // reduction to non-zero new poly
     if (red_result == 1)
     {
       /* statistic */
       if (TEST_OPT_PROT) PrintS("s");
 
       // get the polynomial (canonicalize bucket, make sure P.p is set)
       strat->P.GetP(strat->lmBin);
 
       int pos=posInS(strat,strat->sl,strat->P.p,strat->P.ecart);
 
       // reduce the tail and normalize poly
       if (TEST_OPT_INTSTRATEGY)
       {
         strat->P.pCleardenom();
         if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
         {
           strat->P.p = redtailBba(&(strat->P),pos-1,strat, withT);
           strat->P.pCleardenom();
         }
       }
       else
       {
         strat->P.pNorm();
         if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
           strat->P.p = redtailBba(&(strat->P),pos-1,strat, withT);
       }
 
       // here we must shrink again! and optionally reduce again
       // or build shrink into redtailBba!
 
 #ifdef KDEBUG
       if (TEST_OPT_DEBUG){PrintS("new s:");strat->P.wrp();PrintLn();}
 #endif
 
       // min_std stuff
       if ((strat->P.p1==NULL) && (strat->minim>0))
       {
         if (strat->minim==1)
         {
           strat->M->m[minimcnt]=p_Copy(strat->P.p,currRing,strat->tailRing);
           p_Delete(&strat->P.p2, currRing, strat->tailRing);
         }
         else
         {
           strat->M->m[minimcnt]=strat->P.p2;
           strat->P.p2=NULL;
         }
         if (strat->tailRing!=currRing && pNext(strat->M->m[minimcnt])!=NULL)
           pNext(strat->M->m[minimcnt])
             = strat->p_shallow_copy_delete(pNext(strat->M->m[minimcnt]),
                                            strat->tailRing, currRing,
                                            currRing->PolyBin);
         minimcnt++;
       }
 
     /* here in the nonhomog case we shrink the reduced poly AGAIN */
 
     if ( ! strat->homog)
     {
       strat->P.GetP(strat->lmBin); // because shifts are counted with .p structure
       /* assume strat->P.t_p != NULL */
       /* in the nonhomog case we have to shrink the polynomial */
       assume(strat->P.t_p!=NULL); // poly qq defined above
       qq = p_Shrink(strat->P.t_p, lV, strat->tailRing); // direct shrink
       if (qq != NULL)
       {
          /* we're here if Shrink is nonzero */
         //         strat->P.p =  NULL;
         //        strat->P.Delete(); /* deletes P.p and P.t_p */ //error
         strat->P.p   =  NULL; // is not set by Delete
         strat->P.t_p =  qq;
         strat->P.GetP(strat->lmBin);
         // update sev and length
         strat->initEcart(&(strat->P));
         strat->P.sev = pGetShortExpVector(strat->P.p);
       }
       else
       {
          /* Shrink is zero, like y(1)*y(2) - y(1)*y(3)*/
 #ifdef PDEBUG
          if (TEST_OPT_DEBUG){PrintS("nonzero s shrinks to 0");PrintLn();}
 #endif
          //         strat->P.Delete();  // cause error
          strat->P.p = NULL;
          strat->P.t_p = NULL;
            //         strat->P.p = NULL; // or delete strat->P.p ?
          goto     red_shrink2zero;
        }
     }
       /* end shrinking poly AGAIN in the nonhomog case */
 
 
       // enter into S, L, and T
       //if ((!TEST_OPT_IDLIFT) || (pGetComp(strat->P.p) <= strat->syzComp))
       //        enterT(strat->P, strat); // this was here before Shift stuff
       //enterTShift(LObject p, kStrategy strat, int atT, int uptodeg, int lV); // syntax
       // the default value for atT = -1 as in bba
       /*   strat->P.GetP(); */
       // because shifts are counted with .p structure // done before, but ?
       enterTShift(strat->P,strat,-1,uptodeg, lV);
       enterpairsShift(strat->P.p,strat->sl,strat->P.ecart,pos,strat, strat->tl,uptodeg,lV);
       //      enterpairsShift(vw,strat->sl,strat->P.ecart,pos,strat, strat->tl,uptodeg,lV);
       // posInS only depends on the leading term
       strat->enterS(strat->P, pos, strat, strat->tl);
 
       if (hilb!=NULL) khCheck(Q,w,hilb,hilbeledeg,hilbcount,strat);
 //      Print("[%d]",hilbeledeg);
       if (strat->P.lcm!=NULL) pLmFree(strat->P.lcm);
     }
     else
     {
     red_shrink2zero:
       if (strat->P.p1 == NULL && strat->minim > 0)
       {
         p_Delete(&strat->P.p2, currRing, strat->tailRing);
       }
     }
 #ifdef KDEBUG
     memset(&(strat->P), 0, sizeof(strat->P));
 #endif
     kTest_TS(strat);
   }
 #ifdef KDEBUG
   if (TEST_OPT_DEBUG) messageSets(strat);
 #endif
   /* complete reduction of the standard basis--------- */
   /*  shift case: look for elt's in S such that they are divisible by elt in T */
   //  if (TEST_OPT_SB_1)
   if (TEST_OPT_REDSB)
   {
     int k=0;
     int j=-1;
     while(k<=strat->sl)
     {
 //       loop
 //       {
 //         if (j>=k) break;
 //         clearS(strat->S[j],strat->sevS[j],&k,&j,strat);
 //         j++;
 //       }
       LObject Ln (strat->S[k],currRing, strat->tailRing);
       Ln.SetShortExpVector();
       j = kFindDivisibleByInT(strat, &Ln, j+1);
       if (j<0) {  k++; j=-1;}
       else
       {
         if ( pLmCmp(strat->S[k],strat->T[j].p) == 0)
         {
           j = kFindDivisibleByInT(strat, &Ln, j+1);
           if (j<0) {  k++; j=-1;}
           else
           {
             deleteInS(k,strat);
           }
         }
         else
         {
           deleteInS(k,strat);
         }
       }
     }
   }
 
   if (TEST_OPT_REDSB)
   {    completeReduce(strat, TRUE); //shift: withT = TRUE
     if (strat->completeReduce_retry)
     {
       // completeReduce needed larger exponents, retry
       // to reduce with S (instead of T)
       // and in currRing (instead of strat->tailRing)
       cleanT(strat);strat->tailRing=currRing;
       int i;
       for(i=strat->sl;i>=0;i--) strat->S_2_R[i]=-1;
       completeReduce(strat, TRUE);
     }
   }
   else if (TEST_OPT_PROT) PrintLn();
 
   /* release temp data-------------------------------- */
   exitBuchMora(strat);
 //  if (TEST_OPT_WEIGHTM)
 //  {
 //    pRestoreDegProcs(currRing,pFDegOld, pLDegOld);
 //    if (ecartWeights)
 //    {
 //      omFreeSize((ADDRESS)ecartWeights,((currRing->N)+1)*sizeof(short));
 //      ecartWeights=NULL;
 //    }
 //  }
   if (TEST_OPT_PROT) messageStat(hilbcount,strat);
   if (Q!=NULL) updateResult(strat->Shdl,Q,strat);
   return (strat->Shdl);
 }

void cancelunit	(	LObject *	p,
		BOOLEAN	inNF = `FALSE`
	)

Definition at line 324 of file kutil.cc.

 {
   int  i;
   poly h;
   number lc;
 
   if(rHasGlobalOrdering (currRing)) return;
   if(TEST_OPT_CANCELUNIT) return;
 
   ring r = L->tailRing;
   poly p = L->GetLmTailRing();
 
 #ifdef HAVE_RINGS
     if (rField_is_Ring(r) /*&& (rHasLocalOrMixedOrdering(r))*/)
       lc = pGetCoeff(p);
 #endif
     #if ADIDEBUG
     printf("\n        cancelunit\n");
     pWrite(p);
     #endif
 #ifdef HAVE_RINGS
   // Leading coef have to be a unit
   // example 2x+4x2 should be simplified to 2x*(1+2x)
   // and 2 is not a unit in Z
   //if ( !(n_IsUnit(pGetCoeff(p), r->cf)) ) return;
 #endif
 
   if(p_GetComp(p, r) != 0 && !p_OneComp(p, r)) return;
 
 //    for(i=r->N;i>0;i--)
 //    {
 //      if ((p_GetExp(p,i,r)>0) && (rIsPolyVar(i, r)==TRUE)) return;
 //    }
   h = pNext(p);
 
   loop
   {
     if (h==NULL)
     {
       p_Delete(&pNext(p), r);
       if (!inNF)
       {
         number eins;
 #ifdef HAVE_RINGS
         if (rField_is_Ring(r) /*&& (rHasLocalOrMixedOrdering(r))*/)
           eins = nCopy(lc);
         else
 #endif
           eins=nInit(1);
         if (L->p != NULL)
         {
           pSetCoeff(L->p,eins);
           if (L->t_p != NULL)
             pSetCoeff0(L->t_p,eins);
         }
         else
           pSetCoeff(L->t_p,eins);
         /* p and t_p share the same coeff, if both are !=NULL */
         /* p==NULL==t_p cannot happen here */
       }
       L->ecart = 0;
       L->length = 1;
       //if (L->pLength > 0)
       L->pLength = 1;
       L->max = NULL;
 
       if (L->t_p != NULL && pNext(L->t_p) != NULL)
         p_Delete(&pNext(L->t_p),r);
       if (L->p != NULL && pNext(L->p) != NULL)
         pNext(L->p) = NULL;
 
       return;
     }
     i = 0;
     loop
     {
       i++;
       if (p_GetExp(p,i,r) > p_GetExp(h,i,r)) return ; // does not divide
       if (i == r->N) break; // does divide, try next monom
     }
     //wrp(p); PrintS(" divide ");wrp(h); PrintLn();
     #ifdef HAVE_RINGS
     // Note: As long as qring j forbidden if j contains integer (i.e. ground rings are
     //       domains), no zerodivisor test needed  CAUTION
     #if ADIDEBUG
     pWrite(h);
     #endif
     if (rField_is_Ring(r) && !n_DivBy(pGetCoeff(h),lc,r->cf))
     {
       #if ADIDEBUG
       printf("\nDoes not divide\n");
       #endif
       return;
     }
     #if ADIDEBUG
     printf("\nDivides. Go On\n");
     #endif
     #endif
     pIter(h);
   }
 }

void chainCritNormal	(	poly	p,
		int	ecart,
		kStrategy	strat
	)

Definition at line 2451 of file kutil.cc.

 {
   int i,j,l;
 
   /*
   *pairtest[i] is TRUE if spoly(S[i],p) == 0.
   *In this case all elements in B such
   *that their lcm is divisible by the leading term of S[i] can be canceled
   */
   if (strat->pairtest!=NULL)
   {
     {
       /*- i.e. there is an i with pairtest[i]==TRUE -*/
       for (j=0; j<=strat->sl; j++)
       {
         if (strat->pairtest[j])
         {
           for (i=strat->Bl; i>=0; i--)
           {
             if (pDivisibleBy(strat->S[j],strat->B[i].lcm))
             {
               deleteInL(strat->B,&strat->Bl,i,strat);
               strat->c3++;
             }
           }
         }
       }
     }
     omFreeSize(strat->pairtest,(strat->sl+2)*sizeof(BOOLEAN));
     strat->pairtest=NULL;
   }
   if (strat->Gebauer || strat->fromT)
   {
     if (strat->sugarCrit)
     {
     /*
     *suppose L[j] == (s,r) and p/lcm(s,r)
     *and lcm(s,r)#lcm(s,p) and lcm(s,r)#lcm(r,p)
     *and in case the sugar is o.k. then L[j] can be canceled
     */
       for (j=strat->Ll; j>=0; j--)
       {
         if (sugarDivisibleBy(ecart,strat->L[j].ecart)
         && ((pNext(strat->L[j].p) == strat->tail) || (rHasGlobalOrdering(currRing)))
         && pCompareChain(p,strat->L[j].p1,strat->L[j].p2,strat->L[j].lcm))
         {
           if (strat->L[j].p == strat->tail)
           {
               deleteInL(strat->L,&strat->Ll,j,strat);
               strat->c3++;
           }
         }
       }
       /*
       *this is GEBAUER-MOELLER:
       *in B all elements with the same lcm except the "best"
       *(i.e. the last one in B with this property) will be canceled
       */
       j = strat->Bl;
       loop /*cannot be changed into a for !!! */
       {
         if (j <= 0) break;
         i = j-1;
         loop
         {
           if (i <  0) break;
           if (pLmEqual(strat->B[j].lcm,strat->B[i].lcm))
           {
             strat->c3++;
             if (sugarDivisibleBy(strat->B[j].ecart,strat->B[i].ecart))
             {
               deleteInL(strat->B,&strat->Bl,i,strat);
               j--;
             }
             else
             {
               deleteInL(strat->B,&strat->Bl,j,strat);
               break;
             }
           }
           i--;
         }
         j--;
       }
     }
     else /*sugarCrit*/
     {
       /*
       *suppose L[j] == (s,r) and p/lcm(s,r)
       *and lcm(s,r)#lcm(s,p) and lcm(s,r)#lcm(r,p)
       *and in case the sugar is o.k. then L[j] can be canceled
       */
       for (j=strat->Ll; j>=0; j--)
       {
         if (pCompareChain(p,strat->L[j].p1,strat->L[j].p2,strat->L[j].lcm))
         {
           if ((pNext(strat->L[j].p) == strat->tail)||(rHasGlobalOrdering(currRing)))
           {
             deleteInL(strat->L,&strat->Ll,j,strat);
             strat->c3++;
           }
         }
       }
       /*
       *this is GEBAUER-MOELLER:
       *in B all elements with the same lcm except the "best"
       *(i.e. the last one in B with this property) will be canceled
       */
       j = strat->Bl;
       loop   /*cannot be changed into a for !!! */
       {
         if (j <= 0) break;
         for(i=j-1; i>=0; i--)
         {
           if (pLmEqual(strat->B[j].lcm,strat->B[i].lcm))
           {
             strat->c3++;
             deleteInL(strat->B,&strat->Bl,i,strat);
             j--;
           }
         }
         j--;
       }
     }
     /*
     *the elements of B enter L
     */
     kMergeBintoL(strat);
   }
   else
   {
     for (j=strat->Ll; j>=0; j--)
     {
       if (pCompareChain(p,strat->L[j].p1,strat->L[j].p2,strat->L[j].lcm))
       {
         if ((pNext(strat->L[j].p) == strat->tail)||(rHasGlobalOrdering(currRing)))
         {
           deleteInL(strat->L,&strat->Ll,j,strat);
           strat->c3++;
         }
       }
     }
     /*
     *this is our MODIFICATION of GEBAUER-MOELLER:
     *First the elements of B enter L,
     *then we fix a lcm and the "best" element in L
     *(i.e the last in L with this lcm and of type (s,p))
     *and cancel all the other elements of type (r,p) with this lcm
     *except the case the element (s,r) has also the same lcm
     *and is on the worst position with respect to (s,p) and (r,p)
     */
     /*
     *B enters to L/their order with respect to B is permutated for elements
     *B[i].p with the same leading term
     */
     kMergeBintoL(strat);
     j = strat->Ll;
     loop  /*cannot be changed into a for !!! */
     {
       if (j <= 0)
       {
         /*now L[0] cannot be canceled any more and the tail can be removed*/
         if (strat->L[0].p2 == strat->tail) strat->L[0].p2 = p;
         break;
       }
       if (strat->L[j].p2 == p)
       {
         i = j-1;
         loop
         {
           if (i < 0)  break;
           if ((strat->L[i].p2 == p) && pLmEqual(strat->L[j].lcm,strat->L[i].lcm))
           {
             /*L[i] could be canceled but we search for a better one to cancel*/
             strat->c3++;
             if (isInPairsetL(i-1,strat->L[j].p1,strat->L[i].p1,&l,strat)
             && (pNext(strat->L[l].p) == strat->tail)
             && (!pLmEqual(strat->L[i].p,strat->L[l].p))
             && pDivisibleBy(p,strat->L[l].lcm))
             {
               /*
               *"NOT equal(...)" because in case of "equal" the element L[l]
               *is "older" and has to be from theoretical point of view behind
               *L[i], but we do not want to reorder L
               */
               strat->L[i].p2 = strat->tail;
               /*
               *L[l] will be canceled, we cannot cancel L[i] later on,
               *so we mark it with "tail"
               */
               deleteInL(strat->L,&strat->Ll,l,strat);
               i--;
             }
             else
             {
               deleteInL(strat->L,&strat->Ll,i,strat);
             }
             j--;
           }
           i--;
         }
       }
       else if (strat->L[j].p2 == strat->tail)
       {
         /*now L[j] cannot be canceled any more and the tail can be removed*/
         strat->L[j].p2 = p;
       }
       j--;
     }
   }
 }

void chainCritOpt_1	(	poly	,
		int	,
		kStrategy	strat
	)

Definition at line 2666 of file kutil.cc.

 {
   if (strat->pairtest!=NULL)
   {
     omFreeSize(strat->pairtest,(strat->sl+2)*sizeof(BOOLEAN));
     strat->pairtest=NULL;
   }
   /*
   *the elements of B enter L
   */
   kMergeBintoL(strat);
 }

void chainCritSig	(	poly	p,
		int	ecart,
		kStrategy	strat
	)

Definition at line 2682 of file kutil.cc.

 {
   int i,j,l;
   kMergeBintoLSba(strat);
   j = strat->Ll;
   loop  /*cannot be changed into a for !!! */
   {
     if (j <= 0)
     {
       /*now L[0] cannot be canceled any more and the tail can be removed*/
       if (strat->L[0].p2 == strat->tail) strat->L[0].p2 = p;
       break;
     }
     if (strat->L[j].p2 == p)
     {
       i = j-1;
       loop
       {
         if (i < 0)  break;
         if ((strat->L[i].p2 == p) && pLmEqual(strat->L[j].lcm,strat->L[i].lcm))
         {
           /*L[i] could be canceled but we search for a better one to cancel*/
           strat->c3++;
           if (isInPairsetL(i-1,strat->L[j].p1,strat->L[i].p1,&l,strat)
               && (pNext(strat->L[l].p) == strat->tail)
               && (!pLmEqual(strat->L[i].p,strat->L[l].p))
               && pDivisibleBy(p,strat->L[l].lcm))
           {
             /*
              *"NOT equal(...)" because in case of "equal" the element L[l]
              *is "older" and has to be from theoretical point of view behind
              *L[i], but we do not want to reorder L
              */
             strat->L[i].p2 = strat->tail;
             /*
              *L[l] will be canceled, we cannot cancel L[i] later on,
              *so we mark it with "tail"
              */
             deleteInL(strat->L,&strat->Ll,l,strat);
             i--;
           }
           else
           {
             deleteInL(strat->L,&strat->Ll,i,strat);
           }
           j--;
         }
         i--;
       }
     }
     else if (strat->L[j].p2 == strat->tail)
     {
       /*now L[j] cannot be canceled any more and the tail can be removed*/
       strat->L[j].p2 = p;
     }
     j--;
   }
 }

void cleanT ( kStrategy strat )

Definition at line 505 of file kutil.cc.

 {
   int i,j;
   poly  p;
   assume(currRing == strat->tailRing || strat->tailRing != NULL);
 
   pShallowCopyDeleteProc p_shallow_copy_delete =
     (strat->tailRing != currRing ?
      pGetShallowCopyDeleteProc(strat->tailRing, currRing) :
      NULL);
 
   for (j=0; j<=strat->tl; j++)
   {
     p = strat->T[j].p;
     strat->T[j].p=NULL;
     if (strat->T[j].max != NULL)
     {
       p_LmFree(strat->T[j].max, strat->tailRing);
     }
     i = -1;
     loop
     {
       i++;
       if (i>strat->sl)
       {
         if (strat->T[j].t_p != NULL)
         {
           p_Delete(&(strat->T[j].t_p), strat->tailRing);
           p_LmFree(p, currRing);
         }
         else
           pDelete(&p);
         break;
       }
       if (p == strat->S[i])
       {
         if (strat->T[j].t_p != NULL)
         {
           assume(p_shallow_copy_delete != NULL);
           pNext(p) = p_shallow_copy_delete(pNext(p),strat->tailRing,currRing,
                                            currRing->PolyBin);
           p_LmFree(strat->T[j].t_p, strat->tailRing);
         }
         break;
       }
     }
   }
   strat->tl=-1;
 }

KINLINE void clearS	(	poly	p,
		unsigned long	p_sev,
		int *	at,
		int *	k,
		kStrategy	strat
	)

Definition at line 1145 of file kInline.h.

 {
   assume(p_sev == pGetShortExpVector(p));
   if (strat->noClearS) return;
   #if HAVE_RINGS
     if(rField_is_Ring(currRing))
     {
         if (!pLmShortDivisibleBy(p,p_sev, strat->S[*at], ~ strat->sevS[*at]))
             return;
         if(!n_DivBy(pGetCoeff(strat->S[*at]), pGetCoeff(p), currRing))
             return;
     }
     else
     {
         if (!pLmShortDivisibleBy(p,p_sev, strat->S[*at], ~ strat->sevS[*at])) return;
     }
   #else
     if (!pLmShortDivisibleBy(p,p_sev, strat->S[*at], ~ strat->sevS[*at])) return;
   #endif
   deleteInS((*at),strat);
   (*at)--;
   (*k)--;
 }

void completeReduce	(	kStrategy	strat,
		BOOLEAN	withT = `FALSE`
	)

Definition at line 8801 of file kutil.cc.

 {
   int i;
   int low = (((rHasGlobalOrdering(currRing)) && (strat->ak==0)) ? 1 : 0);
   LObject L;
 
 #ifdef KDEBUG
   // need to set this: during tailreductions of T[i], T[i].max is out of
   // sync
   sloppy_max = TRUE;
 #endif
 
   strat->noTailReduction = FALSE;
   //if(rHasMixedOrdering(currRing)) strat->noTailReduction = TRUE;
   if (TEST_OPT_PROT)
   {
     PrintLn();
 //    if (timerv) writeTime("standard base computed:");
   }
   if (TEST_OPT_PROT)
   {
     Print("(S:%d)",strat->sl);mflush();
   }
   for (i=strat->sl; i>=low; i--)
   {
     int end_pos=strat->sl;
     if ((strat->fromQ!=NULL) && (strat->fromQ[i])) continue; // do not reduce Q_i
     if (strat->ak==0) end_pos=i-1;
     TObject* T_j = strat->s_2_t(i);
     if ((T_j != NULL)&&(T_j->p==strat->S[i]))
     {
       L = *T_j;
       #ifdef KDEBUG
       if (TEST_OPT_DEBUG)
       {
         Print("test S[%d]:",i);
         p_wrp(L.p,currRing,strat->tailRing);
         PrintLn();
       }
       #endif
       if (rHasGlobalOrdering(currRing))
         strat->S[i] = redtailBba(&L, end_pos, strat, withT);
       else
         strat->S[i] = redtail(&L, strat->sl, strat);
       #ifdef KDEBUG
       if (TEST_OPT_DEBUG)
       {
         Print("to (tailR) S[%d]:",i);
         p_wrp(strat->S[i],currRing,strat->tailRing);
         PrintLn();
       }
       #endif
 
       if (strat->redTailChange && strat->tailRing != currRing)
       {
         if (T_j->max != NULL) p_LmFree(T_j->max, strat->tailRing);
         if (pNext(T_j->p) != NULL)
           T_j->max = p_GetMaxExpP(pNext(T_j->p), strat->tailRing);
         else
           T_j->max = NULL;
       }
       if (TEST_OPT_INTSTRATEGY)
         T_j->pCleardenom();
     }
     else
     {
       assume(currRing == strat->tailRing);
       #ifdef KDEBUG
       if (TEST_OPT_DEBUG)
       {
         Print("test S[%d]:",i);
         p_wrp(strat->S[i],currRing,strat->tailRing);
         PrintLn();
       }
       #endif
       if (rHasGlobalOrdering(currRing))
         strat->S[i] = redtailBba(strat->S[i], end_pos, strat, withT);
       else
         strat->S[i] = redtail(strat->S[i], strat->sl, strat);
       if (TEST_OPT_INTSTRATEGY)
       {
         if (TEST_OPT_CONTENTSB)
         {
           number n;
           p_Cleardenom_n(strat->S[i], currRing, n);// also does a pContent
           if (!nIsOne(n))
           {
             denominator_list denom=(denominator_list)omAlloc(sizeof(denominator_list_s));
             denom->n=nInvers(n);
             denom->next=DENOMINATOR_LIST;
             DENOMINATOR_LIST=denom;
           }
           nDelete(&n);
         }
         else
         {
           //pContent(strat->S[i]);
           strat->S[i]=p_Cleardenom(strat->S[i], currRing);// also does a pContent
         }
       }
       #ifdef KDEBUG
       if (TEST_OPT_DEBUG)
       {
         Print("to (-tailR) S[%d]:",i);
         p_wrp(strat->S[i],currRing,strat->tailRing);
         PrintLn();
       }
       #endif
     }
     if (TEST_OPT_PROT)
       PrintS("-");
   }
   if (TEST_OPT_PROT) PrintLn();
 #ifdef KDEBUG
   sloppy_max = FALSE;
 #endif
 }

ideal createG0 ( )

Definition at line 3687 of file kutil.cc.

 {
   // Initialize
   long exp[50];            // The exponent of \hat{X} (basepoint)
   long cexp[50];           // The current exponent for iterating over all
   long ind[50];            // The power of 2 in the i-th component of exp
   long cind[50];           // analog for cexp
   long mult[50];           // How to multiply the elements of G
   long cabsind = 0;        // The abs. index of cexp, i.e. the sum of cind
   long habsind = 0;        // The abs. index of the coefficient of h
   long step[50];           // The last increases
   for (int i = 1; i <= currRing->N; i++)
   {
     exp[i] = 0;
     cexp[i] = exp[i];
     ind[i] = 0;
     step[i] = 500000;
     cind[i] = ind[i];
   }
   long bound = currRing->ch;
   step[1] = 500000;
 #ifdef OLI_DEBUG
   PrintS("-------------\npoly  :");
 //  wrp(p);
   Print("\nexp   : (%d, %d)\n", exp[1] + mult[1], exp[2] + mult[1]);
   Print("cexp  : (%d, %d)\n", cexp[1], cexp[2]);
   Print("cind  : (%d, %d)\n", cind[1], cind[2]);
   Print("bound : %d\n", bound);
   Print("cind  : %d\n", cabsind);
 #endif
   if (cabsind == 0)
   {
     if (!(nextZeroSimplexExponent(exp, ind, cexp, cind, &cabsind, step, bound, currRing->N)))
     {
       return idInit(1, 1);
     }
   }
   ideal G0 = idInit(1, 1);
   // Now the whole simplex
   do
   {
     // Build s-polynomial
     // 2**ind-def * mult * g - exp-def * h
     poly t_p;
     poly zeroPoly = kCreateZeroPoly(cexp, cabsind, &t_p, currRing, currRing);
 #ifdef OLI_DEBUG
     Print("%d, (%d, %d), ind = (%d, %d)\n", cabsind, cexp[1], cexp[2], cind[1], cind[2]);
     Print("zPoly : ");
     wrp(zeroPoly);
     Print("\n");
 #endif
     // Add to ideal
     pEnlargeSet(&(G0->m), IDELEMS(G0), 1);
     IDELEMS(G0) += 1;
     G0->m[IDELEMS(G0) - 1] = zeroPoly;
   }
   while ( nextZeroSimplexExponent(exp, ind, cexp, cind, &cabsind, step, bound, currRing->N) );
   idSkipZeroes(G0);
   return G0;
 }

void deleteHC	(	poly *	p,
		int *	e,
		int *	l,
		kStrategy	strat
	)

Definition at line 310 of file kutil.cc.

 {
   LObject L(*p, currRing, strat->tailRing);
 
   deleteHC(&L, strat);
   *p = L.p;
   *e = L.ecart;
   *l = L.length;
   if (L.t_p != NULL) p_LmFree(L.t_p, strat->tailRing);
 }

void deleteHC	(	LObject *	L,
		kStrategy	strat,
		BOOLEAN	fromNext = `FALSE`
	)

Definition at line 235 of file kutil.cc.

 {
   if (strat->kHEdgeFound)
   {
     kTest_L(L);
     poly p1;
     poly p = L->GetLmTailRing();
     int l = 1;
     kBucket_pt bucket = NULL;
     if (L->bucket != NULL)
     {
       kBucketClear(L->bucket, &pNext(p), &L->pLength);
       L->pLength++;
       bucket = L->bucket;
       L->bucket = NULL;
     }
 
     if (!fromNext && p_Cmp(p,strat->kNoetherTail(), L->tailRing) == -1)
     {
       L->Delete();
       L->Clear();
       L->ecart = -1;
       if (bucket != NULL) kBucketDestroy(&bucket);
       return;
     }
     p1 = p;
     while (pNext(p1)!=NULL)
     {
     if (p_LmCmp(pNext(p1), strat->kNoetherTail(), L->tailRing) == -1)
       {
         p_Delete(&pNext(p1), L->tailRing);
         if (p1 == p)
         {
           if (L->t_p != NULL)
           {
             assume(L->p != NULL && p == L->t_p);
             pNext(L->p) = NULL;
           }
           L->max  = NULL;
         }
         else if (fromNext)
           L->max  = p_GetMaxExpP(pNext(L->p), L->tailRing ); // p1;
         //if (L->pLength != 0)
         L->pLength = l;
         // Hmmm when called from updateT, then only
         // reset ecart when cut
         if (fromNext)
           L->ecart = L->pLDeg() - L->GetpFDeg();
         break;
       }
       l++;
       pIter(p1);
     }
     if (! fromNext)
     {
       L->SetpFDeg();
       L->ecart = L->pLDeg(strat->LDegLast) - L->GetpFDeg();
     }
     if (bucket != NULL)
     {
       if (L->pLength > 1)
       {
         kBucketInit(bucket, pNext(p), L->pLength - 1);
         pNext(p) = NULL;
         if (L->t_p != NULL) pNext(L->t_p) = NULL;
         L->pLength = 0;
         L->bucket = bucket;
       }
       else
         kBucketDestroy(&bucket);
     }
     kTest_L(L);
   }
 }

void deleteInL	(	LSet	set,
		int *	length,
		int	j,
		kStrategy	strat
	)

Definition at line 1053 of file kutil.cc.

 {
   if (set[j].lcm!=NULL)
   {
 #ifdef HAVE_RINGS
     if (pGetCoeff(set[j].lcm) != NULL)
       pLmDelete(set[j].lcm);
     else
 #endif
       pLmFree(set[j].lcm);
   }
   if (set[j].sig!=NULL)
   {
 #ifdef HAVE_RINGS
     if (pGetCoeff(set[j].sig) != NULL)
       pLmDelete(set[j].sig);
     else
 #endif
       pLmFree(set[j].sig);
   }
   if (set[j].p!=NULL)
   {
     if (pNext(set[j].p) == strat->tail)
     {
 #ifdef HAVE_RINGS
       if (pGetCoeff(set[j].p) != NULL)
         pLmDelete(set[j].p);
       else
 #endif
         pLmFree(set[j].p);
       /*- tail belongs to several int spolys -*/
     }
     else
     {
       // search p in T, if it is there, do not delete it
       if (rHasGlobalOrdering(currRing) || (kFindInT(set[j].p, strat) < 0))
       {
         // assure that for global orderings kFindInT fails
         //assume((rHasLocalOrMixedOrdering(currRing)) && (kFindInT(set[j].p, strat) >= 0));
         set[j].Delete();
       }
     }
   }
   if (*length > 0 && j < *length)
   {
 #ifdef ENTER_USE_MEMMOVE
     memmove(&(set[j]), &(set[j+1]), (*length - j)*sizeof(LObject));
 #else
     int i;
     for (i=j; i < (*length); i++)
       set[i] = set[i+1];
 #endif
   }
 #ifdef KDEBUG
   memset(&(set[*length]),0,sizeof(LObject));
 #endif
   (*length)--;
 }

void deleteInS	(	int	i,
		kStrategy	strat
	)

Definition at line 946 of file kutil.cc.

 {
 #ifdef ENTER_USE_MEMMOVE
   memmove(&(strat->S[i]), &(strat->S[i+1]), (strat->sl - i)*sizeof(poly));
   memmove(&(strat->ecartS[i]),&(strat->ecartS[i+1]),(strat->sl - i)*sizeof(int));
   memmove(&(strat->sevS[i]),&(strat->sevS[i+1]),(strat->sl - i)*sizeof(unsigned long));
   memmove(&(strat->S_2_R[i]),&(strat->S_2_R[i+1]),(strat->sl - i)*sizeof(int));
 #else
   int j;
   for (j=i; j<strat->sl; j++)
   {
     strat->S[j] = strat->S[j+1];
     strat->ecartS[j] = strat->ecartS[j+1];
     strat->sevS[j] = strat->sevS[j+1];
     strat->S_2_R[j] = strat->S_2_R[j+1];
   }
 #endif
   if (strat->lenS!=NULL)
   {
 #ifdef ENTER_USE_MEMMOVE
     memmove(&(strat->lenS[i]),&(strat->lenS[i+1]),(strat->sl - i)*sizeof(int));
 #else
     for (j=i; j<strat->sl; j++) strat->lenS[j] = strat->lenS[j+1];
 #endif
   }
   if (strat->lenSw!=NULL)
   {
 #ifdef ENTER_USE_MEMMOVE
     memmove(&(strat->lenSw[i]),&(strat->lenSw[i+1]),(strat->sl - i)*sizeof(wlen_type));
 #else
     for (j=i; j<strat->sl; j++) strat->lenSw[j] = strat->lenSw[j+1];
 #endif
   }
   if (strat->fromQ!=NULL)
   {
 #ifdef ENTER_USE_MEMMOVE
     memmove(&(strat->fromQ[i]),&(strat->fromQ[i+1]),(strat->sl - i)*sizeof(int));
 #else
     for (j=i; j<strat->sl; j++)
     {
       strat->fromQ[j] = strat->fromQ[j+1];
     }
 #endif
   }
   strat->S[strat->sl] = NULL;
   strat->sl--;
 }

void deleteInSSba	(	int	i,
		kStrategy	strat
	)

Definition at line 998 of file kutil.cc.

 {
 #ifdef ENTER_USE_MEMMOVE
   memmove(&(strat->S[i]), &(strat->S[i+1]), (strat->sl - i)*sizeof(poly));
   memmove(&(strat->sig[i]), &(strat->sig[i+1]), (strat->sl - i)*sizeof(poly));
   memmove(&(strat->ecartS[i]),&(strat->ecartS[i+1]),(strat->sl - i)*sizeof(int));
   memmove(&(strat->sevS[i]),&(strat->sevS[i+1]),(strat->sl - i)*sizeof(unsigned long));
   memmove(&(strat->sevSig[i]),&(strat->sevSig[i+1]),(strat->sl - i)*sizeof(unsigned long));
   memmove(&(strat->S_2_R[i]),&(strat->S_2_R[i+1]),(strat->sl - i)*sizeof(int));
 #else
   int j;
   for (j=i; j<strat->sl; j++)
   {
     strat->S[j] = strat->S[j+1];
     strat->sig[j] = strat->sig[j+1];
     strat->ecartS[j] = strat->ecartS[j+1];
     strat->sevS[j] = strat->sevS[j+1];
     strat->sevSig[j] = strat->sevSig[j+1];
     strat->S_2_R[j] = strat->S_2_R[j+1];
   }
 #endif
   if (strat->lenS!=NULL)
   {
 #ifdef ENTER_USE_MEMMOVE
     memmove(&(strat->lenS[i]),&(strat->lenS[i+1]),(strat->sl - i)*sizeof(int));
 #else
     for (j=i; j<strat->sl; j++) strat->lenS[j] = strat->lenS[j+1];
 #endif
   }
   if (strat->lenSw!=NULL)
   {
 #ifdef ENTER_USE_MEMMOVE
     memmove(&(strat->lenSw[i]),&(strat->lenSw[i+1]),(strat->sl - i)*sizeof(wlen_type));
 #else
     for (j=i; j<strat->sl; j++) strat->lenSw[j] = strat->lenSw[j+1];
 #endif
   }
   if (strat->fromQ!=NULL)
   {
 #ifdef ENTER_USE_MEMMOVE
     memmove(&(strat->fromQ[i]),&(strat->fromQ[i+1]),(strat->sl - i)*sizeof(int));
 #else
     for (j=i; j<strat->sl; j++)
     {
       strat->fromQ[j] = strat->fromQ[j+1];
     }
 #endif
   }
   strat->S[strat->sl] = NULL;
   strat->sl--;
 }

void enterExtendedSpoly	(	poly	h,
		kStrategy	strat
	)

Definition at line 3784 of file kutil.cc.

 {
   if (nIsOne(pGetCoeff(h))) return;
   number gcd;
   bool go = false;
   if (n_DivBy((number) 0, pGetCoeff(h), currRing->cf))
   {
     gcd = n_Ann(pGetCoeff(h),currRing->cf);
     go = true;
   }
   else
     gcd = n_Gcd((number) 0, pGetCoeff(h), strat->tailRing->cf);
   if (go || !nIsOne(gcd))
   {
     poly p = h->next;
     if (!go)
     {
       number tmp = gcd;
       gcd = n_Ann(gcd,currRing->cf);
       nDelete(&tmp);
     }
     p_Test(p,strat->tailRing);
     p = pp_Mult_nn(p, gcd, strat->tailRing);
     nDelete(&gcd);
 
     if (p != NULL)
     {
       if (TEST_OPT_PROT)
       {
         PrintS("Z");
       }
 #ifdef KDEBUG
       if (TEST_OPT_DEBUG)
       {
         PrintS("--- create zero spoly: ");
         p_wrp(h,currRing,strat->tailRing);
         PrintS(" ---> ");
       }
 #endif
       poly tmp = pInit();
       pSetCoeff0(tmp, pGetCoeff(p));
       for (int i = 1; i <= rVar(currRing); i++)
       {
         pSetExp(tmp, i, p_GetExp(p, i, strat->tailRing));
       }
       if (rRing_has_Comp(currRing) && rRing_has_Comp(strat->tailRing))
       {
         p_SetComp(tmp, p_GetComp(p, strat->tailRing), currRing);
       }
       p_Setm(tmp, currRing);
       p = p_LmFreeAndNext(p, strat->tailRing);
       pNext(tmp) = p;
       LObject h;
       h.Init();
       h.p = tmp;
       h.tailRing = strat->tailRing;
       int posx;
       if (h.p!=NULL)
       {
         if (TEST_OPT_INTSTRATEGY)
         {
           //pContent(h.p);
           h.pCleardenom(); // also does a pContent
         }
         else
         {
           h.pNorm();
         }
         strat->initEcart(&h);
         if (strat->Ll==-1)
           posx =0;
         else
           posx = strat->posInL(strat->L,strat->Ll,&h,strat);
         h.sev = pGetShortExpVector(h.p);
         if (strat->tailRing != currRing)
         {
           h.t_p = k_LmInit_currRing_2_tailRing(h.p, strat->tailRing);
         }
 #ifdef KDEBUG
         if (TEST_OPT_DEBUG)
         {
           p_wrp(tmp,currRing,strat->tailRing);
           PrintLn();
         }
 #endif
         enterL(&strat->L,&strat->Ll,&strat->Lmax,h,posx);
       }
     }
   }
   nDelete(&gcd);
 }

void enterL	(	LSet *	set,
		int *	length,
		int *	LSetmax,
		LObject	p,
		int	at
	)

Definition at line 1115 of file kutil.cc.

 {
   // this should be corrected
   assume(p.FDeg == p.pFDeg());
 
   if ((*length)>=0)
   {
     if ((*length) == (*LSetmax)-1) enlargeL(set,LSetmax,setmaxLinc);
     if (at <= (*length))
 #ifdef ENTER_USE_MEMMOVE
       memmove(&((*set)[at+1]), &((*set)[at]), ((*length)-at+1)*sizeof(LObject));
 #else
     for (i=(*length)+1; i>=at+1; i--) (*set)[i] = (*set)[i-1];
 #endif
   }
   else at = 0;
   (*set)[at] = p;
   (*length)++;
 }

void enterOnePairLift	(	int	i,
		poly	p,
		int	ecart,
		int	isFromQ,
		kStrategy	strat,
		int	atR
	)

Definition at line 1841 of file kutil.cc.

 {
   assume(ALLOW_PROD_CRIT(strat));
   assume(!rIsPluralRing(currRing));
   assume(strat->syzComp==1);
   assume(i<=strat->sl);
 
   int      l,j,compare;
   LObject  Lp;
   Lp.i_r = -1;
 
 #ifdef KDEBUG
   Lp.ecart=0; Lp.length=0;
 #endif
   /*- computes the lcm(s[i],p) -*/
   Lp.lcm = pInit();
 
   pLcm(p,strat->S[i],Lp.lcm);
   pSetm(Lp.lcm);
 
   if (strat->sugarCrit)
   {
     if((!((strat->ecartS[i]>0)&&(ecart>0)))
     && p_HasNotCF_Lift(p,strat->S[i],currRing))
     {
     /*
     *the product criterion has applied for (s,p),
     *i.e. lcm(s,p)=product of the leading terms of s and p.
     *Suppose (s,r) is in L and the leading term
     *of p divides lcm(s,r)
     *(==> the leading term of p divides the leading term of r)
     *but the leading term of s does not divide the leading term of r
     *(notice that tis condition is automatically satisfied if r is still
     *in S), then (s,r) can be cancelled.
     *This should be done here because the
     *case lcm(s,r)=lcm(s,p) is not covered by chainCrit.
     *
     *Moreover, skipping (s,r) holds also for the noncommutative case.
     */
       strat->cp++;
       pLmFree(Lp.lcm);
       Lp.lcm=NULL;
       return;
     }
     else
       Lp.ecart = si_max(ecart,strat->ecartS[i]);
     if (strat->fromT && (strat->ecartS[i]>ecart))
     {
       pLmFree(Lp.lcm);
       Lp.lcm=NULL;
       return;
       /*the pair is (s[i],t[.]), discard it if the ecart is too big*/
     }
     /*
     *the set B collects the pairs of type (S[j],p)
     *suppose (r,p) is in B and (s,p) is the new pair and lcm(s,p)#lcm(r,p)
     *if the leading term of s devides lcm(r,p) then (r,p) will be canceled
     *if the leading term of r devides lcm(s,p) then (s,p) will not enter B
     */
     {
       j = strat->Bl;
       loop
       {
         if (j < 0)  break;
         compare=pDivComp(strat->B[j].lcm,Lp.lcm);
         if ((compare==1)
         &&(sugarDivisibleBy(strat->B[j].ecart,Lp.ecart)))
         {
           strat->c3++;
           if ((strat->fromQ==NULL) || (isFromQ==0) || (strat->fromQ[i]==0))
           {
             pLmFree(Lp.lcm);
             return;
           }
           break;
         }
         else
         if ((compare ==-1)
         && sugarDivisibleBy(Lp.ecart,strat->B[j].ecart))
         {
           deleteInL(strat->B,&strat->Bl,j,strat);
           strat->c3++;
         }
         j--;
       }
     }
   }
   else /*sugarcrit*/
   {
     if(/*(strat->ak==0) && productCrit(p,strat->S[i])*/
     p_HasNotCF_Lift(p,strat->S[i],currRing))
     {
     /*
     *the product criterion has applied for (s,p),
     *i.e. lcm(s,p)=product of the leading terms of s and p.
     *Suppose (s,r) is in L and the leading term
     *of p devides lcm(s,r)
     *(==> the leading term of p devides the leading term of r)
     *but the leading term of s does not devide the leading term of r
     *(notice that tis condition is automatically satisfied if r is still
     *in S), then (s,r) can be canceled.
     *This should be done here because the
     *case lcm(s,r)=lcm(s,p) is not covered by chainCrit.
     */
         strat->cp++;
         pLmFree(Lp.lcm);
         Lp.lcm=NULL;
         return;
     }
     if (strat->fromT && (strat->ecartS[i]>ecart))
     {
       pLmFree(Lp.lcm);
       Lp.lcm=NULL;
       return;
       /*the pair is (s[i],t[.]), discard it if the ecart is too big*/
     }
     /*
     *the set B collects the pairs of type (S[j],p)
     *suppose (r,p) is in B and (s,p) is the new pair and lcm(s,p)#lcm(r,p)
     *if the leading term of s devides lcm(r,p) then (r,p) will be canceled
     *if the leading term of r devides lcm(s,p) then (s,p) will not enter B
     */
     for(j = strat->Bl;j>=0;j--)
     {
       compare=pDivComp(strat->B[j].lcm,Lp.lcm);
       if (compare==1)
       {
         strat->c3++;
         if ((strat->fromQ==NULL) || (isFromQ==0) || (strat->fromQ[i]==0))
         {
           pLmFree(Lp.lcm);
           return;
         }
         break;
       }
       else
       if (compare ==-1)
       {
         deleteInL(strat->B,&strat->Bl,j,strat);
         strat->c3++;
       }
     }
   }
   /*
   *the pair (S[i],p) enters B if the spoly != 0
   */
   /*-  compute the short s-polynomial -*/
   if (strat->fromT && !TEST_OPT_INTSTRATEGY)
     pNorm(p);
 
   if ((strat->S[i]==NULL) || (p==NULL))
     return;
 
   if ((strat->fromQ!=NULL) && (isFromQ!=0) && (strat->fromQ[i]!=0))
     Lp.p=NULL;
   else
   {
       assume(!rIsPluralRing(currRing));
       Lp.p = ksCreateShortSpoly(strat->S[i], p, strat->tailRing);
   }
   if (Lp.p == NULL)
   {
     /*- the case that the s-poly is 0 -*/
     if (strat->pairtest==NULL) initPairtest(strat);
     strat->pairtest[i] = TRUE;/*- hint for spoly(S^[i],p)=0 -*/
     strat->pairtest[strat->sl+1] = TRUE;
     /*hint for spoly(S[i],p) == 0 for some i,0 <= i <= sl*/
     /*
     *suppose we have (s,r),(r,p),(s,p) and spoly(s,p) == 0 and (r,p) is
     *still in B (i.e. lcm(r,p) == lcm(s,p) or the leading term of s does not
     *devide lcm(r,p)). In the last case (s,r) can be canceled if the leading
     *term of p devides the lcm(s,r)
     *(this canceling should be done here because
     *the case lcm(s,p) == lcm(s,r) is not covered in chainCrit)
     *the first case is handeled in chainCrit
     */
     if (Lp.lcm!=NULL) pLmFree(Lp.lcm);
   }
   else
   {
     /*- the pair (S[i],p) enters B -*/
     Lp.p1 = strat->S[i];
     Lp.p2 = p;
 
     pNext(Lp.p) = strat->tail; // !!!
 
     if (atR >= 0)
     {
       Lp.i_r1 = strat->S_2_R[i];
       Lp.i_r2 = atR;
     }
     else
     {
       Lp.i_r1 = -1;
       Lp.i_r2 = -1;
     }
     strat->initEcartPair(&Lp,strat->S[i],p,strat->ecartS[i],ecart);
 
     if (TEST_OPT_INTSTRATEGY)
     {
         nDelete(&(Lp.p->coef));
     }
 
     l = strat->posInL(strat->B,strat->Bl,&Lp,strat);
     enterL(&strat->B,&strat->Bl,&strat->Bmax,Lp,l);
   }
 }

void enterOnePairManyShifts	(	int	i,
		poly	p,
		int	ecart,
		int	isFromQ,
		kStrategy	strat,
		int	atR,
		int	uptodeg,
		int	lV
	)

Definition at line 10264 of file kutil.cc.

 {
   /* p comes from strat->P.p, that is LObject with LM in currRing and Tail in tailRing */
 
   assume(p_LmCheckIsFromRing(p,currRing));
   assume(p_CheckIsFromRing(pNext(p),strat->tailRing));
 
   /* cycles through all shifts of s[i] until uptodeg - lastVblock(s[i]) */
   /* that is create the pairs (f, s \dot g)  */
 
   poly qq = strat->S[i]; //  lm in currRing, tail in tailRing
 
   //  poly q = pCopy(pHead(strat->S[i])); // lm in currRing
   //  pNext(q) = prCopyR(pNext(strat->S[i]),strat->tailRing,currRing); // zero shift
 
  /* determine how many elements we have to insert for a given s[i] */
   /* x(0)y(1)z(2) : lastVblock-1=2, to add until lastVblock=uptodeg-1 */
   /* hence, a total number of elt's to add is: */
   /*  int toInsert = 1 + (uptodeg-1) - (pLastVblock(p.p, lV) -1);  */
   int toInsert =  itoInsert(qq, uptodeg,  lV, strat->tailRing);
 
 #ifdef KDEBUG
     if (TEST_OPT_DEBUG)
     {
       //      Print("entered ManyShifts: with toInsert=%d",toInsert); PrintLn();
     }
 #endif
 
   assume(i<=strat->sl); // from OnePair
 
   /* these vars hold for all shifts of s[i] */
   int ecartq = 0; //Hans says it's ok; we're in the homog case, no ecart
 
   int qfromQ;
   if (strat->fromQ != NULL)
   {
     qfromQ = strat->fromQ[i];
   }
   else
   {
     qfromQ = -1;
   }
 
   int j;
 
   poly q/*, s*/;
 
   // for the 0th shift: insert the orig. pair
   enterOnePairShift(qq, p, ecart, isFromQ, strat, -1, ecartq, qfromQ, 0, i, uptodeg, lV);
 
   for (j=1; j<= toInsert; j++)
   {
     //    q = pLPshift(strat->S[i],j,uptodeg,lV);
     q = p_LPshiftT(qq, j, uptodeg, lV, strat, currRing);
     //    q = p_mLPshift(qq,j,uptodeg,lV,currRing); // lm in currRing, shift this monomial
     //    s = p_LPshift(pNext(qq), j, uptodeg, lV, strat->tailRing); // from tailRing
     //    pNext(q) = s; // in tailRing
     /* here we need to call enterOnePair with two polys ... */
 
 #ifdef KDEBUG
     if (TEST_OPT_DEBUG)
     {
       //      PrintS("ManyShifts: calling enterOnePairShift(q,p)");      PrintLn();
     }
 #endif
     enterOnePairShift(q, p, ecart, isFromQ, strat, -1, ecartq, qfromQ, j, i, uptodeg, lV);
   }
 }

void enterOnePairNormal	(	int	i,
		poly	p,
		int	ecart,
		int	isFromQ,
		kStrategy	strat,
		int	atR
	)

Definition at line 1536 of file kutil.cc.

 {
   assume(i<=strat->sl);
 
   int      l,j,compare;
   LObject  Lp;
   Lp.i_r = -1;
 
 #ifdef KDEBUG
   Lp.ecart=0; Lp.length=0;
 #endif
   /*- computes the lcm(s[i],p) -*/
   Lp.lcm = pInit();
 
 #ifndef HAVE_RATGRING
   pLcm(p,strat->S[i],Lp.lcm);
 #elif defined(HAVE_RATGRING)
   if (rIsRatGRing(currRing))
   pLcmRat(p,strat->S[i],Lp.lcm, currRing->real_var_start); // int rat_shift
   else
   pLcm(p,strat->S[i],Lp.lcm);
 #endif
   pSetm(Lp.lcm);
 
 
   if (strat->sugarCrit && ALLOW_PROD_CRIT(strat))
   {
     if((!((strat->ecartS[i]>0)&&(ecart>0)))
     && pHasNotCF(p,strat->S[i]))
     {
     /*
     *the product criterion has applied for (s,p),
     *i.e. lcm(s,p)=product of the leading terms of s and p.
     *Suppose (s,r) is in L and the leading term
     *of p divides lcm(s,r)
     *(==> the leading term of p divides the leading term of r)
     *but the leading term of s does not divide the leading term of r
     *(notice that tis condition is automatically satisfied if r is still
     *in S), then (s,r) can be cancelled.
     *This should be done here because the
     *case lcm(s,r)=lcm(s,p) is not covered by chainCrit.
     *
     *Moreover, skipping (s,r) holds also for the noncommutative case.
     */
       strat->cp++;
       pLmFree(Lp.lcm);
       Lp.lcm=NULL;
       return;
     }
     else
       Lp.ecart = si_max(ecart,strat->ecartS[i]);
     if (strat->fromT && (strat->ecartS[i]>ecart))
     {
       pLmFree(Lp.lcm);
       Lp.lcm=NULL;
       return;
       /*the pair is (s[i],t[.]), discard it if the ecart is too big*/
     }
     /*
     *the set B collects the pairs of type (S[j],p)
     *suppose (r,p) is in B and (s,p) is the new pair and lcm(s,p)#lcm(r,p)
     *if the leading term of s devides lcm(r,p) then (r,p) will be canceled
     *if the leading term of r devides lcm(s,p) then (s,p) will not enter B
     */
     {
       j = strat->Bl;
       loop
       {
         if (j < 0)  break;
         compare=pDivComp(strat->B[j].lcm,Lp.lcm);
         if ((compare==1)
         &&(sugarDivisibleBy(strat->B[j].ecart,Lp.ecart)))
         {
           strat->c3++;
           if ((strat->fromQ==NULL) || (isFromQ==0) || (strat->fromQ[i]==0))
           {
             pLmFree(Lp.lcm);
             return;
           }
           break;
         }
         else
         if ((compare ==-1)
         && sugarDivisibleBy(Lp.ecart,strat->B[j].ecart))
         {
           deleteInL(strat->B,&strat->Bl,j,strat);
           strat->c3++;
         }
         j--;
       }
     }
   }
   else /*sugarcrit*/
   {
     if (ALLOW_PROD_CRIT(strat))
     {
       // if currRing->nc_type!=quasi (or skew)
       // TODO: enable productCrit for super commutative algebras...
       if(/*(strat->ak==0) && productCrit(p,strat->S[i])*/
       pHasNotCF(p,strat->S[i]))
       {
       /*
       *the product criterion has applied for (s,p),
       *i.e. lcm(s,p)=product of the leading terms of s and p.
       *Suppose (s,r) is in L and the leading term
       *of p devides lcm(s,r)
       *(==> the leading term of p devides the leading term of r)
       *but the leading term of s does not devide the leading term of r
       *(notice that tis condition is automatically satisfied if r is still
       *in S), then (s,r) can be canceled.
       *This should be done here because the
       *case lcm(s,r)=lcm(s,p) is not covered by chainCrit.
       */
           strat->cp++;
           pLmFree(Lp.lcm);
           Lp.lcm=NULL;
           return;
       }
       if (strat->fromT && (strat->ecartS[i]>ecart))
       {
         pLmFree(Lp.lcm);
         Lp.lcm=NULL;
         return;
         /*the pair is (s[i],t[.]), discard it if the ecart is too big*/
       }
       /*
       *the set B collects the pairs of type (S[j],p)
       *suppose (r,p) is in B and (s,p) is the new pair and lcm(s,p)#lcm(r,p)
       *if the leading term of s devides lcm(r,p) then (r,p) will be canceled
       *if the leading term of r devides lcm(s,p) then (s,p) will not enter B
       */
       for(j = strat->Bl;j>=0;j--)
       {
         compare=pDivComp(strat->B[j].lcm,Lp.lcm);
         if (compare==1)
         {
           strat->c3++;
           if ((strat->fromQ==NULL) || (isFromQ==0) || (strat->fromQ[i]==0))
           {
             pLmFree(Lp.lcm);
             return;
           }
           break;
         }
         else
         if (compare ==-1)
         {
           deleteInL(strat->B,&strat->Bl,j,strat);
           strat->c3++;
         }
       }
     }
   }
   /*
   *the pair (S[i],p) enters B if the spoly != 0
   */
   /*-  compute the short s-polynomial -*/
   if (strat->fromT && !TEST_OPT_INTSTRATEGY)
     pNorm(p);
 
   if ((strat->S[i]==NULL) || (p==NULL))
     return;
 
   if ((strat->fromQ!=NULL) && (isFromQ!=0) && (strat->fromQ[i]!=0))
     Lp.p=NULL;
   else
   {
     #ifdef HAVE_PLURAL
     if ( rIsPluralRing(currRing) )
     {
       if(pHasNotCF(p, strat->S[i]))
       {
          if(ncRingType(currRing) == nc_lie)
          {
              // generalized prod-crit for lie-type
              strat->cp++;
              Lp.p = nc_p_Bracket_qq(pCopy(p),strat->S[i], currRing);
          }
          else
         if( ALLOW_PROD_CRIT(strat) )
         {
             // product criterion for homogeneous case in SCA
             strat->cp++;
             Lp.p = NULL;
         }
         else
         {
           Lp.p = // nc_CreateSpoly(strat->S[i],p,currRing);
                 nc_CreateShortSpoly(strat->S[i], p, currRing);
 
           assume(pNext(Lp.p)==NULL); // TODO: this may be violated whenever ext.prod.crit. for Lie alg. is used
           pNext(Lp.p) = strat->tail; // !!!
         }
       }
       else
       {
         Lp.p = // nc_CreateSpoly(strat->S[i],p,currRing);
               nc_CreateShortSpoly(strat->S[i], p, currRing);
 
         assume(pNext(Lp.p)==NULL); // TODO: this may be violated whenever ext.prod.crit. for Lie alg. is used
         pNext(Lp.p) = strat->tail; // !!!
 
       }
 
 
 #if MYTEST
       if (TEST_OPT_DEBUG)
       {
         PrintS("enterOnePairNormal::\n strat->S[i]: "); pWrite(strat->S[i]);
         PrintS("p: "); pWrite(p);
         PrintS("SPoly: "); pWrite(Lp.p);
       }
 #endif
 
     }
     else
     #endif
     {
       assume(!rIsPluralRing(currRing));
       Lp.p = ksCreateShortSpoly(strat->S[i], p, strat->tailRing);
 #if MYTEST
       if (TEST_OPT_DEBUG)
       {
         PrintS("enterOnePairNormal::\n strat->S[i]: "); pWrite(strat->S[i]);
         PrintS("p: "); pWrite(p);
         PrintS("commutative SPoly: "); pWrite(Lp.p);
       }
 #endif
 
       }
   }
   if (Lp.p == NULL)
   {
     /*- the case that the s-poly is 0 -*/
     if (strat->pairtest==NULL) initPairtest(strat);
     strat->pairtest[i] = TRUE;/*- hint for spoly(S^[i],p)=0 -*/
     strat->pairtest[strat->sl+1] = TRUE;
     /*hint for spoly(S[i],p) == 0 for some i,0 <= i <= sl*/
     /*
     *suppose we have (s,r),(r,p),(s,p) and spoly(s,p) == 0 and (r,p) is
     *still in B (i.e. lcm(r,p) == lcm(s,p) or the leading term of s does not
     *devide lcm(r,p)). In the last case (s,r) can be canceled if the leading
     *term of p devides the lcm(s,r)
     *(this canceling should be done here because
     *the case lcm(s,p) == lcm(s,r) is not covered in chainCrit)
     *the first case is handeled in chainCrit
     */
     if (Lp.lcm!=NULL) pLmFree(Lp.lcm);
   }
   else
   {
     /*- the pair (S[i],p) enters B -*/
     Lp.p1 = strat->S[i];
     Lp.p2 = p;
 
     if (
         (!rIsPluralRing(currRing))
 //      ||  (rIsPluralRing(currRing) && (ncRingType(currRing) != nc_lie))
        )
     {
       assume(pNext(Lp.p)==NULL); // TODO: this may be violated whenever ext.prod.crit. for Lie alg. is used
       pNext(Lp.p) = strat->tail; // !!!
     }
 
     if (atR >= 0)
     {
       Lp.i_r1 = strat->S_2_R[i];
       Lp.i_r2 = atR;
     }
     else
     {
       Lp.i_r1 = -1;
       Lp.i_r2 = -1;
     }
     strat->initEcartPair(&Lp,strat->S[i],p,strat->ecartS[i],ecart);
 
     if (TEST_OPT_INTSTRATEGY)
     {
       if (!rIsPluralRing(currRing))
         nDelete(&(Lp.p->coef));
     }
 
     l = strat->posInL(strat->B,strat->Bl,&Lp,strat);
     enterL(&strat->B,&strat->Bl,&strat->Bmax,Lp,l);
   }
 }

void enterOnePairSelfShifts	(	poly	qq,
		poly	p,
		int	ecart,
		int	isFromQ,
		kStrategy	strat,
		int	atR,
		int	uptodeg,
		int	lV
	)

Definition at line 10339 of file kutil.cc.

 {
 
   /* format: p,qq are in LObject form: lm in CR, tail in TR */
   /* for true self pairs qq ==p  */
   /* we test both qq and p */
   assume(p_LmCheckIsFromRing(qq,currRing));
   assume(p_CheckIsFromRing(pNext(qq),strat->tailRing));
   assume(p_LmCheckIsFromRing(p,currRing));
   assume(p_CheckIsFromRing(pNext(p),strat->tailRing));
 
   /* since this proc is applied twice for (h, s*g) and (g,s*h), init j with 1 only */
 
   //  int j = 0;
   int j = 1;
 
   /* for such self pairs start with 1, not with 0 */
   if (qq == p) j=1;
 
   /* should cycle through all shifts of q until uptodeg - lastVblock(q) */
   /* that is create the pairs (f, s \dot g)  */
 
   int toInsert =  itoInsert(qq, uptodeg,  lV, strat->tailRing);
 
 #ifdef KDEBUG
     if (TEST_OPT_DEBUG)
     {
       //      Print("entered SelfShifts: with toInsert=%d",toInsert); PrintLn();
     }
 #endif
 
   poly q;
 
   /* these vars hold for all shifts of s[i] */
   int ecartq = 0; //Hans says it's ok; we're in the homog case, no ecart
   int qfromQ = 0; // strat->fromQ[i];
 
   for (; j<= toInsert; j++)
   {
     //    q = pLPshift(strat->S[i],j,uptodeg,lV);
     /* we increase shifts by one; must delete q there*/
     //    q = qq; q = pMoveCurrTail2poly(q,strat);
     //    q = pLPshift(q,j,uptodeg,lV); //,currRing);
     q = p_LPshiftT(qq, j, uptodeg, lV, strat, currRing);
     //    q = p_mLPshift(qq,j,uptodeg,lV,currRing); // lm in currRing, shift this monomial
     //    s = p_LPshift(pNext(qq), j, uptodeg, lV, strat->tailRing); // from tailRing
     //    pNext(q) = s; // in tailRing
     /* here we need to call enterOnePair with two polys ... */
 #ifdef KDEBUG
     if (TEST_OPT_DEBUG)
     {
       //      PrintS("SelfShifts: calling enterOnePairShift(q,p)");      PrintLn();
     }
 #endif
     enterOnePairShift(q, p, ecart, isFromQ, strat, -1, ecartq, qfromQ, j, -1, uptodeg, lV);
   }
 }

void enterOnePairShift	(	poly	q,
		poly	p,
		int	ecart,
		int	isFromQ,
		kStrategy	strat,
		int	atR,
		int	ecartq,
		int	qisFromQ,
		int	shiftcount,
		int	ifromS,
		int	uptodeg,
		int	lV
	)

Definition at line 10402 of file kutil.cc.

 {
 
   /* Format: q and p are like strat->P.p, so lm in CR, tail in TR */
 
   /* check this Formats: */
   assume(p_LmCheckIsFromRing(q,currRing));
   assume(p_CheckIsFromRing(pNext(q),strat->tailRing));
   assume(p_LmCheckIsFromRing(p,currRing));
   assume(p_CheckIsFromRing(pNext(p),strat->tailRing));
 
 #ifdef KDEBUG
     if (TEST_OPT_DEBUG)
     {
 //       PrintS("enterOnePairShift(q,p) invoked with q = ");
 //       wrp(q); //      wrp(pHead(q));
 //       PrintS(", p = ");
 //       wrp(p); //wrp(pHead(p));
 //       PrintLn();
     }
 #endif
 
   /* poly q stays for s[i], ecartq = ecart(q), qisFromQ = applies to q */
 
   int qfromQ = qisFromQ;
 
   /* need additionally: int up_to_degree, poly V0 with the variables in (0)  or just the number lV = the length of the first block */
 
   int      l,j,compare;
   LObject  Lp;
   Lp.i_r = -1;
 
 #ifdef KDEBUG
   Lp.ecart=0; Lp.length=0;
 #endif
   /*- computes the lcm(s[i],p) -*/
   Lp.lcm = pInit();
 
   pLcm(p,q, Lp.lcm); // q is what was strat->S[i], so a poly in LM/TR presentation
   pSetm(Lp.lcm);
 
   /* apply the V criterion */
   if (!isInV(Lp.lcm, lV))
   {
 #ifdef KDEBUG
     if (TEST_OPT_DEBUG)
     {
       PrintS("V crit applied to q = ");
       wrp(q); //      wrp(pHead(q));
       PrintS(", p = ");
       wrp(p); //wrp(pHead(p));
       PrintLn();
     }
 #endif
     pLmFree(Lp.lcm);
     Lp.lcm=NULL;
     /* + counter for applying the V criterion */
     strat->cv++;
     return;
   }
 
   if (strat->sugarCrit && ALLOW_PROD_CRIT(strat))
   {
     if((!((ecartq>0)&&(ecart>0)))
     && pHasNotCF(p,q))
     {
     /*
     *the product criterion has applied for (s,p),
     *i.e. lcm(s,p)=product of the leading terms of s and p.
     *Suppose (s,r) is in L and the leading term
     *of p divides lcm(s,r)
     *(==> the leading term of p divides the leading term of r)
     *but the leading term of s does not divide the leading term of r
     *(notice that this condition is automatically satisfied if r is still
     *in S), then (s,r) can be cancelled.
     *This should be done here because the
     *case lcm(s,r)=lcm(s,p) is not covered by chainCrit.
     *
     *Moreover, skipping (s,r) holds also for the noncommutative case.
     */
       strat->cp++;
       pLmFree(Lp.lcm);
       Lp.lcm=NULL;
       return;
     }
     else
       Lp.ecart = si_max(ecart,ecartq);
     if (strat->fromT && (ecartq>ecart))
     {
       pLmFree(Lp.lcm);
       Lp.lcm=NULL;
       return;
       /*the pair is (s[i],t[.]), discard it if the ecart is too big*/
     }
     /*
     *the set B collects the pairs of type (S[j],p)
     *suppose (r,p) is in B and (s,p) is the new pair and lcm(s,p)#lcm(r,p)
     *if the leading term of s devides lcm(r,p) then (r,p) will be canceled
     *if the leading term of r devides lcm(s,p) then (s,p) will not enter B
     */
     {
       j = strat->Bl;
       loop
       {
         if (j < 0)  break;
         compare=pDivComp(strat->B[j].lcm,Lp.lcm);
         if ((compare==1)
         &&(sugarDivisibleBy(strat->B[j].ecart,Lp.ecart)))
         {
           strat->c3++;
           if ((strat->fromQ==NULL) || (isFromQ==0) || (qfromQ==0))
           {
             pLmFree(Lp.lcm);
             return;
           }
           break;
         }
         else
         if ((compare ==-1)
         && sugarDivisibleBy(Lp.ecart,strat->B[j].ecart))
         {
           deleteInL(strat->B,&strat->Bl,j,strat);
           strat->c3++;
         }
         j--;
       }
     }
   }
   else /*sugarcrit*/
   {
     if (ALLOW_PROD_CRIT(strat))
     {
       // if currRing->nc_type!=quasi (or skew)
       // TODO: enable productCrit for super commutative algebras...
       if(/*(strat->ak==0) && productCrit(p,strat->S[i])*/
       pHasNotCF(p,q))
       {
       /*
       *the product criterion has applied for (s,p),
       *i.e. lcm(s,p)=product of the leading terms of s and p.
       *Suppose (s,r) is in L and the leading term
       *of p devides lcm(s,r)
       *(==> the leading term of p devides the leading term of r)
       *but the leading term of s does not devide the leading term of r
       *(notice that tis condition is automatically satisfied if r is still
       *in S), then (s,r) can be canceled.
       *This should be done here because the
       *case lcm(s,r)=lcm(s,p) is not covered by chainCrit.
       */
           strat->cp++;
           pLmFree(Lp.lcm);
           Lp.lcm=NULL;
           return;
       }
       if (strat->fromT && (ecartq>ecart))
       {
         pLmFree(Lp.lcm);
         Lp.lcm=NULL;
         return;
         /*the pair is (s[i],t[.]), discard it if the ecart is too big*/
       }
       /*
       *the set B collects the pairs of type (S[j],p)
       *suppose (r,p) is in B and (s,p) is the new pair and lcm(s,p)#lcm(r,p)
       *if the leading term of s devides lcm(r,p) then (r,p) will be canceled
       *if the leading term of r devides lcm(s,p) then (s,p) will not enter B
       */
       for(j = strat->Bl;j>=0;j--)
       {
         compare=pDivComp(strat->B[j].lcm,Lp.lcm);
         if (compare==1)
         {
           strat->c3++;
           if ((strat->fromQ==NULL) || (isFromQ==0) || (qfromQ==0))
           {
             pLmFree(Lp.lcm);
             return;
           }
           break;
         }
         else
         if (compare ==-1)
         {
           deleteInL(strat->B,&strat->Bl,j,strat);
           strat->c3++;
         }
       }
     }
   }
   /*
   *the pair (S[i],p) enters B if the spoly != 0
   */
   /*-  compute the short s-polynomial -*/
   if (strat->fromT && !TEST_OPT_INTSTRATEGY)
     pNorm(p);
   if ((q==NULL) || (p==NULL))
     return;
   if ((strat->fromQ!=NULL) && (isFromQ!=0) && (qfromQ!=0))
     Lp.p=NULL;
   else
   {
 //     if ( rIsPluralRing(currRing) )
 //     {
 //       if(pHasNotCF(p, q))
 //       {
 //         if(ncRingType(currRing) == nc_lie)
 //         {
 //             // generalized prod-crit for lie-type
 //             strat->cp++;
 //             Lp.p = nc_p_Bracket_qq(pCopy(p),q, currRing);
 //         }
 //         else
 //         if( ALLOW_PROD_CRIT(strat) )
 //         {
 //             // product criterion for homogeneous case in SCA
 //             strat->cp++;
 //             Lp.p = NULL;
 //         }
 //         else
 //           Lp.p = nc_CreateSpoly(q,p,currRing); // ?
 //       }
 //       else  Lp.p = nc_CreateSpoly(q,p,currRing);
 //     }
 //     else
 //     {
 
     /* ksCreateShortSpoly needs two Lobject-kind presentations */
     /* p is already in this form, so convert q */
     //    q = pMove2CurrTail(q, strat);
     Lp.p = ksCreateShortSpoly(q, p, strat->tailRing);
       //  }
   }
   if (Lp.p == NULL)
   {
     /*- the case that the s-poly is 0 -*/
     /* TEMPORARILY DISABLED FOR SHIFTS because there is no i*/
 //      if (strat->pairtest==NULL) initPairtest(strat);
 //      strat->pairtest[i] = TRUE;/*- hint for spoly(S^[i],p)=0 -*/
 //      strat->pairtest[strat->sl+1] = TRUE;
     /* END _ TEMPORARILY DISABLED FOR SHIFTS */
     /*hint for spoly(S[i],p) == 0 for some i,0 <= i <= sl*/
     /*
     *suppose we have (s,r),(r,p),(s,p) and spoly(s,p) == 0 and (r,p) is
     *still in B (i.e. lcm(r,p) == lcm(s,p) or the leading term of s does not
     *devide lcm(r,p)). In the last case (s,r) can be canceled if the leading
     *term of p devides the lcm(s,r)
     *(this canceling should be done here because
     *the case lcm(s,p) == lcm(s,r) is not covered in chainCrit)
     *the first case is handeled in chainCrit
     */
     if (Lp.lcm!=NULL) pLmFree(Lp.lcm);
   }
   else
   {
     /*- the pair (S[i],p) enters B -*/
     /* both of them should have their LM in currRing and TAIL in tailring */
     Lp.p1 = q;  // already in the needed form
     Lp.p2 = p; // already in the needed form
 
     if ( !rIsPluralRing(currRing) )
       pNext(Lp.p) = strat->tail;
 
     /* TEMPORARILY DISABLED FOR SHIFTS because there's no i*/
     /* at the beginning we DO NOT set atR = -1 ANYMORE*/
     if ( (atR >= 0) && (shiftcount==0) && (ifromS >=0) )
     {
       Lp.i_r1 = kFindInT(Lp.p1,strat); //strat->S_2_R[ifromS];
       Lp.i_r2 = atR;
     }
     else
     {
       /* END _ TEMPORARILY DISABLED FOR SHIFTS */
       Lp.i_r1 = -1;
       Lp.i_r2 = -1;
      }
     strat->initEcartPair(&Lp,q,p,ecartq,ecart);
 
     if (TEST_OPT_INTSTRATEGY)
     {
       if (!rIsPluralRing(currRing))
         nDelete(&(Lp.p->coef));
     }
 
     l = strat->posInL(strat->B,strat->Bl,&Lp,strat);
     enterL(&strat->B,&strat->Bl,&strat->Bmax,Lp,l);
   }
 }

void enterOnePairSig	(	int	i,
		poly	p,
		poly	pSig,
		int	ecart,
		int	isFromQ,
		kStrategy	strat,
		int	atR
	)

BOOLEAN enterOneStrongPoly	(	int	i,
		poly	p,
		int	,
		int	,
		kStrategy	strat,
		int	atR = `-1`,
		bool	enterTstrong = `FALSE`
	)

Definition at line 1399 of file kutil.cc.

 {
   number d, s, t;
   assume(atR >= 0);
   poly m1, m2, gcd,si;
   if(!enterTstrong)
   {
     assume(i<=strat->sl);
     si = strat->S[i];
   }
   else
   {
     assume(i<=strat->tl);
     si = strat->T[i].p;
   }
   //printf("\n--------------------------------\n");
   //pWrite(p);pWrite(si);
   d = n_ExtGcd(pGetCoeff(p), pGetCoeff(si), &s, &t, currRing->cf);
 
   if (nIsZero(s) || nIsZero(t))  // evtl. durch divBy tests ersetzen
   {
     nDelete(&d);
     nDelete(&s);
     nDelete(&t);
     return FALSE;
   }
 
   k_GetStrongLeadTerms(p, si, currRing, m1, m2, gcd, strat->tailRing);
   //p_Test(m1,strat->tailRing);
   //p_Test(m2,strat->tailRing);
   /*if(!enterTstrong)
   {
     while (! kCheckStrongCreation(atR, m1, i, m2, strat) )
     {
       memset(&(strat->P), 0, sizeof(strat->P));
       kStratChangeTailRing(strat);
       strat->P = *(strat->R[atR]);
       p_LmFree(m1, strat->tailRing);
       p_LmFree(m2, strat->tailRing);
       p_LmFree(gcd, currRing);
       k_GetStrongLeadTerms(p, si, currRing, m1, m2, gcd, strat->tailRing);
     }
   }*/
   pSetCoeff0(m1, s);
   pSetCoeff0(m2, t);
   pSetCoeff0(gcd, d);
   p_Test(m1,strat->tailRing);
   p_Test(m2,strat->tailRing);
   //printf("\n===================================\n");
   //pWrite(m1);pWrite(m2);pWrite(gcd);
 #ifdef KDEBUG
   if (TEST_OPT_DEBUG)
   {
     // Print("t = %d; s = %d; d = %d\n", nInt(t), nInt(s), nInt(d));
     PrintS("m1 = ");
     p_wrp(m1, strat->tailRing);
     PrintS(" ; m2 = ");
     p_wrp(m2, strat->tailRing);
     PrintS(" ; gcd = ");
     wrp(gcd);
     PrintS("\n--- create strong gcd poly: ");
     Print("\n p: %d", i);
     wrp(p);
     Print("\n strat->S[%d]: ", i);
     wrp(si);
     PrintS(" ---> ");
   }
 #endif
 
   pNext(gcd) = p_Add_q(pp_Mult_mm(pNext(p), m1, strat->tailRing), pp_Mult_mm(pNext(si), m2, strat->tailRing), strat->tailRing);
   p_LmDelete(m1, strat->tailRing);
   p_LmDelete(m2, strat->tailRing);
 #ifdef KDEBUG
   if (TEST_OPT_DEBUG)
   {
     wrp(gcd);
     PrintLn();
   }
 #endif
 
   LObject h;
   h.p = gcd;
   h.tailRing = strat->tailRing;
   int posx;
   h.pCleardenom();
   strat->initEcart(&h);
   h.sev = pGetShortExpVector(h.p);
   h.i_r1 = -1;h.i_r2 = -1;
   if (currRing!=strat->tailRing)
     h.t_p = k_LmInit_currRing_2_tailRing(h.p, strat->tailRing);
   if(!enterTstrong)
   {
     #if 1
     h.p1 = p;h.p2 = strat->S[i];
     #endif
     if (atR >= 0)
     {
       h.i_r2 = strat->S_2_R[i];
       h.i_r1 = atR;
     }
     else
     {
       h.i_r1 = -1;
       h.i_r2 = -1;
     }
     if (strat->Ll==-1)
       posx =0;
     else
       posx = strat->posInL(strat->L,strat->Ll,&h,strat);
     enterL(&strat->L,&strat->Ll,&strat->Lmax,h,posx);
   }
   else
   {
     if(h.IsNull()) return FALSE;
     //int red_result;
     //reduzieren ist teur!!!
     //if(strat->L != NULL)
       //red_result = strat->red(&h,strat);
     if(!h.IsNull())
     {
       enterT(h, strat,-1);
       //int pos = posInS(strat,strat->sl,h.p,h.ecart);
       //strat->enterS(h,pos,strat,-1);
     }
   }
   //#if 1
   #if ADIDEBUG
   printf("\nThis strong poly was added to L:\n");pWrite(h.p);pWrite(h.p1);pWrite(h.p2);
   #endif
   return TRUE;
 }

void enterpairs	(	poly	h,
		int	k,
		int	ec,
		int	pos,
		kStrategy	strat,
		int	atR = `-1`
	)

Definition at line 3988 of file kutil.cc.

 {
   int j=pos;
 
 #ifdef HAVE_RINGS
   assume (!rField_is_Ring(currRing));
 #endif
   //#if ADIDEBUG
   #if 0
         Print("\n    Vor initenterpairs: The new pair list L -- after superenterpairs in loop\n");
         for(int iii=0;iii<=strat->Ll;iii++)
         {
           printf("\n    L[%d]:\n",iii);
           PrintS("         ");p_Write(strat->L[iii].p,strat->tailRing);
           PrintS("         ");p_Write(strat->L[iii].p1,strat->tailRing);
           PrintS("         ");p_Write(strat->L[iii].p2,strat->tailRing);
         }
         #endif
 
   initenterpairs(h,k,ecart,0,strat, atR);
 
       //#if ADIDEBUG
       #if 0
         Print("\n    Nach initenterpairs: The new pair list L -- after superenterpairs in loop \n");
         for(int iii=0;iii<=strat->Ll;iii++)
         {
           printf("\n    L[%d]:\n",iii);
           PrintS("         ");p_Write(strat->L[iii].p,strat->tailRing);
           PrintS("         ");p_Write(strat->L[iii].p1,strat->tailRing);
           PrintS("         ");p_Write(strat->L[iii].p2,strat->tailRing);
         }
         #endif
 
   if ( (!strat->fromT)
   && ((strat->syzComp==0)
     ||(pGetComp(h)<=strat->syzComp)))
   {
     //Print("start clearS k=%d, pos=%d, sl=%d\n",k,pos,strat->sl);
     unsigned long h_sev = pGetShortExpVector(h);
     loop
     {
       if (j > k) break;
       clearS(h,h_sev, &j,&k,strat);
       j++;
     }
     //Print("end clearS sl=%d\n",strat->sl);
   }
  // PrintS("end enterpairs\n");
 }

void enterpairsShift	(	poly	h,
		int	k,
		int	ecart,
		int	pos,
		kStrategy	strat,
		int	atR,
		int	uptodeg,
		int	lV
	)

Definition at line 10696 of file kutil.cc.

 {
   /* h is strat->P.p, that is LObject with LM in currRing and Tail in tailRing */
   /* Q: what is exactly the strat->fromT ? A: a local case trick; don't need it yet*/
   int j=pos;
 
 #ifdef HAVE_RINGS
   assume (!rField_is_Ring(currRing));
 #endif
   initenterpairsShift(h,k,ecart,0,strat, atR,uptodeg,lV);
   if ( (!strat->fromT)
   && ((strat->syzComp==0)
     ||(pGetComp(h)<=strat->syzComp)))
   {
     //Print("start clearS k=%d, pos=%d, sl=%d\n",k,pos,strat->sl);
     unsigned long h_sev = pGetShortExpVector(h);
     loop
     {
       if (j > k) break;
       clearS(h,h_sev, &j,&k,strat);
       j++;
     }
     //Print("end clearS sl=%d\n",strat->sl);
   }
  // PrintS("end enterpairs\n");
 }

void enterpairsSig	(	poly	h,
		poly	hSig,
		int	from,
		int	k,
		int	ec,
		int	pos,
		kStrategy	strat,
		int	atR = `-1`
	)

Definition at line 4044 of file kutil.cc.

 {
 int j=pos;
 
 #ifdef HAVE_RINGS
 assume (!rField_is_Ring(currRing));
 #endif
 
 initenterpairsSig(h,hSig,hFrom,k,ecart,0,strat, atR);
 if ( (!strat->fromT)
 && ((strat->syzComp==0)
   ||(pGetComp(h)<=strat->syzComp)))
 {
   //Print("start clearS k=%d, pos=%d, sl=%d\n",k,pos,strat->sl);
   unsigned long h_sev = pGetShortExpVector(h);
   loop
   {
     if (j > k) break;
     clearS(h,h_sev, &j,&k,strat);
     j++;
   }
   //Print("end clearS sl=%d\n",strat->sl);
 }
 // PrintS("end enterpairs\n");
 }

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

Definition at line 7577 of file kutil.cc.

 {
   strat->news = TRUE;
   /*- puts p to the standardbasis s at position at -*/
   if (strat->sl == IDELEMS(strat->Shdl)-1)
   {
     strat->sevS = (unsigned long*) omRealloc0Size(strat->sevS,
                                     IDELEMS(strat->Shdl)*sizeof(unsigned long),
                                     (IDELEMS(strat->Shdl)+setmaxTinc)
                                                   *sizeof(unsigned long));
     strat->ecartS = (intset)omReallocSize(strat->ecartS,
                                           IDELEMS(strat->Shdl)*sizeof(int),
                                           (IDELEMS(strat->Shdl)+setmaxTinc)
                                                   *sizeof(int));
     strat->S_2_R = (int*) omRealloc0Size(strat->S_2_R,
                                          IDELEMS(strat->Shdl)*sizeof(int),
                                          (IDELEMS(strat->Shdl)+setmaxTinc)
                                                   *sizeof(int));
     if (strat->lenS!=NULL)
       strat->lenS=(int*)omRealloc0Size(strat->lenS,
                                        IDELEMS(strat->Shdl)*sizeof(int),
                                        (IDELEMS(strat->Shdl)+setmaxTinc)
                                                  *sizeof(int));
     if (strat->lenSw!=NULL)
       strat->lenSw=(wlen_type*)omRealloc0Size(strat->lenSw,
                                        IDELEMS(strat->Shdl)*sizeof(wlen_type),
                                        (IDELEMS(strat->Shdl)+setmaxTinc)
                                                  *sizeof(wlen_type));
     if (strat->fromQ!=NULL)
     {
       strat->fromQ = (intset)omReallocSize(strat->fromQ,
                                     IDELEMS(strat->Shdl)*sizeof(int),
                                     (IDELEMS(strat->Shdl)+setmaxTinc)*sizeof(int));
     }
     pEnlargeSet(&strat->S,IDELEMS(strat->Shdl),setmaxTinc);
     IDELEMS(strat->Shdl)+=setmaxTinc;
     strat->Shdl->m=strat->S;
   }
   if (atS <= strat->sl)
   {
 #ifdef ENTER_USE_MEMMOVE
 // #if 0
     memmove(&(strat->S[atS+1]), &(strat->S[atS]),
             (strat->sl - atS + 1)*sizeof(poly));
     memmove(&(strat->ecartS[atS+1]), &(strat->ecartS[atS]),
             (strat->sl - atS + 1)*sizeof(int));
     memmove(&(strat->sevS[atS+1]), &(strat->sevS[atS]),
             (strat->sl - atS + 1)*sizeof(unsigned long));
     memmove(&(strat->S_2_R[atS+1]), &(strat->S_2_R[atS]),
             (strat->sl - atS + 1)*sizeof(int));
     if (strat->lenS!=NULL)
     memmove(&(strat->lenS[atS+1]), &(strat->lenS[atS]),
             (strat->sl - atS + 1)*sizeof(int));
     if (strat->lenSw!=NULL)
     memmove(&(strat->lenSw[atS+1]), &(strat->lenSw[atS]),
             (strat->sl - atS + 1)*sizeof(wlen_type));
 #else
     for (i=strat->sl+1; i>=atS+1; i--)
     {
       strat->S[i] = strat->S[i-1];
       strat->ecartS[i] = strat->ecartS[i-1];
       strat->sevS[i] = strat->sevS[i-1];
       strat->S_2_R[i] = strat->S_2_R[i-1];
     }
     if (strat->lenS!=NULL)
     for (i=strat->sl+1; i>=atS+1; i--)
       strat->lenS[i] = strat->lenS[i-1];
     if (strat->lenSw!=NULL)
     for (i=strat->sl+1; i>=atS+1; i--)
       strat->lenSw[i] = strat->lenSw[i-1];
 #endif
   }
   if (strat->fromQ!=NULL)
   {
 #ifdef ENTER_USE_MEMMOVE
     memmove(&(strat->fromQ[atS+1]), &(strat->fromQ[atS]),
                   (strat->sl - atS + 1)*sizeof(int));
 #else
     for (i=strat->sl+1; i>=atS+1; i--)
     {
       strat->fromQ[i] = strat->fromQ[i-1];
     }
 #endif
     strat->fromQ[atS]=0;
   }
 
   /*- save result -*/
   strat->S[atS] = p.p;
   if (strat->honey) strat->ecartS[atS] = p.ecart;
   if (p.sev == 0)
     p.sev = pGetShortExpVector(p.p);
   else
     assume(p.sev == pGetShortExpVector(p.p));
   strat->sevS[atS] = p.sev;
   strat->ecartS[atS] = p.ecart;
   strat->S_2_R[atS] = atR;
   strat->sl++;
 }

void entersets ( LObject h )

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

Definition at line 7680 of file kutil.cc.

 {
   strat->news = TRUE;
   /*- puts p to the standardbasis s at position at -*/
   if (strat->sl == IDELEMS(strat->Shdl)-1)
   {
     strat->sevS = (unsigned long*) omRealloc0Size(strat->sevS,
                                     IDELEMS(strat->Shdl)*sizeof(unsigned long),
                                     (IDELEMS(strat->Shdl)+setmaxTinc)
                                                   *sizeof(unsigned long));
     strat->sevSig = (unsigned long*) omRealloc0Size(strat->sevSig,
                                     IDELEMS(strat->Shdl)*sizeof(unsigned long),
                                     (IDELEMS(strat->Shdl)+setmaxTinc)
                                                   *sizeof(unsigned long));
     strat->ecartS = (intset)omReallocSize(strat->ecartS,
                                           IDELEMS(strat->Shdl)*sizeof(int),
                                           (IDELEMS(strat->Shdl)+setmaxTinc)
                                                   *sizeof(int));
     strat->S_2_R = (int*) omRealloc0Size(strat->S_2_R,
                                          IDELEMS(strat->Shdl)*sizeof(int),
                                          (IDELEMS(strat->Shdl)+setmaxTinc)
                                                   *sizeof(int));
     if (strat->lenS!=NULL)
       strat->lenS=(int*)omRealloc0Size(strat->lenS,
                                        IDELEMS(strat->Shdl)*sizeof(int),
                                        (IDELEMS(strat->Shdl)+setmaxTinc)
                                                  *sizeof(int));
     if (strat->lenSw!=NULL)
       strat->lenSw=(wlen_type*)omRealloc0Size(strat->lenSw,
                                        IDELEMS(strat->Shdl)*sizeof(wlen_type),
                                        (IDELEMS(strat->Shdl)+setmaxTinc)
                                                  *sizeof(wlen_type));
     if (strat->fromQ!=NULL)
     {
       strat->fromQ = (intset)omReallocSize(strat->fromQ,
                                     IDELEMS(strat->Shdl)*sizeof(int),
                                     (IDELEMS(strat->Shdl)+setmaxTinc)*sizeof(int));
     }
     pEnlargeSet(&strat->S,IDELEMS(strat->Shdl),setmaxTinc);
     pEnlargeSet(&strat->sig,IDELEMS(strat->Shdl),setmaxTinc);
     IDELEMS(strat->Shdl)+=setmaxTinc;
     strat->Shdl->m=strat->S;
   }
   // in a signature-based algorithm the following situation will never
   // appear due to the fact that the critical pairs are already sorted
   // by increasing signature.
   if (atS <= strat->sl)
   {
 #ifdef ENTER_USE_MEMMOVE
 // #if 0
     memmove(&(strat->S[atS+1]), &(strat->S[atS]),
             (strat->sl - atS + 1)*sizeof(poly));
     memmove(&(strat->ecartS[atS+1]), &(strat->ecartS[atS]),
             (strat->sl - atS + 1)*sizeof(int));
     memmove(&(strat->sevS[atS+1]), &(strat->sevS[atS]),
             (strat->sl - atS + 1)*sizeof(unsigned long));
     memmove(&(strat->S_2_R[atS+1]), &(strat->S_2_R[atS]),
             (strat->sl - atS + 1)*sizeof(int));
     if (strat->lenS!=NULL)
     memmove(&(strat->lenS[atS+1]), &(strat->lenS[atS]),
             (strat->sl - atS + 1)*sizeof(int));
     if (strat->lenSw!=NULL)
     memmove(&(strat->lenSw[atS+1]), &(strat->lenSw[atS]),
             (strat->sl - atS + 1)*sizeof(wlen_type));
 #else
     for (i=strat->sl+1; i>=atS+1; i--)
     {
       strat->S[i] = strat->S[i-1];
       strat->ecartS[i] = strat->ecartS[i-1];
       strat->sevS[i] = strat->sevS[i-1];
       strat->S_2_R[i] = strat->S_2_R[i-1];
     }
     if (strat->lenS!=NULL)
     for (i=strat->sl+1; i>=atS+1; i--)
       strat->lenS[i] = strat->lenS[i-1];
     if (strat->lenSw!=NULL)
     for (i=strat->sl+1; i>=atS+1; i--)
       strat->lenSw[i] = strat->lenSw[i-1];
 #endif
   }
   if (strat->fromQ!=NULL)
   {
 #ifdef ENTER_USE_MEMMOVE
     memmove(&(strat->fromQ[atS+1]), &(strat->fromQ[atS]),
                   (strat->sl - atS + 1)*sizeof(int));
 #else
     for (i=strat->sl+1; i>=atS+1; i--)
     {
       strat->fromQ[i] = strat->fromQ[i-1];
     }
 #endif
     strat->fromQ[atS]=0;
   }
 
   /*- save result -*/
   strat->S[atS] = p.p;
   strat->sig[atS] = p.sig; // TODO: get ths correct signature in here!
   if (strat->honey) strat->ecartS[atS] = p.ecart;
   if (p.sev == 0)
     p.sev = pGetShortExpVector(p.p);
   else
     assume(p.sev == pGetShortExpVector(p.p));
   strat->sevS[atS] = p.sev;
   // during the interreduction process of a signature-based algorithm we do not
   // compute the signature at this point, but when the whole interreduction
   // process finishes, i.e. f5c terminates!
   if (p.sig != NULL)
   {
     if (p.sevSig == 0)
       p.sevSig = pGetShortExpVector(p.sig);
     else
       assume(p.sevSig == pGetShortExpVector(p.sig));
     strat->sevSig[atS] = p.sevSig; // TODO: get the correct signature in here!
   }
   strat->ecartS[atS] = p.ecart;
   strat->S_2_R[atS] = atR;
   strat->sl++;
 #ifdef DEBUGF5
   int k;
   Print("--- LIST S: %d ---\n",strat->sl);
   for(k=0;k<=strat->sl;k++)
   {
     pWrite(strat->sig[k]);
   }
   Print("--- LIST S END ---\n");
 #endif
 }

void enterSyz	(	LObject &	p,
		kStrategy	strat,
		int	atT
	)

Definition at line 8007 of file kutil.cc.

 {
   int i;
   strat->newt = TRUE;
   if (strat->syzl == strat->syzmax-1)
   {
     pEnlargeSet(&strat->syz,strat->syzmax,setmaxTinc);
     strat->sevSyz = (unsigned long*) omRealloc0Size(strat->sevSyz,
                                     (strat->syzmax)*sizeof(unsigned long),
                                     ((strat->syzmax)+setmaxTinc)
                                                   *sizeof(unsigned long));
     strat->syzmax += setmaxTinc;
   }
   if (atT < strat->syzl)
   {
 #ifdef ENTER_USE_MEMMOVE
     memmove(&(strat->syz[atT+1]), &(strat->syz[atT]),
             (strat->syzl-atT+1)*sizeof(poly));
     memmove(&(strat->sevSyz[atT+1]), &(strat->sevSyz[atT]),
             (strat->syzl-atT+1)*sizeof(unsigned long));
 #endif
     for (i=strat->syzl; i>=atT+1; i--)
     {
 #ifndef ENTER_USE_MEMMOVE
       strat->syz[i] = strat->syz[i-1];
       strat->sevSyz[i] = strat->sevSyz[i-1];
 #endif
     }
   }
   //i = strat->syzl;
   i = atT;
   strat->syz[atT] = p.sig;
   strat->sevSyz[atT] = p.sevSig;
   strat->syzl++;
 #if F5DEBUG
   Print("element in strat->syz: %d--%d  ",atT+1,strat->syzmax);
   pWrite(strat->syz[atT]);
 #endif
   // recheck pairs in strat->L with new rule and delete correspondingly
   int cc = strat->Ll;
   while (cc>-1)
   {
     if (p_LmShortDivisibleBy( strat->syz[atT], strat->sevSyz[atT],
                               strat->L[cc].sig, ~strat->L[cc].sevSig, currRing))
     {
       deleteInL(strat->L,&strat->Ll,cc,strat);
     }
     cc--;
   }
 //#if 1
 #ifdef DEBUGF5
     PrintS("--- Syzygies ---\n");
     Print("syzl   %d\n",strat->syzl);
     Print("syzmax %d\n",strat->syzmax);
     PrintS("--------------------------------\n");
     for(i=0;i<=strat->syzl-1;i++)
     {
       Print("%d - ",i);
       pWrite(strat->syz[i]);
     }
     PrintS("--------------------------------\n");
 #endif
 }

void enterT	(	LObject &	p,
		kStrategy	strat,
		int	atT = `-1`
	)

Definition at line 7811 of file kutil.cc.

 {
   int i;
 
   pp_Test(p.p, currRing, p.tailRing);
   assume(strat->tailRing == p.tailRing);
   // redMoraNF complains about this -- but, we don't really
   // neeed this so far
   assume(p.pLength == 0 || pLength(p.p) == p.pLength || rIsSyzIndexRing(currRing)); // modulo syzring
   assume(p.FDeg == p.pFDeg());
   assume(!p.is_normalized || nIsOne(pGetCoeff(p.p)));
 
 #ifdef KDEBUG
   // do not put an LObject twice into T:
   for(i=strat->tl;i>=0;i--)
   {
     if (p.p==strat->T[i].p)
     {
       printf("already in T at pos %d of %d, atT=%d\n",i,strat->tl,atT);
       return;
     }
   }
 #endif
 
 #ifdef HAVE_TAIL_RING
   if (currRing!=strat->tailRing)
   {
     p.t_p=p.GetLmTailRing();
   }
 #endif
   strat->newt = TRUE;
   if (atT < 0)
     atT = strat->posInT(strat->T, strat->tl, p);
   if (strat->tl == strat->tmax-1)
     enlargeT(strat->T,strat->R,strat->sevT,strat->tmax,setmaxTinc);
   if (atT <= strat->tl)
   {
 #ifdef ENTER_USE_MEMMOVE
     memmove(&(strat->T[atT+1]), &(strat->T[atT]),
             (strat->tl-atT+1)*sizeof(TObject));
     memmove(&(strat->sevT[atT+1]), &(strat->sevT[atT]),
             (strat->tl-atT+1)*sizeof(unsigned long));
 #endif
     for (i=strat->tl+1; i>=atT+1; i--)
     {
 #ifndef ENTER_USE_MEMMOVE
       strat->T[i] = strat->T[i-1];
       strat->sevT[i] = strat->sevT[i-1];
 #endif
       strat->R[strat->T[i].i_r] = &(strat->T[i]);
     }
   }
 
   if ((strat->tailBin != NULL) && (pNext(p.p) != NULL))
   {
     pNext(p.p)=p_ShallowCopyDelete(pNext(p.p),
                                    (strat->tailRing != NULL ?
                                     strat->tailRing : currRing),
                                    strat->tailBin);
     if (p.t_p != NULL) pNext(p.t_p) = pNext(p.p);
   }
   strat->T[atT] = (TObject) p;
   #if ADIDEBUG
   printf("\nenterT: add in position %i\n",atT);
   pWrite(p.p);
   #endif
   //printf("\nenterT: neue hingefügt: länge = %i, ecart = %i\n",p.length,p.ecart);
 
   if (strat->tailRing != currRing && pNext(p.p) != NULL)
     strat->T[atT].max = p_GetMaxExpP(pNext(p.p), strat->tailRing);
   else
     strat->T[atT].max = NULL;
 
   strat->tl++;
   strat->R[strat->tl] = &(strat->T[atT]);
   strat->T[atT].i_r = strat->tl;
   assume(p.sev == 0 || pGetShortExpVector(p.p) == p.sev);
   strat->sevT[atT] = (p.sev == 0 ? pGetShortExpVector(p.p) : p.sev);
   kTest_T(&(strat->T[atT]));
 }

void enterT_strong	(	LObject &	p,
		kStrategy	strat,
		int	atT = `-1`
	)

Definition at line 7895 of file kutil.cc.

 {
   int i;
 
   pp_Test(p.p, currRing, p.tailRing);
   assume(strat->tailRing == p.tailRing);
   // redMoraNF complains about this -- but, we don't really
   // neeed this so far
   assume(p.pLength == 0 || pLength(p.p) == p.pLength || rIsSyzIndexRing(currRing)); // modulo syzring
   assume(p.FDeg == p.pFDeg());
   assume(!p.is_normalized || nIsOne(pGetCoeff(p.p)));
 
 #ifdef KDEBUG
   // do not put an LObject twice into T:
   for(i=strat->tl;i>=0;i--)
   {
     if (p.p==strat->T[i].p)
     {
       printf("already in T at pos %d of %d, atT=%d\n",i,strat->tl,atT);
       return;
     }
   }
 #endif
 
 #ifdef HAVE_TAIL_RING
   if (currRing!=strat->tailRing)
   {
     p.t_p=p.GetLmTailRing();
   }
 #endif
   strat->newt = TRUE;
   if (atT < 0)
     atT = strat->posInT(strat->T, strat->tl, p);
   if (strat->tl == strat->tmax-1)
     enlargeT(strat->T,strat->R,strat->sevT,strat->tmax,setmaxTinc);
   if (atT <= strat->tl)
   {
 #ifdef ENTER_USE_MEMMOVE
     memmove(&(strat->T[atT+1]), &(strat->T[atT]),
             (strat->tl-atT+1)*sizeof(TObject));
     memmove(&(strat->sevT[atT+1]), &(strat->sevT[atT]),
             (strat->tl-atT+1)*sizeof(unsigned long));
 #endif
     for (i=strat->tl+1; i>=atT+1; i--)
     {
 #ifndef ENTER_USE_MEMMOVE
       strat->T[i] = strat->T[i-1];
       strat->sevT[i] = strat->sevT[i-1];
 #endif
       strat->R[strat->T[i].i_r] = &(strat->T[i]);
     }
   }
 
   if ((strat->tailBin != NULL) && (pNext(p.p) != NULL))
   {
     pNext(p.p)=p_ShallowCopyDelete(pNext(p.p),
                                    (strat->tailRing != NULL ?
                                     strat->tailRing : currRing),
                                    strat->tailBin);
     if (p.t_p != NULL) pNext(p.t_p) = pNext(p.p);
   }
   strat->T[atT] = (TObject) p;
   #if ADIDEBUG
   printf("\nenterT_strong: add in position %i\n",atT);
   pWrite(p.p);
   #endif
   //printf("\nenterT_strong: neue hingefügt: länge = %i, ecart = %i\n",p.length,p.ecart);
 
   if (strat->tailRing != currRing && pNext(p.p) != NULL)
     strat->T[atT].max = p_GetMaxExpP(pNext(p.p), strat->tailRing);
   else
     strat->T[atT].max = NULL;
 
   strat->tl++;
   strat->R[strat->tl] = &(strat->T[atT]);
   strat->T[atT].i_r = strat->tl;
   assume(p.sev == 0 || pGetShortExpVector(p.p) == p.sev);
   strat->sevT[atT] = (p.sev == 0 ? pGetShortExpVector(p.p) : p.sev);
   #if 1
   #ifdef HAVE_RINGS
   if(rField_is_Ring(currRing) && rHasLocalOrMixedOrdering(currRing) && !n_IsUnit(p.p->coef, currRing->cf))
   {
     #if ADIDEBUG
     printf("\nDas ist p:\n");pWrite(p.p);
     #endif
     for(i=strat->tl;i>=0;i--)
     {
       if(strat->T[i].ecart <= p.ecart && pLmDivisibleBy(strat->T[i].p,p.p))
       {
         #if ADIDEBUG
         printf("\nFound one: %i\n",i);pWrite(strat->T[i].p);
         #endif
         enterOneStrongPoly(i,p.p,p.ecart,0,strat,0 , TRUE);
       }
     }
   }
   /*
   printf("\nThis is T:\n");
   for(i=strat->tl;i>=0;i--)
   {
     pWrite(strat->T[i].p);
   }
   //getchar();*/
   #endif
   #endif
   kTest_T(&(strat->T[atT]));
 }

void enterTShift	(	LObject	p,
		kStrategy	strat,
		int	atT,
		int	uptodeg,
		int	lV
	)

Definition at line 10803 of file kutil.cc.

 {
   /* determine how many elements we have to insert */
   /* x(0)y(1)z(2) : lastVblock-1=2, to add until lastVblock=uptodeg-1 */
   /* hence, a total number of elt's to add is: */
   /*  int toInsert = 1 + (uptodeg-1) - (pLastVblock(p.p, lV) -1);  */
 
   int toInsert =  itoInsert(p.p, uptodeg,  lV, strat->tailRing);
 
 #ifdef PDEBUG
   //  Print("enterTShift uses toInsert: %d", toInsert);  PrintLn();
 #endif
   int i;
 
   if (atT < 0)
     atT = strat->posInT(strat->T, strat->tl, p);
 
   /* can call enterT in a sequence, e.g. */
 
   /* shift0 = it's our model for further shifts */
   enterT(p,strat,atT);
   LObject qq;
   for (i=1; i<=toInsert; i++) // toIns - 1?
   {
     qq      = p; //qq.Copy();
     qq.p    = NULL;
     qq.max  = NULL;
     qq.t_p = p_LPshift(p_Copy(p.t_p,strat->tailRing), i, uptodeg, lV, strat->tailRing); // direct shift
     qq.GetP();
     // update q.sev
     qq.sev = pGetShortExpVector(qq.p);
     /* enter it into T, first el't is with the shift 0 */
     // compute the position for qq
     atT = strat->posInT(strat->T, strat->tl, qq);
     enterT(qq,strat,atT);
   }
 /* Q: what to do with this one in the orig enterT ? */
 /*  strat->R[strat->tl] = &(strat->T[atT]); */
 /* Solution: it is done by enterT each time separately */
 }

void exitBuchMora ( kStrategy strat )

Definition at line 8419 of file kutil.cc.

 {
   /*- release temp data -*/
   cleanT(strat);
   omFreeSize(strat->T,(strat->tmax)*sizeof(TObject));
   omFreeSize(strat->R,(strat->tmax)*sizeof(TObject*));
   omFreeSize(strat->sevT, (strat->tmax)*sizeof(unsigned long));
   omFreeSize(strat->ecartS,IDELEMS(strat->Shdl)*sizeof(int));
   omFreeSize((ADDRESS)strat->sevS,IDELEMS(strat->Shdl)*sizeof(unsigned long));
   omFreeSize(strat->S_2_R,IDELEMS(strat->Shdl)*sizeof(int));
   /*- set L: should be empty -*/
   omFreeSize(strat->L,(strat->Lmax)*sizeof(LObject));
   /*- set B: should be empty -*/
   omFreeSize(strat->B,(strat->Bmax)*sizeof(LObject));
   pLmDelete(&strat->tail);
   strat->syzComp=0;
 }

void exitSba ( kStrategy strat )

Definition at line 8614 of file kutil.cc.

 {
   /*- release temp data -*/
   cleanT(strat);
   omFreeSize(strat->T,(strat->tmax)*sizeof(TObject));
   omFreeSize(strat->R,(strat->tmax)*sizeof(TObject*));
   omFreeSize(strat->sevT, (strat->tmax)*sizeof(unsigned long));
   omFreeSize(strat->ecartS,IDELEMS(strat->Shdl)*sizeof(int));
   omFreeSize((ADDRESS)strat->sevS,IDELEMS(strat->Shdl)*sizeof(unsigned long));
   omFreeSize((ADDRESS)strat->sevSig,IDELEMS(strat->Shdl)*sizeof(unsigned long));
   omFreeSize((ADDRESS)strat->syz,(strat->syzmax)*sizeof(poly));
   omFreeSize((ADDRESS)strat->sevSyz,(strat->syzmax)*sizeof(unsigned long));
   if (strat->sbaOrder == 1)
   {
     omFreeSize(strat->syzIdx,(strat->syzidxmax)*sizeof(int));
   }
   omFreeSize(strat->S_2_R,IDELEMS(strat->Shdl)*sizeof(int));
   /*- set L: should be empty -*/
   omFreeSize(strat->L,(strat->Lmax)*sizeof(LObject));
   /*- set B: should be empty -*/
   omFreeSize(strat->B,(strat->Bmax)*sizeof(LObject));
   /*- set sig: no need for the signatures anymore -*/
   omFreeSize(strat->sig,IDELEMS(strat->Shdl)*sizeof(poly));
   pLmDelete(&strat->tail);
   strat->syzComp=0;
 }

void f5c	(	kStrategy	strat,
		int &	olddeg,
		int &	minimcnt,
		int &	hilbeledeg,
		int &	hilbcount,
		int &	srmax,
		int &	lrmax,
		int &	reduc,
		ideal	Q,
		intvec *	w,
		intvec *	hilb
	)

Definition at line 2748 of file kstd2.cc.

 {
   int Ll_old, red_result = 1;
   int pos  = 0;
   hilbeledeg=1;
   hilbcount=0;
   minimcnt=0;
   srmax = 0; // strat->sl is 0 at this point
   reduc = olddeg = lrmax = 0;
   // we cannot use strat->T anymore
   //cleanT(strat);
   //strat->tl = -1;
   Ll_old    = strat->Ll;
   while (strat->tl >= 0)
   {
     if(!strat->T[strat->tl].is_redundant)
     {
       LObject h;
       h.p = strat->T[strat->tl].p;
       h.tailRing = strat->T[strat->tl].tailRing;
       h.t_p = strat->T[strat->tl].t_p;
       if (h.p!=NULL)
       {
         if (currRing->OrdSgn==-1)
         {
           cancelunit(&h);
           deleteHC(&h, strat);
         }
         if (h.p!=NULL)
         {
           if (TEST_OPT_INTSTRATEGY)
           {
             //pContent(h.p);
             h.pCleardenom(); // also does a pContent
           }
           else
           {
             h.pNorm();
           }
           strat->initEcart(&h);
           pos = strat->Ll+1;
           h.sev = pGetShortExpVector(h.p);
           enterL(&strat->L,&strat->Ll,&strat->Lmax,h,pos);
         }
       }
     }
     strat->tl--;
   }
   strat->sl = -1;
 #if 0
 //#ifdef HAVE_TAIL_RING
   if(!rField_is_Ring())  // create strong gcd poly computes with tailring and S[i] ->to be fixed
     kStratInitChangeTailRing(strat);
 #endif
   //enterpairs(pOne(),0,0,-1,strat,strat->tl);
   //strat->sl = -1;
   /* picks the last element from the lazyset L */
   while (strat->Ll>Ll_old)
   {
     strat->P = strat->L[strat->Ll];
     strat->Ll--;
 //#if 1
 #ifdef DEBUGF5
     Print("NEXT PAIR TO HANDLE IN INTERRED ALGORITHM\n");
     Print("-------------------------------------------------\n");
     pWrite(pHead(strat->P.p));
     pWrite(pHead(strat->P.p1));
     pWrite(pHead(strat->P.p2));
     printf("%d\n",strat->tl);
     Print("-------------------------------------------------\n");
 #endif
     if (pNext(strat->P.p) == strat->tail)
     {
       // deletes the short spoly
 #ifdef HAVE_RINGS
       if (rField_is_Ring(currRing))
         pLmDelete(strat->P.p);
       else
 #endif
         pLmFree(strat->P.p);
 
       // TODO: needs some masking
       // TODO: masking needs to vanish once the signature
       //       sutff is completely implemented
       strat->P.p = NULL;
       poly m1 = NULL, m2 = NULL;
 
       // check that spoly creation is ok
       while (strat->tailRing != currRing &&
           !kCheckSpolyCreation(&(strat->P), strat, m1, m2))
       {
         assume(m1 == NULL && m2 == NULL);
         // if not, change to a ring where exponents are at least
         // large enough
         if (!kStratChangeTailRing(strat))
         {
           WerrorS("OVERFLOW...");
           break;
         }
       }
       // create the real one
       ksCreateSpoly(&(strat->P), NULL, strat->use_buckets,
           strat->tailRing, m1, m2, strat->R);
     }
     else if (strat->P.p1 == NULL)
     {
       if (strat->minim > 0)
         strat->P.p2=p_Copy(strat->P.p, currRing, strat->tailRing);
       // for input polys, prepare reduction
       strat->P.PrepareRed(strat->use_buckets);
     }
 
     if (strat->P.p == NULL && strat->P.t_p == NULL)
     {
       red_result = 0;
     }
     else
     {
       if (TEST_OPT_PROT)
         message((strat->honey ? strat->P.ecart : 0) + strat->P.pFDeg(),
             &olddeg,&reduc,strat, red_result);
 
 #ifdef DEBUGF5
       Print("Poly before red: ");
       pWrite(strat->P.p);
 #endif
       /* complete reduction of the element chosen from L */
       red_result = strat->red2(&strat->P,strat);
       if (errorreported)  break;
     }
 
     if (strat->overflow)
     {
       if (!kStratChangeTailRing(strat)) { Werror("OVERFLOW.."); break;}
     }
 
     // reduction to non-zero new poly
     if (red_result == 1)
     {
       // get the polynomial (canonicalize bucket, make sure P.p is set)
       strat->P.GetP(strat->lmBin);
       // in the homogeneous case FDeg >= pFDeg (sugar/honey)
       // but now, for entering S, T, we reset it
       // in the inhomogeneous case: FDeg == pFDeg
       if (strat->homog) strat->initEcart(&(strat->P));
 
       /* statistic */
       if (TEST_OPT_PROT) PrintS("s");
 
       int pos=posInS(strat,strat->sl,strat->P.p,strat->P.ecart);
 
 #ifdef KDEBUG
 #if MYTEST
       PrintS("New S: "); pDebugPrint(strat->P.p); PrintLn();
 #endif /* MYTEST */
 #endif /* KDEBUG */
 
       // reduce the tail and normalize poly
       // in the ring case we cannot expect LC(f) = 1,
       // therefore we call pContent instead of pNorm
 #if F5CTAILRED
       BOOLEAN withT = TRUE;
       if ((TEST_OPT_INTSTRATEGY) || (rField_is_Ring(currRing)))
       {
         strat->P.pCleardenom();
         if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
         {
           strat->P.p = redtailBba(&(strat->P),pos-1,strat, withT);
           strat->P.pCleardenom();
         }
       }
       else
       {
         strat->P.pNorm();
         if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
           strat->P.p = redtailBba(&(strat->P),pos-1,strat, withT);
       }
 #endif
 #ifdef KDEBUG
       if (TEST_OPT_DEBUG){PrintS("new s:");strat->P.wrp();PrintLn();}
 #if MYTEST
 //#if 1
       PrintS("New (reduced) S: "); pDebugPrint(strat->P.p); PrintLn();
 #endif /* MYTEST */
 #endif /* KDEBUG */
 
       // min_std stuff
       if ((strat->P.p1==NULL) && (strat->minim>0))
       {
         if (strat->minim==1)
         {
           strat->M->m[minimcnt]=p_Copy(strat->P.p,currRing,strat->tailRing);
           p_Delete(&strat->P.p2, currRing, strat->tailRing);
         }
         else
         {
           strat->M->m[minimcnt]=strat->P.p2;
           strat->P.p2=NULL;
         }
         if (strat->tailRing!=currRing && pNext(strat->M->m[minimcnt])!=NULL)
           pNext(strat->M->m[minimcnt])
             = strat->p_shallow_copy_delete(pNext(strat->M->m[minimcnt]),
                 strat->tailRing, currRing,
                 currRing->PolyBin);
         minimcnt++;
       }
 
       // enter into S, L, and T
       // here we need to recompute new signatures, but those are trivial ones
       if ((!TEST_OPT_IDLIFT) || (pGetComp(strat->P.p) <= strat->syzComp))
       {
         enterT(strat->P, strat);
         // posInS only depends on the leading term
         strat->enterS(strat->P, pos, strat, strat->tl);
 //#if 1
 #ifdef DEBUGF5
         Print("ELEMENT ADDED TO GCURR DURING INTERRED: ");
         pWrite(pHead(strat->S[strat->sl]));
         pWrite(strat->sig[strat->sl]);
 #endif
         if (hilb!=NULL) khCheck(Q,w,hilb,hilbeledeg,hilbcount,strat);
       }
       //      Print("[%d]",hilbeledeg);
       if (strat->P.lcm!=NULL)
 #ifdef HAVE_RINGS
         pLmDelete(strat->P.lcm);
 #else
       pLmFree(strat->P.lcm);
 #endif
       if (strat->sl>srmax) srmax = strat->sl;
     }
     else
     {
       // adds signature of the zero reduction to
       // strat->syz. This is the leading term of
       // syzygy and can be used in syzCriterion()
       // the signature is added if and only if the
       // pair was not detected by the rewritten criterion in strat->red = redSig
       if (strat->P.p1 == NULL && strat->minim > 0)
       {
         p_Delete(&strat->P.p2, currRing, strat->tailRing);
       }
     }
 
 #ifdef KDEBUG
     memset(&(strat->P), 0, sizeof(strat->P));
 #endif /* KDEBUG */
   }
   int cc = 0;
   while (cc<strat->tl+1)
   {
     strat->T[cc].sig        = pOne();
     p_SetComp(strat->T[cc].sig,cc+1,currRing);
     strat->T[cc].sevSig     = pGetShortExpVector(strat->T[cc].sig);
     strat->sig[cc]          = strat->T[cc].sig;
     strat->sevSig[cc]       = strat->T[cc].sevSig;
     strat->T[cc].is_sigsafe = TRUE;
     cc++;
   }
   strat->max_lower_index = strat->tl;
   // set current signature index of upcoming iteration step
   // NOTE:  this needs to be set here, as otherwise initSyzRules cannot compute
   //        the corresponding syzygy rules correctly
   strat->currIdx = cc+1;
   for (int cd=strat->Ll; cd>=0; cd--)
   {
     p_SetComp(strat->L[cd].sig,cc+1,currRing);
     cc++;
   }
   for (cc=strat->sl+1; cc<IDELEMS(strat->Shdl); ++cc)
     strat->Shdl->m[cc]  = NULL;
 //#if 1
 #if DEBUGF5
   Print("------------------- STRAT S ---------------------\n");
   cc = 0;
   while (cc<strat->tl+1)
   {
     pWrite(pHead(strat->S[cc]));
     pWrite(strat->sig[cc]);
     printf("- - - - - -\n");
     cc++;
   }
   Print("-------------------------------------------------\n");
   Print("------------------- STRAT T ---------------------\n");
   cc = 0;
   while (cc<strat->tl+1)
   {
     pWrite(pHead(strat->T[cc].p));
     pWrite(strat->T[cc].sig);
     printf("- - - - - -\n");
     cc++;
   }
   Print("-------------------------------------------------\n");
   Print("------------------- STRAT L ---------------------\n");
   cc = 0;
   while (cc<strat->Ll+1)
   {
     pWrite(pHead(strat->L[cc].p));
     pWrite(pHead(strat->L[cc].p1));
     pWrite(pHead(strat->L[cc].p2));
     pWrite(strat->L[cc].sig);
     printf("- - - - - -\n");
     cc++;
   }
   Print("-------------------------------------------------\n");
   printf("F5C DONE\nSTRAT SL: %d -- %d\n",strat->sl, strat->currIdx);
 #endif
 
 }

BOOLEAN faugereRewCriterion	(	poly	sig,
		unsigned long	not_sevSig,
		poly	lm,
		kStrategy	strat,
		int	start
	)

Definition at line 5750 of file kutil.cc.

 {
   //printf("Faugere Rewritten Criterion\n");
 //#if 1
 #ifdef DEBUGF5
   PrintS("rewritten criterion checks:  ");
   pWrite(sig);
 #endif
   for(int k = strat->sl; k>=start; k--)
   {
 //#if 1
 #ifdef DEBUGF5
     Print("checking with:  ");
     pWrite(strat->sig[k]);
     pWrite(pHead(strat->S[k]));
 #endif
     if (p_LmShortDivisibleBy(strat->sig[k], strat->sevSig[k], sig, not_sevSig, currRing))
     {
 //#if 1
 #ifdef DEBUGF5
       PrintS("DELETE!\n");
 #endif
       return TRUE;
     }
     //k--;
   }
 #ifdef DEBUGF5
   Print("ALL ELEMENTS OF S\n----------------------------------------\n");
   for(int kk = 0; kk<strat->sl+1; kk++)
   {
     pWrite(pHead(strat->S[kk]));
   }
   Print("------------------------------\n");
 #endif
   return FALSE;
 }

void finalReduceByMon ( kStrategy strat )

used for GB over ZZ: final reduction by constant elements background: any known constant element of ideal suppresses intermediate coefficient swell and beautifies output

Definition at line 9294 of file kutil.cc.

 {
   if(!nCoeff_is_Ring_Z(currRing->cf))
       return;
   poly p,pp;
   for(int j = 0; j<=strat->sl; j++)
   {
     if((strat->S[j]!=NULL)&&(pNext(strat->S[j]) == NULL))
     {
       for(int i = 0; i<=strat->sl; i++)
       {
         if((i != j) && (strat->S[i] != NULL))
         {
           p = strat->S[i];
           if(pLmDivisibleBy(strat->S[j], p))
           {
             number dummy = n_IntMod(p->coef, strat->S[j]->coef, currRing->cf);
             p_SetCoeff(p,dummy,currRing);
           }
           pp = pNext(p);
           if((pp == NULL) && (nIsZero(p->coef)))
           {
             deleteInS(i, strat);
           }
           else
           {
             while(pp != NULL)
               {
                 if(pLmDivisibleBy(strat->S[j], pp))
                 {
                   number dummy = n_IntMod(pp->coef, strat->S[j]->coef, currRing->cf);
                   p_SetCoeff(pp,dummy,currRing);
                   if(nIsZero(pp->coef))
                   {
                     pLmDelete(&pNext(p));
                     pp = pNext(p);
                   }
                   else
                   {
                     p = pp;
                     pp = pNext(p);
                   }
                 }
                 else
                 {
                   p = pp;
                   pp = pNext(p);
                 }
               }
           }
           if(strat->S[i]!= NULL && nIsZero(pGetCoeff(strat->S[i])))
           {
             if(pNext(strat->S[i]) == NULL)
                 strat->S[i]=NULL;
             else
                 strat->S[i]=pNext(strat->S[i]);
           }
         }
       }
       //idPrint(strat->Shdl);
     }
   }
   //idSkipZeroes(strat->Shdl);
 }

BOOLEAN findMinLMPair	(	poly	sig,
		unsigned long	not_sevSig,
		kStrategy	strat,
		int	start
	)

ideal freegb	(	ideal	I,
		int	uptodeg,
		int	lVblock
	)

Definition at line 3406 of file kstd2.cc.

 {
   /* todo main call */
 
   /* assume: ring is prepared, ideal is copied into shifted ring */
   /* uptodeg and lVblock are correct - test them! */
 
   /* check whether the ideal is in V */
 
 //  if (0)
   if (! ideal_isInV(I,lVblock) )
   {
     WerrorS("The input ideal contains incorrectly encoded elements! ");
     return(NULL);
   }
 
   //  kStrategy strat = new skStrategy;
   /* ideal bbaShift(ideal F, ideal Q,intvec *w,intvec *hilb,kStrategy strat, int uptodeg, int lV) */
   /* at the moment:
 - no quotient (check)
 - no *w, no *hilb
   */
   /* ideal F, ideal Q, tHomog h,intvec ** w, intvec *hilb,int syzComp,
      int newIdeal, intvec *vw) */
   ideal RS = kStdShift(I,NULL, testHomog, NULL,NULL,0,0,NULL, uptodeg, lVblock);
     //bbaShift(I,NULL, NULL, NULL, strat, uptodeg, lVblock);
   idSkipZeroes(RS);
   return(RS);
 }

void HEckeTest	(	poly	pp,
		kStrategy	strat
	)

Definition at line 436 of file kutil.cc.

 {
   int   j,/*k,*/p;
 
   strat->kHEdgeFound=FALSE;
   if (currRing->pLexOrder || rHasMixedOrdering(currRing))
   {
     return;
   }
   if (strat->ak > 1)           /*we are in the module case*/
   {
     return; // until ....
     //if (!pVectorOut)     /*pVectorOut <=> order = c,* */
     //  return FALSE;
     //if (pGetComp(pp) < strat->ak) /* ak is the number of the last component */
     //  return FALSE;
   }
   // k = 0;
   p=pIsPurePower(pp);
   if (p!=0) strat->NotUsedAxis[p] = FALSE;
   /*- the leading term of pp is a power of the p-th variable -*/
   for (j=(currRing->N);j>0; j--)
   {
     if (strat->NotUsedAxis[j])
     {
       return;
     }
   }
   strat->kHEdgeFound=TRUE;
 }

BOOLEAN homogTest	(	polyset	F,
		int	Fmax
	)

long ind2 ( long arg )

Definition at line 3339 of file kutil.cc.

 {
   long ind = 0;
   if (arg <= 0) return 0;
   while (arg%2 == 0)
   {
     arg = arg / 2;
     ind++;
   }
   return ind;
 }

long ind_fact_2 ( long arg )

Definition at line 3351 of file kutil.cc.

 {
   long ind = 0;
   if (arg <= 0) return 0;
   if (arg%2 == 1) { arg--; }
   while (arg > 0)
   {
     ind += ind2(arg);
     arg = arg - 2;
   }
   return ind;
 }

void initBba	(	ideal	F,
		kStrategy	strat
	)

Definition at line 1388 of file kstd1.cc.

 {
  /* setting global variables ------------------- */
   strat->enterS = enterSBba;
     strat->red = redHoney;
   if (strat->honey)
     strat->red = redHoney;
   else if (currRing->pLexOrder && !strat->homog)
     strat->red = redLazy;
   else
   {
     strat->LazyPass *=4;
     strat->red = redHomog;
   }
 #ifdef HAVE_RINGS  //TODO Oliver
   if (rField_is_Ring(currRing))
   {
     strat->red = redRing;
   }
 #endif
   if (currRing->pLexOrder && strat->honey)
     strat->initEcart = initEcartNormal;
   else
     strat->initEcart = initEcartBBA;
   if (strat->honey)
     strat->initEcartPair = initEcartPairMora;
   else
     strat->initEcartPair = initEcartPairBba;
 //  if ((TEST_OPT_WEIGHTM)&&(F!=NULL))
 //  {
 //    //interred  machen   Aenderung
 //    strat->pOrigFDeg=pFDeg;
 //    strat->pOrigLDeg=pLDeg;
 //    //h=ggetid("ecart");
 //    //if ((h!=NULL) /*&& (IDTYP(h)==INTVEC_CMD)*/)
 //    //{
 //    //  ecartWeights=iv2array(IDINTVEC(h));
 //    //}
 //    //else
 //    {
 //      ecartWeights=(short *)omAlloc(((currRing->N)+1)*sizeof(short));
 //      /*uses automatic computation of the ecartWeights to set them*/
 //      kEcartWeights(F->m,IDELEMS(F)-1,ecartWeights);
 //    }
 //    pRestoreDegProcs(currRing,totaldegreeWecart, maxdegreeWecart);
 //    if (TEST_OPT_PROT)
 //    {
 //      for(i=1; i<=(currRing->N); i++)
 //        Print(" %d",ecartWeights[i]);
 //      PrintLn();
 //      mflush();
 //    }
 //  }
 }

void initBbaShift	(	ideal	F,
		kStrategy	strat
	)

Definition at line 3567 of file kstd2.cc.

 {
  /* setting global variables ------------------- */
   strat->enterS = enterSBba; /* remains as is, we change enterT! */
 
   strat->red = redFirstShift; /* no redHomog ! */
 
   if (currRing->pLexOrder && strat->honey)
     strat->initEcart = initEcartNormal;
   else
     strat->initEcart = initEcartBBA;
   if (strat->honey)
     strat->initEcartPair = initEcartPairMora;
   else
     strat->initEcartPair = initEcartPairBba;
 //  if ((TEST_OPT_WEIGHTM)&&(F!=NULL))
 //  {
 //    //interred  machen   Aenderung
 //    pFDegOld=currRing->pFDeg;
 //    pLDegOld=pLDeg;
 //    //h=ggetid("ecart");
 //    //if ((h!=NULL) /*&& (IDTYP(h)==INTVEC_CMD)*/)
 //    //{
 //    //  ecartWeights=iv2array(IDINTVEC(h));
 //    //}
 //    //else
 //    {
 //      ecartWeights=(short *)omAlloc(((currRing->N)+1)*sizeof(short));
 //      /*uses automatic computation of the ecartWeights to set them*/
 //      kEcartWeights(F->m,IDELEMS(F)-1,ecartWeights,currRing);
 //    }
 //    pRestoreDegProcs(currRing,totaldegreeWecart, maxdegreeWecart);
 //    if (TEST_OPT_PROT)
 //    {
 //      for(int i=1; i<=rVar(currRing); i++)
 //        Print(" %d",ecartWeights[i]);
 //      PrintLn();
 //      mflush();
 //    }
 //  }
 }

void initBuchMora	(	ideal	F,
		ideal	Q,
		kStrategy	strat
	)

Definition at line 8338 of file kutil.cc.

 {
   strat->interpt = BTEST1(OPT_INTERRUPT);
   strat->kHEdge=NULL;
   if (rHasGlobalOrdering(currRing)) strat->kHEdgeFound=FALSE;
   /*- creating temp data structures------------------- -*/
   strat->cp = 0;
   strat->c3 = 0;
   strat->tail = pInit();
   /*- set s -*/
   strat->sl = -1;
   /*- set L -*/
   strat->Lmax = ((IDELEMS(F)+setmaxLinc-1)/setmaxLinc)*setmaxLinc;
   strat->Ll = -1;
   strat->L = initL(((IDELEMS(F)+setmaxLinc-1)/setmaxLinc)*setmaxLinc);
   /*- set B -*/
   strat->Bmax = setmaxL;
   strat->Bl = -1;
   strat->B = initL();
   /*- set T -*/
   strat->tl = -1;
   strat->tmax = setmaxT;
   strat->T = initT();
   strat->R = initR();
   strat->sevT = initsevT();
   /*- init local data struct.---------------------------------------- -*/
   strat->P.ecart=0;
   strat->P.length=0;
   strat->P.pLength=0;
   if (rHasLocalOrMixedOrdering(currRing))
   {
     if (strat->kHEdge!=NULL) pSetComp(strat->kHEdge, strat->ak);
     if (strat->kNoether!=NULL) pSetComp(strat->kNoetherTail(), strat->ak);
   }
   #ifdef HAVE_RINGS
   if(rField_is_Ring(currRing))
   {
     /*Shdl=*/initSL(F, Q,strat); /*sets also S, ecartS, fromQ */
   }
   else
   #endif
   {
     if(TEST_OPT_SB_1)
     {
         int i;
         ideal P=idInit(IDELEMS(F)-strat->newIdeal,F->rank);
         for (i=strat->newIdeal;i<IDELEMS(F);i++)
         {
           P->m[i-strat->newIdeal] = F->m[i];
           F->m[i] = NULL;
         }
         initSSpecial(F,Q,P,strat);
         for (i=strat->newIdeal;i<IDELEMS(F);i++)
         {
           F->m[i] = P->m[i-strat->newIdeal];
           P->m[i-strat->newIdeal] = NULL;
         }
         idDelete(&P);
     }
 
     else
     {
       /*Shdl=*/initSL(F, Q,strat); /*sets also S, ecartS, fromQ */
       // /*Shdl=*/initS(F, Q,strat); /*sets also S, ecartS, fromQ */
     }
   }
   strat->fromT = FALSE;
   strat->noTailReduction = !TEST_OPT_REDTAIL;
   if ((!TEST_OPT_SB_1)
   #ifdef HAVE_RINGS
   || (rField_is_Ring(currRing))
   #endif
   )
   {
     updateS(TRUE,strat);
   }
   if (strat->fromQ!=NULL) omFreeSize(strat->fromQ,IDELEMS(strat->Shdl)*sizeof(int));
   strat->fromQ=NULL;
   assume(kTest_TS(strat));
 }

void initBuchMoraCrit ( kStrategy strat )

Definition at line 8092 of file kutil.cc.

 {
   strat->enterOnePair=enterOnePairNormal;
   strat->chainCrit=chainCritNormal;
   if (TEST_OPT_SB_1)
     strat->chainCrit=chainCritOpt_1;
 #ifdef HAVE_RINGS
   if (rField_is_Ring(currRing))
   {
     strat->enterOnePair=enterOnePairRing;
     strat->chainCrit=chainCritRing;
   }
 #endif
 #ifdef HAVE_RATGRING
   if (rIsRatGRing(currRing))
   {
      strat->chainCrit=chainCritPart;
      /* enterOnePairNormal get rational part in it */
   }
 #endif
   if (TEST_OPT_IDLIFT  /* i.e. also strat->syzComp==1 */
   && (!rIsPluralRing(currRing)))
     strat->enterOnePair=enterOnePairLift;
 
 
   strat->sugarCrit =        TEST_OPT_SUGARCRIT;
   strat->Gebauer =          strat->homog || strat->sugarCrit;
   strat->honey =            !strat->homog || strat->sugarCrit || TEST_OPT_WEIGHTM;
   if (TEST_OPT_NOT_SUGAR) strat->honey = FALSE;
   strat->pairtest = NULL;
   /* alway use tailreduction, except:
   * - in local rings, - in lex order case, -in ring over extensions */
   strat->noTailReduction = !TEST_OPT_REDTAIL;
   //if(rHasMixedOrdering(currRing)==2)
   //{
   // strat->noTailReduction =TRUE;
   //}
 
 #ifdef HAVE_PLURAL
   // and r is plural_ring
   //  hence this holds for r a rational_plural_ring
   if( rIsPluralRing(currRing) || (rIsSCA(currRing) && !strat->z2homog) )
   {    //or it has non-quasi-comm type... later
     strat->sugarCrit = FALSE;
     strat->Gebauer = FALSE;
     strat->honey = FALSE;
   }
 #endif
 
 #ifdef HAVE_RINGS
   // Coefficient ring?
   if (rField_is_Ring(currRing))
   {
     strat->sugarCrit = FALSE;
     strat->Gebauer = FALSE ;
     strat->honey = FALSE;
   }
 #endif
   #ifdef KDEBUG
   if (TEST_OPT_DEBUG)
   {
     if (strat->homog) PrintS("ideal/module is homogeneous\n");
     else              PrintS("ideal/module is not homogeneous\n");
   }
   #endif
 }

void initBuchMoraPos ( kStrategy strat )

Definition at line 8244 of file kutil.cc.

 {
   if (rHasGlobalOrdering(currRing))
   {
     if (strat->honey)
     {
       strat->posInL = posInL15;
       // ok -- here is the deal: from my experiments for Singular-2-0
       // I conclude that that posInT_EcartpLength is the best of
       // posInT15, posInT_EcartFDegpLength, posInT_FDegLength, posInT_pLength
       // see the table at the end of this file
       if (TEST_OPT_OLDSTD)
         strat->posInT = posInT15;
       else
         strat->posInT = posInT_EcartpLength;
     }
     else if (currRing->pLexOrder && !TEST_OPT_INTSTRATEGY)
     {
       strat->posInL = posInL11;
       strat->posInT = posInT11;
     }
     else if (TEST_OPT_INTSTRATEGY)
     {
       strat->posInL = posInL11;
       strat->posInT = posInT11;
     }
     else
     {
       strat->posInL = posInL0;
       strat->posInT = posInT0;
     }
     //if (strat->minim>0) strat->posInL =posInLSpecial;
     if (strat->homog)
     {
        strat->posInL = posInL110;
        strat->posInT = posInT110;
     }
   }
   else
   {
     if (strat->homog)
     {
       strat->posInL = posInL11;
       strat->posInT = posInT11;
     }
     else
     {
       if ((currRing->order[0]==ringorder_c)
       ||(currRing->order[0]==ringorder_C))
       {
         strat->posInL = posInL17_c;
         strat->posInT = posInT17_c;
       }
       else
       {
         strat->posInL = posInL17;
         strat->posInT = posInT17;
       }
     }
   }
   if (strat->minim>0) strat->posInL =posInLSpecial;
   // for further tests only
   if ((BTEST1(11)) || (BTEST1(12)))
     strat->posInL = posInL11;
   else if ((BTEST1(13)) || (BTEST1(14)))
     strat->posInL = posInL13;
   else if ((BTEST1(15)) || (BTEST1(16)))
     strat->posInL = posInL15;
   else if ((BTEST1(17)) || (BTEST1(18)))
     strat->posInL = posInL17;
   if (BTEST1(11))
     strat->posInT = posInT11;
   else if (BTEST1(13))
     strat->posInT = posInT13;
   else if (BTEST1(15))
     strat->posInT = posInT15;
   else if ((BTEST1(17)))
     strat->posInT = posInT17;
   else if ((BTEST1(19)))
     strat->posInT = posInT19;
   else if (BTEST1(12) || BTEST1(14) || BTEST1(16) || BTEST1(18))
     strat->posInT = posInT1;
 #ifdef HAVE_RINGS
   if (rField_is_Ring(currRing))
   {
     strat->posInL = posInL11Ring;
     if(rHasLocalOrMixedOrdering(currRing) && currRing->pLexOrder == TRUE)
       strat->posInL = posInL11Ringls;
     strat->posInT = posInT11;
   }
 #endif
   strat->posInLDependsOnLength = kPosInLDependsOnLength(strat->posInL);
 }

void initBuchMoraShift	(	ideal	F,
		ideal	Q,
		kStrategy	strat
	)

Definition at line 10180 of file kutil.cc.

 {
   strat->interpt = BTEST1(OPT_INTERRUPT);
   strat->kHEdge=NULL;
   if (rHasGlobalOrdering(currRing)) strat->kHEdgeFound=FALSE;
   /*- creating temp data structures------------------- -*/
   strat->cp = 0;
   strat->c3 = 0;
   strat->cv = 0;
   strat->tail = pInit();
   /*- set s -*/
   strat->sl = -1;
   /*- set L -*/
   strat->Lmax = setmaxL;
   strat->Ll = -1;
   strat->L = initL();
   /*- set B -*/
   strat->Bmax = setmaxL;
   strat->Bl = -1;
   strat->B = initL();
   /*- set T -*/
   strat->tl = -1;
   strat->tmax = setmaxT;
   strat->T = initT();
   strat->R = initR();
   strat->sevT = initsevT();
   /*- init local data struct.---------------------------------------- -*/
   strat->P.ecart=0;
   strat->P.length=0;
   if (rHasLocalOrMixedOrdering(currRing))
   {
     if (strat->kHEdge!=NULL) pSetComp(strat->kHEdge, strat->ak);
     if (strat->kNoether!=NULL) pSetComp(strat->kNoetherTail(), strat->ak);
   }
   #ifdef HAVE_RINGS
   if(rField_is_Ring(currRing))
   {
     /*Shdl=*/initSL(F, Q,strat); /*sets also S, ecartS, fromQ */
   }
   #endif
   {
     if(TEST_OPT_SB_1)
     {
         int i;
         ideal P=idInit(IDELEMS(F)-strat->newIdeal,F->rank);
         for (i=strat->newIdeal;i<IDELEMS(F);i++)
         {
           P->m[i-strat->newIdeal] = F->m[i];
           F->m[i] = NULL;
         }
         initSSpecial(F,Q,P,strat);
         for (i=strat->newIdeal;i<IDELEMS(F);i++)
         {
           F->m[i] = P->m[i-strat->newIdeal];
           P->m[i-strat->newIdeal] = NULL;
         }
         idDelete(&P);
     }
     else
     {
       /*Shdl=*/initSL(F, Q,strat); /*sets also S, ecartS, fromQ */
       // /*Shdl=*/initS(F, Q,strat); /*sets also S, ecartS, fromQ */
     }
   }
   strat->fromT = FALSE;
   if (!TEST_OPT_SB_1)
   {
     /* the only change: we do not fill the set T*/
     #ifdef HAVE_RINGS
     if(!rField_is_Ring(currRing))
     #endif
     updateS(FALSE,strat);
   }
   if (strat->fromQ!=NULL) omFreeSize(strat->fromQ,IDELEMS(strat->Shdl)*sizeof(int));
   strat->fromQ=NULL;
   /* more changes: fill the set T with all the shifts of elts of S*/
   /* is done by other procedure */
 }

void initEcartBBA ( TObject * h )

Definition at line 1147 of file kutil.cc.

 {
   h->FDeg = h->pFDeg();
   (*h).ecart = 0;
   h->length=h->pLength=pLength(h->p);
 }

void initEcartNormal ( TObject * h )

Definition at line 1139 of file kutil.cc.

 {
   h->FDeg = h->pFDeg();
   h->ecart = h->pLDeg() - h->FDeg;
   // h->length is set by h->pLDeg
   h->length=h->pLength=pLength(h->p);
 }

void initEcartPairBba	(	LObject *	Lp,
		poly	f,
		poly	g,
		int	ecartF,
		int	ecartG
	)

Definition at line 1154 of file kutil.cc.

 {
   Lp->FDeg = Lp->pFDeg();
   (*Lp).ecart = 0;
   (*Lp).length = 0;
 }

void initEcartPairMora	(	LObject *	Lp,
		poly	f,
		poly	g,
		int	ecartF,
		int	ecartG
	)

Definition at line 1161 of file kutil.cc.

 {
   Lp->FDeg = Lp->pFDeg();
   (*Lp).ecart = si_max(ecartF,ecartG);
   (*Lp).ecart = (*Lp).ecart- (Lp->FDeg -p_FDeg((*Lp).lcm,currRing));
   (*Lp).length = 0;
 }

void initenterpairsShift	(	poly	h,
		int	k,
		int	ecart,
		int	isFromQ,
		kStrategy	strat,
		int	atR,
		int	uptodeg,
		int	lV
	)

Definition at line 10730 of file kutil.cc.

 {
   /* h comes from strat->P.p, that is LObject with LM in currRing and Tail in tailRing */
   //  atR = -1;
   if ((strat->syzComp==0)
   || (pGetComp(h)<=strat->syzComp))
   {
     int j;
     BOOLEAN new_pair=FALSE;
 
     if (pGetComp(h)==0)
     {
       /* for Q!=NULL: build pairs (f,q),(f1,f2), but not (q1,q2)*/
       if ((isFromQ)&&(strat->fromQ!=NULL))
       {
         for (j=0; j<=k; j++)
         {
           if (!strat->fromQ[j])
           {
             new_pair=TRUE;
             enterOnePairManyShifts(j,h,ecart,isFromQ,strat, atR,uptodeg,lV);
             // other side pairs:
             enterOnePairSelfShifts(h,strat->S[j],ecart,isFromQ,strat, atR,uptodeg,lV);
           //Print("j:%d, Ll:%d\n",j,strat->Ll);
           }
         }
       }
       else
       {
         new_pair=TRUE;
         for (j=0; j<=k; j++)
         {
           enterOnePairManyShifts(j,h,ecart,isFromQ,strat, atR,uptodeg,lV);
           // other side pairs
           enterOnePairSelfShifts(h,strat->S[j],ecart,isFromQ,strat, atR,uptodeg,lV);
         }
         /* HERE we put (h, s*h) pairs */
        /* enterOnePairSelfShifts (poly qq, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int uptodeg, int lV); */
        enterOnePairSelfShifts (h, h, ecart, isFromQ, strat, atR, uptodeg, lV);
       }
     }
     else
     {
       for (j=0; j<=k; j++)
       {
         if ((pGetComp(h)==pGetComp(strat->S[j]))
         || (pGetComp(strat->S[j])==0))
         {
           new_pair=TRUE;
           enterOnePairManyShifts(j,h,ecart,isFromQ,strat, atR, uptodeg, lV);
           // other side pairs
           enterOnePairSelfShifts(h,strat->S[j],ecart,isFromQ,strat, atR,uptodeg,lV);
         //Print("j:%d, Ll:%d\n",j,strat->Ll);
         }
       }
       /* HERE we put (h, s*h) pairs */
       enterOnePairSelfShifts (h, h, ecart, isFromQ, strat, atR, uptodeg, lV);
     }
 
     if (new_pair)
     {
       strat->chainCrit(h,ecart,strat);
     }
 
   }
 }

void initHilbCrit	(	ideal	F,
		ideal	Q,
		intvec **	hilb,
		kStrategy	strat
	)

Definition at line 8072 of file kutil.cc.

 {
 
   //if the ordering is local, then hilb criterion
   //can be used also if the ideal is not homogenous
   if((rHasLocalOrMixedOrdering(currRing)) && (rHasMixedOrdering(currRing)==FALSE))
   #ifdef HAVE_RINGS
   {
   if(rField_is_Ring(currRing))
           *hilb=NULL;
   else
            return;
   }
 #endif
   if (strat->homog!=isHomog)
   {
     *hilb=NULL;
   }
 }

static LSet initL ( int nr = setmaxL )

inlinestatic

Definition at line 411 of file kutil.h.

412 { return (LSet)omAlloc(nr*sizeof(LObject)); }

LObject

class sLObject LObject

Definition: kutil.h:60

omAlloc

#define omAlloc(size)

Definition: omAllocDecl.h:210

LSet

LObject * LSet

Definition: kutil.h:62

KINLINE TObject** initR ( )

Definition at line 92 of file kInline.h.

 {
   return (TObject**) omAlloc0(setmaxT*sizeof(TObject*));
 }

void initS	(	ideal	F,
		ideal	Q,
		kStrategy	strat
	)

Definition at line 6383 of file kutil.cc.

 {
   int   i,pos;
 
   if (Q!=NULL) i=((IDELEMS(F)+IDELEMS(Q)+(setmaxTinc-1))/setmaxTinc)*setmaxTinc;
   else         i=((IDELEMS(F)+(setmaxTinc-1))/setmaxTinc)*setmaxTinc;
   strat->ecartS=initec(i);
   strat->sevS=initsevS(i);
   strat->S_2_R=initS_2_R(i);
   strat->fromQ=NULL;
   strat->Shdl=idInit(i,F->rank);
   strat->S=strat->Shdl->m;
   /*- put polys into S -*/
   if (Q!=NULL)
   {
     strat->fromQ=initec(i);
     memset(strat->fromQ,0,i*sizeof(int));
     for (i=0; i<IDELEMS(Q); i++)
     {
       if (Q->m[i]!=NULL)
       {
         LObject h;
         h.p = pCopy(Q->m[i]);
         if (TEST_OPT_INTSTRATEGY)
         {
           //pContent(h.p);
           h.pCleardenom(); // also does a pContent
         }
         else
         {
           h.pNorm();
         }
         if (rHasLocalOrMixedOrdering(currRing))
         {
           deleteHC(&h, strat);
         }
         if (h.p!=NULL)
         {
           strat->initEcart(&h);
           if (strat->sl==-1)
             pos =0;
           else
           {
             pos = posInS(strat,strat->sl,h.p,h.ecart);
           }
           h.sev = pGetShortExpVector(h.p);
           strat->enterS(h,pos,strat,-1);
           strat->fromQ[pos]=1;
         }
       }
     }
   }
   for (i=0; i<IDELEMS(F); i++)
   {
     if (F->m[i]!=NULL)
     {
       LObject h;
       h.p = pCopy(F->m[i]);
       if (rHasLocalOrMixedOrdering(currRing))
       {
                     /*#ifdef HAVE_RINGS
                           if (rField_is_Ring(currRing))
                             {
                             h.pCleardenom();
                             }
                           else
                                 #endif*/
         cancelunit(&h);  /*- tries to cancel a unit -*/
         deleteHC(&h, strat);
       }
       if (h.p!=NULL)
       // do not rely on the input being a SB!
       {
         if (TEST_OPT_INTSTRATEGY)
         {
           //pContent(h.p);
           h.pCleardenom(); // also does a pContent
         }
         else
         {
           h.pNorm();
         }
         strat->initEcart(&h);
         if (strat->sl==-1)
           pos =0;
         else
           pos = posInS(strat,strat->sl,h.p,h.ecart);
         h.sev = pGetShortExpVector(h.p);
         strat->enterS(h,pos,strat,-1);
       }
     }
   }
   /*- test, if a unit is in F -*/
   if ((strat->sl>=0)
 #ifdef HAVE_RINGS
        && n_IsUnit(pGetCoeff(strat->S[0]),currRing->cf)
 #endif
        && pIsConstant(strat->S[0]))
   {
     while (strat->sl>0) deleteInS(strat->sl,strat);
   }
 }

void initSba	(	ideal	F,
		kStrategy	strat
	)

Definition at line 1443 of file kstd1.cc.

 {
   int i;
   //idhdl h;
  /* setting global variables ------------------- */
   strat->enterS = enterSSba;
     strat->red2 = redHoney;
   if (strat->honey)
     strat->red2 = redHoney;
   else if (currRing->pLexOrder && !strat->homog)
     strat->red2 = redLazy;
   else
   {
     strat->LazyPass *=4;
     strat->red2 = redHomog;
   }
 #if defined(HAVE_RINGS)
   if (rField_is_Ring(currRing))
   {
     if(rHasLocalOrMixedOrdering(currRing))
       {strat->red = redRiloc;}
     else
       {strat->red2 = redRing;}
   }
 #endif
   if (currRing->pLexOrder && strat->honey)
     strat->initEcart = initEcartNormal;
   else
     strat->initEcart = initEcartBBA;
   if (strat->honey)
     strat->initEcartPair = initEcartPairMora;
   else
     strat->initEcartPair = initEcartPairBba;
   //strat->kIdeal = NULL;
   //if (strat->ak==0) strat->kIdeal->rtyp=IDEAL_CMD;
   //else              strat->kIdeal->rtyp=MODUL_CMD;
   //strat->kIdeal->data=(void *)strat->Shdl;
   if ((TEST_OPT_WEIGHTM)&&(F!=NULL))
   {
     //interred  machen   Aenderung
     strat->pOrigFDeg  = currRing->pFDeg;
     strat->pOrigLDeg  = currRing->pLDeg;
     //h=ggetid("ecart");
     //if ((h!=NULL) /*&& (IDTYP(h)==INTVEC_CMD)*/)
     //{
     //  ecartWeights=iv2array(IDINTVEC(h));
     //}
     //else
     {
       ecartWeights=(short *)omAlloc(((currRing->N)+1)*sizeof(short));
       /*uses automatic computation of the ecartWeights to set them*/
       kEcartWeights(F->m,IDELEMS(F)-1,ecartWeights, currRing);
     }
     pRestoreDegProcs(currRing, totaldegreeWecart, maxdegreeWecart);
     if (TEST_OPT_PROT)
     {
       for(i=1; i<=(currRing->N); i++)
         Print(" %d",ecartWeights[i]);
       PrintLn();
       mflush();
     }
   }
   // for sig-safe reductions in signature-based
   // standard basis computations
   strat->red          = redSig;
   //strat->sbaOrder  = 1;
   strat->currIdx      = 1;
 }

void initSbaBuchMora	(	ideal	F,
		ideal	Q,
		kStrategy	strat
	)

Definition at line 8535 of file kutil.cc.

 {
   strat->interpt = BTEST1(OPT_INTERRUPT);
   strat->kHEdge=NULL;
   if (rHasGlobalOrdering(currRing)) strat->kHEdgeFound=FALSE;
   /*- creating temp data structures------------------- -*/
   strat->cp = 0;
   strat->c3 = 0;
   strat->tail = pInit();
   /*- set s -*/
   strat->sl = -1;
   /*- set ps -*/
   strat->syzl = -1;
   /*- set L -*/
   strat->Lmax = ((IDELEMS(F)+setmaxLinc-1)/setmaxLinc)*setmaxLinc;
   strat->Ll = -1;
   strat->L = initL(((IDELEMS(F)+setmaxLinc-1)/setmaxLinc)*setmaxLinc);
   /*- set B -*/
   strat->Bmax = setmaxL;
   strat->Bl = -1;
   strat->B = initL();
   /*- set T -*/
   strat->tl = -1;
   strat->tmax = setmaxT;
   strat->T = initT();
   strat->R = initR();
   strat->sevT = initsevT();
   /*- init local data struct.---------------------------------------- -*/
   strat->P.ecart=0;
   strat->P.length=0;
   if (rHasLocalOrMixedOrdering(currRing))
   {
     if (strat->kHEdge!=NULL) pSetComp(strat->kHEdge, strat->ak);
     if (strat->kNoether!=NULL) pSetComp(strat->kNoetherTail(), strat->ak);
   }
   #ifdef HAVE_RINGS
   if(rField_is_Ring(currRing))
   {
     /*Shdl=*/initSLSba(F, Q,strat); /*sets also S, ecartS, fromQ */
   }
   else
   #endif
   {
     if(TEST_OPT_SB_1)
     {
         int i;
         ideal P=idInit(IDELEMS(F)-strat->newIdeal,F->rank);
         for (i=strat->newIdeal;i<IDELEMS(F);i++)
         {
           P->m[i-strat->newIdeal] = F->m[i];
           F->m[i] = NULL;
         }
         initSSpecialSba(F,Q,P,strat);
         for (i=strat->newIdeal;i<IDELEMS(F);i++)
         {
           F->m[i] = P->m[i-strat->newIdeal];
           P->m[i-strat->newIdeal] = NULL;
         }
         idDelete(&P);
     }
     else
     {
       /*Shdl=*/initSLSba(F, Q,strat); /*sets also S, ecartS, fromQ */
       // /*Shdl=*/initS(F, Q,strat); /*sets also S, ecartS, fromQ */
     }
   }
   strat->fromT = FALSE;
   if (!TEST_OPT_SB_1)
   {
     #ifdef HAVE_RINGS
     if(!rField_is_Ring(currRing))
     #endif
     updateS(TRUE,strat);
   }
   //if (strat->fromQ!=NULL) omFreeSize(strat->fromQ,IDELEMS(strat->Shdl)*sizeof(int));
   //strat->fromQ=NULL;
   assume(kTest_TS(strat));
 }

void initSbaCrit ( kStrategy strat )

Definition at line 8159 of file kutil.cc.

 {
   //strat->enterOnePair=enterOnePairNormal;
   strat->enterOnePair = enterOnePairNormal;
   //strat->chainCrit=chainCritNormal;
   strat->chainCrit    = chainCritSig;
   /******************************************
    * rewCrit1 and rewCrit2 are already set in
    * kSba() in kstd1.cc
    *****************************************/
   //strat->rewCrit1     = faugereRewCriterion;
   if (strat->sbaOrder == 1)
   {
     strat->syzCrit  = syzCriterionInc;
   }
   else
   {
     strat->syzCrit  = syzCriterion;
   }
 #ifdef HAVE_RINGS
   if (rField_is_Ring(currRing))
   {
     strat->enterOnePair=enterOnePairRing;
     strat->chainCrit=chainCritRing;
   }
 #endif
 #ifdef HAVE_RATGRING
   if (rIsRatGRing(currRing))
   {
      strat->chainCrit=chainCritPart;
      /* enterOnePairNormal get rational part in it */
   }
 #endif
 
   strat->sugarCrit =        TEST_OPT_SUGARCRIT;
   strat->Gebauer =          strat->homog || strat->sugarCrit;
   strat->honey =            !strat->homog || strat->sugarCrit || TEST_OPT_WEIGHTM;
   if (TEST_OPT_NOT_SUGAR) strat->honey = FALSE;
   strat->pairtest = NULL;
   /* alway use tailreduction, except:
   * - in local rings, - in lex order case, -in ring over extensions */
   strat->noTailReduction = !TEST_OPT_REDTAIL;
   if(rHasMixedOrdering(currRing)) strat->noTailReduction =TRUE;
 
 #ifdef HAVE_PLURAL
   // and r is plural_ring
   //  hence this holds for r a rational_plural_ring
   if( rIsPluralRing(currRing) || (rIsSCA(currRing) && !strat->z2homog) )
   {    //or it has non-quasi-comm type... later
     strat->sugarCrit = FALSE;
     strat->Gebauer = FALSE;
     strat->honey = FALSE;
   }
 #endif
 
 #ifdef HAVE_RINGS
   // Coefficient ring?
   if (rField_is_Ring(currRing))
   {
     strat->sugarCrit = FALSE;
     strat->Gebauer = FALSE ;
     strat->honey = FALSE;
   }
 #endif
   #ifdef KDEBUG
   if (TEST_OPT_DEBUG)
   {
     if (strat->homog) PrintS("ideal/module is homogeneous\n");
     else              PrintS("ideal/module is not homogeneous\n");
   }
   #endif
 }

void initSbaPos ( kStrategy strat )

Definition at line 8437 of file kutil.cc.

 {
   if (rHasGlobalOrdering(currRing))
   {
     if (strat->honey)
     {
       strat->posInL = posInL15;
       // ok -- here is the deal: from my experiments for Singular-2-0
       // I conclude that that posInT_EcartpLength is the best of
       // posInT15, posInT_EcartFDegpLength, posInT_FDegLength, posInT_pLength
       // see the table at the end of this file
       if (TEST_OPT_OLDSTD)
         strat->posInT = posInT15;
       else
         strat->posInT = posInT_EcartpLength;
     }
     else if (currRing->pLexOrder && !TEST_OPT_INTSTRATEGY)
     {
       strat->posInL = posInL11;
       strat->posInT = posInT11;
     }
     else if (TEST_OPT_INTSTRATEGY)
     {
       strat->posInL = posInL11;
       strat->posInT = posInT11;
     }
     else
     {
       strat->posInL = posInL0;
       strat->posInT = posInT0;
     }
     //if (strat->minim>0) strat->posInL =posInLSpecial;
     if (strat->homog)
     {
        strat->posInL = posInL110;
        strat->posInT = posInT110;
     }
   }
   else
   {
     if (strat->homog)
     {
       strat->posInL = posInL11;
       strat->posInT = posInT11;
     }
     else
     {
       if ((currRing->order[0]==ringorder_c)
       ||(currRing->order[0]==ringorder_C))
       {
         strat->posInL = posInL17_c;
         strat->posInT = posInT17_c;
       }
       else
       {
         strat->posInL = posInL17;
         strat->posInT = posInT17;
       }
     }
   }
   if (strat->minim>0) strat->posInL =posInLSpecial;
   // for further tests only
   if ((BTEST1(11)) || (BTEST1(12)))
     strat->posInL = posInL11;
   else if ((BTEST1(13)) || (BTEST1(14)))
     strat->posInL = posInL13;
   else if ((BTEST1(15)) || (BTEST1(16)))
     strat->posInL = posInL15;
   else if ((BTEST1(17)) || (BTEST1(18)))
     strat->posInL = posInL17;
   if (BTEST1(11))
     strat->posInT = posInT11;
   else if (BTEST1(13))
     strat->posInT = posInT13;
   else if (BTEST1(15))
     strat->posInT = posInT15;
   else if ((BTEST1(17)))
     strat->posInT = posInT17;
   else if ((BTEST1(19)))
     strat->posInT = posInT19;
   else if (BTEST1(12) || BTEST1(14) || BTEST1(16) || BTEST1(18))
     strat->posInT = posInT1;
 #ifdef HAVE_RINGS
   if (rField_is_Ring(currRing))
   {
     strat->posInL = posInL11Ring;
     if(rHasLocalOrMixedOrdering(currRing) && currRing->pLexOrder == TRUE)
       strat->posInL = posInL11Ringls;
     strat->posInT = posInT11;
   }
 #endif
   strat->posInLDependsOnLength = FALSE;
   strat->posInLSba  = posInLSig;
   //strat->posInL     = posInLSig;
   strat->posInL     = posInLF5C;
   //strat->posInT     = posInTSig;
 }

KINLINE unsigned long* initsevT ( )

Definition at line 97 of file kInline.h.

 {
   return (unsigned long*) omAlloc0(setmaxT*sizeof(unsigned long));
 }

void initSL	(	ideal	F,
		ideal	Q,
		kStrategy	strat
	)

Definition at line 6486 of file kutil.cc.

 {
   int   i,pos;
 
   if (Q!=NULL) i=((IDELEMS(Q)+(setmaxTinc-1))/setmaxTinc)*setmaxTinc;
   else i=setmaxT;
   strat->ecartS=initec(i);
   strat->sevS=initsevS(i);
   strat->S_2_R=initS_2_R(i);
   strat->fromQ=NULL;
   strat->Shdl=idInit(i,F->rank);
   strat->S=strat->Shdl->m;
   /*- put polys into S -*/
   if (Q!=NULL)
   {
     strat->fromQ=initec(i);
     memset(strat->fromQ,0,i*sizeof(int));
     for (i=0; i<IDELEMS(Q); i++)
     {
       if (Q->m[i]!=NULL)
       {
         LObject h;
         h.p = pCopy(Q->m[i]);
         if (rHasLocalOrMixedOrdering(currRing))
         {
           deleteHC(&h,strat);
         }
         if (TEST_OPT_INTSTRATEGY)
         {
           //pContent(h.p);
           h.pCleardenom(); // also does a pContent
         }
         else
         {
           h.pNorm();
         }
         if (h.p!=NULL)
         {
           strat->initEcart(&h);
           if (strat->sl==-1)
             pos =0;
           else
           {
             pos = posInS(strat,strat->sl,h.p,h.ecart);
           }
           h.sev = pGetShortExpVector(h.p);
           strat->enterS(h,pos,strat,-1);
           strat->fromQ[pos]=1;
         }
       }
     }
   }
   for (i=0; i<IDELEMS(F); i++)
   {
     if (F->m[i]!=NULL)
     {
       LObject h;
       h.p = pCopy(F->m[i]);
       if (h.p!=NULL)
       {
         if (rHasLocalOrMixedOrdering(currRing))
         {
           cancelunit(&h);  /*- tries to cancel a unit -*/
           deleteHC(&h, strat);
         }
         if (h.p!=NULL)
         {
           if (TEST_OPT_INTSTRATEGY)
           {
             //pContent(h.p);
             h.pCleardenom(); // also does a pContent
           }
           else
           {
             h.pNorm();
           }
           strat->initEcart(&h);
           if (strat->Ll==-1)
             pos =0;
           else
             pos = strat->posInL(strat->L,strat->Ll,&h,strat);
           h.sev = pGetShortExpVector(h.p);
           enterL(&strat->L,&strat->Ll,&strat->Lmax,h,pos);
         }
       }
     }
   }
   /*- test, if a unit is in F -*/
 
   if ((strat->Ll>=0)
 #ifdef HAVE_RINGS
        && n_IsUnit(pGetCoeff(strat->L[strat->Ll].p), currRing->cf)
 #endif
        && pIsConstant(strat->L[strat->Ll].p))
   {
     while (strat->Ll>0) deleteInL(strat->L,&strat->Ll,strat->Ll-1,strat);
   }
 }

void initSLSba	(	ideal	F,
		ideal	Q,
		kStrategy	strat
	)

Definition at line 6585 of file kutil.cc.

 {
   int   i,pos;
   if (Q!=NULL) i=((IDELEMS(Q)+(setmaxTinc-1))/setmaxTinc)*setmaxTinc;
   else i=setmaxT;
   strat->ecartS =   initec(i);
   strat->sevS   =   initsevS(i);
   strat->sevSig =   initsevS(i);
   strat->S_2_R  =   initS_2_R(i);
   strat->fromQ  =   NULL;
   strat->Shdl   =   idInit(i,F->rank);
   strat->S      =   strat->Shdl->m;
   strat->sig    =   (poly *)omAlloc0(i*sizeof(poly));
   if (strat->sbaOrder != 1)
   {
     strat->syz    = (poly *)omAlloc0(i*sizeof(poly));
     strat->sevSyz = initsevS(i);
     strat->syzmax = i;
     strat->syzl   = 0;
   }
   /*- put polys into S -*/
   if (Q!=NULL)
   {
     strat->fromQ=initec(i);
     memset(strat->fromQ,0,i*sizeof(int));
     for (i=0; i<IDELEMS(Q); i++)
     {
       if (Q->m[i]!=NULL)
       {
         LObject h;
         h.p = pCopy(Q->m[i]);
         if (rHasLocalOrMixedOrdering(currRing))
         {
           deleteHC(&h,strat);
         }
         if (TEST_OPT_INTSTRATEGY)
         {
           //pContent(h.p);
           h.pCleardenom(); // also does a pContent
         }
         else
         {
           h.pNorm();
         }
         if (h.p!=NULL)
         {
           strat->initEcart(&h);
           if (strat->sl==-1)
             pos =0;
           else
           {
             pos = posInS(strat,strat->sl,h.p,h.ecart);
           }
           h.sev = pGetShortExpVector(h.p);
           strat->enterS(h,pos,strat,-1);
           strat->fromQ[pos]=1;
         }
       }
     }
   }
   for (i=0; i<IDELEMS(F); i++)
   {
     if (F->m[i]!=NULL)
     {
       LObject h;
       h.p = pCopy(F->m[i]);
       h.sig = pOne();
       //h.sig = pInit();
       //p_SetCoeff(h.sig,nInit(1),currRing);
       p_SetComp(h.sig,i+1,currRing);
       // if we are working with the Schreyer order we generate it
       // by multiplying the initial signatures with the leading monomial
       // of the corresponding initial polynomials generating the ideal
       // => we can keep the underlying monomial order and get a Schreyer
       //    order without any bigger overhead
       if (strat->sbaOrder == 0 || strat->sbaOrder == 3)
       {
         p_ExpVectorAdd (h.sig,F->m[i],currRing);
       }
       h.sevSig = pGetShortExpVector(h.sig);
 #ifdef DEBUGF5
       pWrite(h.p);
       pWrite(h.sig);
 #endif
       if (h.p!=NULL)
       {
         if (rHasLocalOrMixedOrdering(currRing))
         {
           cancelunit(&h);  /*- tries to cancel a unit -*/
           deleteHC(&h, strat);
         }
         if (h.p!=NULL)
         {
           if (TEST_OPT_INTSTRATEGY)
           {
             //pContent(h.p);
             h.pCleardenom(); // also does a pContent
           }
           else
           {
             h.pNorm();
           }
           strat->initEcart(&h);
           if (strat->Ll==-1)
             pos =0;
           else
             pos = strat->posInLSba(strat->L,strat->Ll,&h,strat);
           h.sev = pGetShortExpVector(h.p);
           enterL(&strat->L,&strat->Ll,&strat->Lmax,h,pos);
         }
       }
       /*
       if (strat->sbaOrder != 1)
       {
         for(j=0;j<i;j++)
         {
           strat->syz[ctr] = pCopy(F->m[j]);
           p_SetCompP(strat->syz[ctr],i+1,currRing);
           // add LM(F->m[i]) to the signature to get a Schreyer order
           // without changing the underlying polynomial ring at all
           p_ExpVectorAdd (strat->syz[ctr],F->m[i],currRing);
           // since p_Add_q() destroys all input
           // data we need to recreate help
           // each time
           poly help = pCopy(F->m[i]);
           p_SetCompP(help,j+1,currRing);
           pWrite(strat->syz[ctr]);
           pWrite(help);
           printf("%d\n",pLmCmp(strat->syz[ctr],help));
           strat->syz[ctr] = p_Add_q(strat->syz[ctr],help,currRing);
           printf("%d. SYZ  ",ctr);
           pWrite(strat->syz[ctr]);
           strat->sevSyz[ctr] = p_GetShortExpVector(strat->syz[ctr],currRing);
           ctr++;
         }
         strat->syzl = ps;
       }
       */
     }
   }
   /*- test, if a unit is in F -*/
 
   if ((strat->Ll>=0)
 #ifdef HAVE_RINGS
        && n_IsUnit(pGetCoeff(strat->L[strat->Ll].p), currRing->cf)
 #endif
        && pIsConstant(strat->L[strat->Ll].p))
   {
     while (strat->Ll>0) deleteInL(strat->L,&strat->Ll,strat->Ll-1,strat);
   }
 }

void initSyzRules ( kStrategy strat )

Definition at line 6737 of file kutil.cc.

 {
   if( strat->S[0] )
   {
     if( strat->S[1] )
     {
       omFreeSize(strat->syzIdx,(strat->syzidxmax)*sizeof(int));
       omFreeSize(strat->sevSyz,(strat->syzmax)*sizeof(unsigned long));
       omFreeSize(strat->syz,(strat->syzmax)*sizeof(poly));
     }
     int i, j, k, diff, comp, comp_old, ps=0, ctr=0;
     /************************************************************
      * computing the length of the syzygy array needed
      ***********************************************************/
     for(i=1; i<=strat->sl; i++)
     {
       if (pGetComp(strat->sig[i-1]) != pGetComp(strat->sig[i]))
       {
         ps += i;
       }
     }
     ps += strat->sl+1;
     //comp              = pGetComp (strat->P.sig);
     comp              = strat->currIdx;
     strat->syzIdx     = initec(comp);
     strat->sevSyz     = initsevS(ps);
     strat->syz        = (poly *)omAlloc(ps*sizeof(poly));
     strat->syzmax     = ps;
     strat->syzl       = 0;
     strat->syzidxmax  = comp;
 #if defined(DEBUGF5) || defined(DEBUGF51)
     PrintS("------------- GENERATING SYZ RULES NEW ---------------\n");
 #endif
     i = 1;
     j = 0;
     /************************************************************
      * generating the leading terms of the principal syzygies
      ***********************************************************/
     while (i <= strat->sl)
     {
       /**********************************************************
        * principal syzygies start with component index 2
        * the array syzIdx starts with index 0
        * => the rules for a signature with component comp start
        *    at strat->syz[strat->syzIdx[comp-2]] !
        *********************************************************/
       if (pGetComp(strat->sig[i-1]) != pGetComp(strat->sig[i]))
       {
         comp      = pGetComp(strat->sig[i]);
         comp_old  = pGetComp(strat->sig[i-1]);
         diff      = comp - comp_old - 1;
         // diff should be zero, but sometimes also the initial generating
         // elements of the input ideal reduce to zero. then there is an
         // index-gap between the signatures. for these inbetween signatures we
         // can safely set syzIdx[j] = 0 as no such element will be ever computed
         // in the following.
         // doing this, we keep the relation "j = comp - 2" alive, which makes
         // jumps way easier when checking criteria
         while (diff>0)
         {
           strat->syzIdx[j]  = 0;
           diff--;
           j++;
         }
         strat->syzIdx[j]  = ctr;
         j++;
         LObject Q;
         int pos;
         for (k = 0; k<i; k++)
         {
           Q.sig          = pOne();
           p_ExpVectorCopy(Q.sig,strat->S[k],currRing);
           p_SetCompP (Q.sig, comp, currRing);
           poly q          = p_One(currRing);
           p_ExpVectorCopy(q,strat->S[i],currRing);
           q               = p_Neg (q, currRing);
           p_SetCompP (q, p_GetComp(strat->sig[k], currRing), currRing);
           Q.sig = p_Add_q (Q.sig, q, currRing);
           Q.sevSig  = p_GetShortExpVector(Q.sig,currRing);
           pos = posInSyz(strat, Q.sig);
           enterSyz(Q, strat, pos);
           ctr++;
         }
       }
       i++;
     }
     /**************************************************************
     * add syzygies for upcoming first element of new iteration step
     **************************************************************/
     comp      = strat->currIdx;
     comp_old  = pGetComp(strat->sig[i-1]);
     diff      = comp - comp_old - 1;
     // diff should be zero, but sometimes also the initial generating
     // elements of the input ideal reduce to zero. then there is an
     // index-gap between the signatures. for these inbetween signatures we
     // can safely set syzIdx[j] = 0 as no such element will be ever computed
     // in the following.
     // doing this, we keep the relation "j = comp - 2" alive, which makes
     // jumps way easier when checking criteria
     while (diff>0)
     {
       strat->syzIdx[j]  = 0;
       diff--;
       j++;
     }
     strat->syzIdx[j]  = ctr;
     LObject Q;
     int pos;
     for (k = 0; k<strat->sl+1; k++)
     {
       Q.sig          = pOne();
       p_ExpVectorCopy(Q.sig,strat->S[k],currRing);
       p_SetCompP (Q.sig, comp, currRing);
       poly q          = p_One(currRing);
       p_ExpVectorCopy(q,strat->L[strat->Ll].p,currRing);
       q               = p_Neg (q, currRing);
       p_SetCompP (q, p_GetComp(strat->sig[k], currRing), currRing);
       Q.sig = p_Add_q (Q.sig, q, currRing);
       Q.sevSig = p_GetShortExpVector(Q.sig,currRing);
       pos = posInSyz(strat, Q.sig);
       enterSyz(Q, strat, pos);
       ctr++;
     }
 //#if 1
 #ifdef DEBUGF5
     PrintS("Principal syzygies:\n");
     Print("syzl   %d\n",strat->syzl);
     Print("syzmax %d\n",strat->syzmax);
     Print("ps     %d\n",ps);
     PrintS("--------------------------------\n");
     for(i=0;i<=strat->syzl-1;i++)
     {
       Print("%d - ",i);
       pWrite(strat->syz[i]);
     }
     for(i=0;i<strat->currIdx;i++)
     {
       Print("%d - %d\n",i,strat->syzIdx[i]);
     }
     PrintS("--------------------------------\n");
 #endif
   }
 }

KINLINE TSet initT ( )

Definition at line 81 of file kInline.h.

 {
   TSet T = (TSet)omAlloc0(setmaxT*sizeof(TObject));
   for (int i=setmaxT-1; i>=0; i--)
   {
     T[i].tailRing = currRing;
     T[i].i_r = -1;
   }
   return T;
 }

KINLINE BOOLEAN k_GetLeadTerms	(	const poly	p1,
		const poly	p2,
		const ring	p_r,
		poly &	m1,
		poly &	m2,
		const ring	m_r
	)

Definition at line 964 of file kInline.h.

 {
   p_LmCheckPolyRing(p1, p_r);
   p_LmCheckPolyRing(p2, p_r);
 
   int i;
   long x;
   m1 = p_Init(m_r);
   m2 = p_Init(m_r);
 
   for (i = p_r->N; i; i--)
   {
     x = p_GetExpDiff(p1, p2, i, p_r);
     if (x > 0)
     {
       if (x > (long) m_r->bitmask) goto false_return;
       p_SetExp(m2,i,x, m_r);
       p_SetExp(m1,i,0, m_r);
     }
     else
     {
       if (-x > (long) m_r->bitmask) goto false_return;
       p_SetExp(m1,i,-x, m_r);
       p_SetExp(m2,i,0, m_r);
     }
   }
 
   p_Setm(m1, m_r);
   p_Setm(m2, m_r);
   return TRUE;
 
   false_return:
   p_LmFree(m1, m_r);
   p_LmFree(m2, m_r);
   m1 = m2 = NULL;
   return FALSE;
 }

KINLINE void k_GetStrongLeadTerms	(	const poly	p1,
		const poly	p2,
		const ring	leadRing,
		poly &	m1,
		poly &	m2,
		poly &	lcm,
		const ring	taiRing
	)

Definition at line 1007 of file kInline.h.

 {
   p_LmCheckPolyRing(p1, leadRing);
   p_LmCheckPolyRing(p2, leadRing);
 
   int i;
   int x;
   int e1;
   int e2;
   int s;
   m1 = p_Init(tailRing);
   m2 = p_Init(tailRing);
   lcm = p_Init(leadRing);
 
   for (i = leadRing->N; i>=0; i--)
   {
     e1 = p_GetExp(p1,i,leadRing);
     e2 = p_GetExp(p2,i,leadRing);
     x = e1 - e2;
     if (x > 0)
     {
       p_SetExp(m2,i,x, tailRing);
       //p_SetExp(m1,i,0, tailRing); // done by p_Init
       s = e1;
     }
     else if (x<0)
     {
       p_SetExp(m1,i,-x, tailRing);
       //p_SetExp(m2,i,0, tailRing); // done by p_Init
       s = e2;
     }
     else
       s = e1; // e1==e2
     p_SetExp(lcm,i,s, leadRing);
   }
 
   p_Setm(m1, tailRing);
   p_Setm(m2, tailRing);
   p_Setm(lcm, leadRing);
 }

KINLINE poly k_LmInit_currRing_2_tailRing	(	poly	p,
		ring	tailRing,
		omBin	bin
	)

Definition at line 905 of file kInline.h.

 {
 
   poly np = p_LmInit(p, currRing, tailRing, tailBin);
   pNext(np) = pNext(p);
   pSetCoeff0(np, pGetCoeff(p));
   return np;
 }

KINLINE poly k_LmInit_currRing_2_tailRing	(	poly	p,
		ring	tailRing
	)

Definition at line 937 of file kInline.h.

 {
   return k_LmInit_currRing_2_tailRing(p, tailRing, tailRing->PolyBin);
 }

KINLINE poly k_LmInit_tailRing_2_currRing	(	poly	p,
		ring	tailRing,
		omBin	bin
	)

Definition at line 914 of file kInline.h.

 {
   poly np = p_LmInit(p, tailRing, currRing, lmBin);
   pNext(np) = pNext(p);
   pSetCoeff0(np, pGetCoeff(p));
   return np;
 }

KINLINE poly k_LmInit_tailRing_2_currRing	(	poly	p,
		ring	tailRing
	)

Definition at line 942 of file kInline.h.

 {
   return  k_LmInit_tailRing_2_currRing(p, tailRing, currRing->PolyBin);
 }

KINLINE poly k_LmShallowCopyDelete_currRing_2_tailRing	(	poly	p,
		ring	tailRing,
		omBin	bin
	)

Definition at line 923 of file kInline.h.

 {
   poly np = k_LmInit_currRing_2_tailRing(p, tailRing, tailBin);
   p_LmFree(p, currRing);
   return np;
 }

KINLINE poly k_LmShallowCopyDelete_currRing_2_tailRing	(	poly	p,
		ring	tailRing
	)

Definition at line 947 of file kInline.h.

 {
   return k_LmShallowCopyDelete_currRing_2_tailRing(p, tailRing, tailRing->PolyBin);
 }

KINLINE poly k_LmShallowCopyDelete_tailRing_2_currRing	(	poly	p,
		ring	tailRing,
		omBin	bin
	)

Definition at line 930 of file kInline.h.

 {
   poly np = k_LmInit_tailRing_2_currRing(p, tailRing, lmBin);
   p_LmFree(p, tailRing);
   return np;
 }

KINLINE poly k_LmShallowCopyDelete_tailRing_2_currRing	(	poly	p,
		ring	tailRing
	)

Definition at line 952 of file kInline.h.

 {
   return  k_LmShallowCopyDelete_tailRing_2_currRing(p, tailRing, currRing->PolyBin);
 }

BOOLEAN kCheckSpolyCreation	(	LObject *	L,
		kStrategy	strat,
		poly &	m1,
		poly &	m2
	)

Definition at line 8994 of file kutil.cc.

 {
   if (strat->overflow) return FALSE;
   assume(L->p1 != NULL && L->p2 != NULL);
   // shift changes: from 0 to -1
   assume(L->i_r1 >= -1 && L->i_r1 <= strat->tl);
   assume(L->i_r2 >= -1 && L->i_r2 <= strat->tl);
   assume(strat->tailRing != currRing);
 
   if (! k_GetLeadTerms(L->p1, L->p2, currRing, m1, m2, strat->tailRing))
     return FALSE;
   // shift changes: extra case inserted
   if ((L->i_r1 == -1) || (L->i_r2 == -1) )
   {
     return TRUE;
   }
   poly p1_max = (strat->R[L->i_r1])->max;
   poly p2_max = (strat->R[L->i_r2])->max;
 
   if (((p1_max != NULL) && !p_LmExpVectorAddIsOk(m1, p1_max, strat->tailRing)) ||
       ((p2_max != NULL) && !p_LmExpVectorAddIsOk(m2, p2_max, strat->tailRing)))
   {
     p_LmFree(m1, strat->tailRing);
     p_LmFree(m2, strat->tailRing);
     m1 = NULL;
     m2 = NULL;
     return FALSE;
   }
   return TRUE;
 }

BOOLEAN kCheckStrongCreation	(	int	atR,
		poly	m1,
		int	atS,
		poly	m2,
		kStrategy	strat
	)

Definition at line 9032 of file kutil.cc.

 {
   assume(strat->S_2_R[atS] >= -1 && strat->S_2_R[atS] <= strat->tl);
   //assume(strat->tailRing != currRing);
 
   poly p1_max = (strat->R[atR])->max;
   poly p2_max = (strat->R[strat->S_2_R[atS]])->max;
 
   if (((p1_max != NULL) && !p_LmExpVectorAddIsOk(m1, p1_max, strat->tailRing)) ||
       ((p2_max != NULL) && !p_LmExpVectorAddIsOk(m2, p2_max, strat->tailRing)))
   {
     return FALSE;
   }
   return TRUE;
 }

poly kCreateZeroPoly	(	long	exp[],
		long	cabsind,
		poly *	t_p,
		ring	leadRing,
		ring	tailRing
	)

Definition at line 3558 of file kutil.cc.

 {
 
   poly zeroPoly = NULL;
 
   number tmp1;
   poly tmp2, tmp3;
 
   if (cabsind == -1)
   {
     cabsind = 0;
     for (int i = 1; i <= leadRing->N; i++)
     {
       cabsind += ind_fact_2(exp[i]);
     }
 //    Print("cabsind: %d\n", cabsind);
   }
   if (cabsind < leadRing->ch)
   {
     zeroPoly = p_ISet(twoPow(leadRing->ch - cabsind), tailRing);
   }
   else
   {
     zeroPoly = p_ISet(1, tailRing);
   }
   for (int i = 1; i <= leadRing->N; i++)
   {
     for (long j = 1; j <= exp[i]; j++)
     {
       tmp1 = nInit(j);
       tmp2 = p_ISet(1, tailRing);
       p_SetExp(tmp2, i, 1, tailRing);
       p_Setm(tmp2, tailRing);
       if (nIsZero(tmp1))
       { // should nowbe obsolet, test ! TODO OLIVER
         zeroPoly = p_Mult_q(zeroPoly, tmp2, tailRing);
       }
       else
       {
         tmp3 = p_NSet(nCopy(tmp1), tailRing);
         zeroPoly = p_Mult_q(zeroPoly, p_Add_q(tmp3, tmp2, tailRing), tailRing);
       }
     }
   }
   tmp2 = p_NSet(nCopy(pGetCoeff(zeroPoly)), leadRing);
   for (int i = 1; i <= leadRing->N; i++)
   {
     pSetExp(tmp2, i, p_GetExp(zeroPoly, i, tailRing));
   }
   p_Setm(tmp2, leadRing);
   *t_p = zeroPoly;
   zeroPoly = pNext(zeroPoly);
   pNext(*t_p) = NULL;
   pNext(tmp2) = zeroPoly;
   return tmp2;
 }

void kDebugPrint ( kStrategy strat )

Output some debug info about a given strategy.

Definition at line 9907 of file kutil.cc.

 {
   PrintS("red: ");
     if (strat->red==redFirst) PrintS("redFirst\n");
     else if (strat->red==redHoney) PrintS("redHoney\n");
     else if (strat->red==redEcart) PrintS("redEcart\n");
     else if (strat->red==redHomog) PrintS("redHomog\n");
     else  Print("%p\n",(void*)strat->red);
   PrintS("posInT: ");
     if (strat->posInT==posInT0) PrintS("posInT0\n");
     else if (strat->posInT==posInT1) PrintS("posInT1\n");
     else if (strat->posInT==posInT11) PrintS("posInT11\n");
     else if (strat->posInT==posInT110) PrintS("posInT110\n");
     else if (strat->posInT==posInT13) PrintS("posInT13\n");
     else if (strat->posInT==posInT15) PrintS("posInT15\n");
     else if (strat->posInT==posInT17) PrintS("posInT17\n");
     else if (strat->posInT==posInT17_c) PrintS("posInT17_c\n");
     else if (strat->posInT==posInT19) PrintS("posInT19\n");
     else if (strat->posInT==posInT2) PrintS("posInT2\n");
 #ifdef HAVE_MORE_POS_IN_T
     else if (strat->posInT==posInT_EcartFDegpLength) PrintS("posInT_EcartFDegpLength\n");
     else if (strat->posInT==posInT_FDegpLength) PrintS("posInT_FDegpLength\n");
     else if (strat->posInT==posInT_pLength) PrintS("posInT_pLength\n");
 #endif
     else if (strat->posInT==posInT_EcartpLength) PrintS("posInT_EcartpLength\n");
     else if (strat->posInT==posInTrg0) PrintS("posInTrg0\n");
     else  Print("%p\n",(void*)strat->posInT);
   PrintS("posInL: ");
     if (strat->posInL==posInL0) PrintS("posInL0\n");
     else if (strat->posInL==posInL10) PrintS("posInL10\n");
     else if (strat->posInL==posInL11) PrintS("posInL11\n");
     else if (strat->posInL==posInL110) PrintS("posInL110\n");
     else if (strat->posInL==posInL13) PrintS("posInL13\n");
     else if (strat->posInL==posInL15) PrintS("posInL15\n");
     else if (strat->posInL==posInL17) PrintS("posInL17\n");
     else if (strat->posInL==posInL17_c) PrintS("posInL17_c\n");
     else if (strat->posInL==posInLSpecial) PrintS("posInLSpecial\n");
     else if (strat->posInL==posInLrg0) PrintS("posInLrg0\n");
     else  Print("%p\n",(void*)strat->posInL);
   PrintS("enterS: ");
     if (strat->enterS==enterSBba) PrintS("enterSBba\n");
     else if (strat->enterS==enterSMora) PrintS("enterSMora\n");
     else if (strat->enterS==enterSMoraNF) PrintS("enterSMoraNF\n");
     else  Print("%p\n",(void*)strat->enterS);
   PrintS("initEcart: ");
     if (strat->initEcart==initEcartBBA) PrintS("initEcartBBA\n");
     else if (strat->initEcart==initEcartNormal) PrintS("initEcartNormal\n");
     else  Print("%p\n",(void*)strat->initEcart);
   PrintS("initEcartPair: ");
     if (strat->initEcartPair==initEcartPairBba) PrintS("initEcartPairBba\n");
     else if (strat->initEcartPair==initEcartPairMora) PrintS("initEcartPairMora\n");
     else  Print("%p\n",(void*)strat->initEcartPair);
   Print("homog=%d, LazyDegree=%d, LazyPass=%d, ak=%d,\n",
     strat->homog, strat->LazyDegree,strat->LazyPass, strat->ak);
   Print("honey=%d, sugarCrit=%d, Gebauer=%d, noTailReduction=%d, use_buckets=%d\n",
     strat->honey,strat->sugarCrit,strat->Gebauer,strat->noTailReduction,strat->use_buckets);
   PrintS("chainCrit: ");
     if (strat->chainCrit==chainCritNormal) PrintS("chainCritNormal\n");
     else if (strat->chainCrit==chainCritOpt_1) PrintS("chainCritOpt_1\n");
     else  Print("%p\n",(void*)strat->chainCrit);
   Print("posInLDependsOnLength=%d\n",
          strat->posInLDependsOnLength);
   PrintS(showOption());PrintLn();
   PrintS("LDeg: ");
     if (currRing->pLDeg==pLDeg0) PrintS("pLDeg0");
     else if (currRing->pLDeg==pLDeg0c) PrintS("pLDeg0c");
     else if (currRing->pLDeg==pLDegb) PrintS("pLDegb");
     else if (currRing->pLDeg==pLDeg1) PrintS("pLDeg1");
     else if (currRing->pLDeg==pLDeg1c) PrintS("pLDeg1c");
     else if (currRing->pLDeg==pLDeg1_Deg) PrintS("pLDeg1_Deg");
     else if (currRing->pLDeg==pLDeg1c_Deg) PrintS("pLDeg1c_Deg");
     else if (currRing->pLDeg==pLDeg1_Totaldegree) PrintS("pLDeg1_Totaldegree");
     else if (currRing->pLDeg==pLDeg1c_Totaldegree) PrintS("pLDeg1c_Totaldegree");
     else if (currRing->pLDeg==pLDeg1_WFirstTotalDegree) PrintS("pLDeg1_WFirstTotalDegree");
     else if (currRing->pLDeg==pLDeg1c_WFirstTotalDegree) PrintS("pLDeg1c_WFirstTotalDegree");
     else if (currRing->pLDeg==maxdegreeWecart) PrintS("maxdegreeWecart");
     else Print("? (%lx)", (long)currRing->pLDeg);
     PrintS(" / ");
     if (strat->tailRing->pLDeg==pLDeg0) PrintS("pLDeg0");
     else if (strat->tailRing->pLDeg==pLDeg0c) PrintS("pLDeg0c");
     else if (strat->tailRing->pLDeg==pLDegb) PrintS("pLDegb");
     else if (strat->tailRing->pLDeg==pLDeg1) PrintS("pLDeg1");
     else if (strat->tailRing->pLDeg==pLDeg1c) PrintS("pLDeg1c");
     else if (strat->tailRing->pLDeg==pLDeg1_Deg) PrintS("pLDeg1_Deg");
     else if (strat->tailRing->pLDeg==pLDeg1c_Deg) PrintS("pLDeg1c_Deg");
     else if (strat->tailRing->pLDeg==pLDeg1_Totaldegree) PrintS("pLDeg1_Totaldegree");
     else if (strat->tailRing->pLDeg==pLDeg1c_Totaldegree) PrintS("pLDeg1c_Totaldegree");
     else if (strat->tailRing->pLDeg==pLDeg1_WFirstTotalDegree) PrintS("pLDeg1_WFirstTotalDegree");
     else if (strat->tailRing->pLDeg==pLDeg1c_WFirstTotalDegree) PrintS("pLDeg1c_WFirstTotalDegree");
     else if (strat->tailRing->pLDeg==maxdegreeWecart) PrintS("maxdegreeWecart");
     else Print("? (%lx)", (long)strat->tailRing->pLDeg);
     PrintLn();
   PrintS("currRing->pFDeg: ");
     if (currRing->pFDeg==p_Totaldegree) PrintS("p_Totaldegree");
     else if (currRing->pFDeg==p_WFirstTotalDegree) PrintS("pWFirstTotalDegree");
     else if (currRing->pFDeg==p_Deg) PrintS("p_Deg");
     else if (currRing->pFDeg==kHomModDeg) PrintS("kHomModDeg");
     else if (currRing->pFDeg==totaldegreeWecart) PrintS("totaldegreeWecart");
     else if (currRing->pFDeg==p_WTotaldegree) PrintS("p_WTotaldegree");
     else Print("? (%lx)", (long)currRing->pFDeg);
     PrintLn();
     Print(" syzring:%d, syzComp(strat):%d limit:%d\n",rIsSyzIndexRing(currRing),strat->syzComp,rGetCurrSyzLimit(currRing));
     if(TEST_OPT_DEGBOUND)
       Print(" degBound: %d\n", Kstd1_deg);
 
     if( ecartWeights != NULL )
     {
        PrintS("ecartWeights: ");
        for (int i = rVar(currRing); i > 0; i--)
          Print("%hd ", ecartWeights[i]);
        PrintLn();
        assume( TEST_OPT_WEIGHTM );
     }
 
 #ifndef SING_NDEBUG
     rDebugPrint(currRing);
 #endif
 }

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 at line 202 of file kstd2.cc.

 {
   unsigned long not_sev = ~L->sev;
   poly p = L->GetLmCurrRing();
   int j = 0;
 
   pAssume(~not_sev == p_GetShortExpVector(p, currRing));
 #if 1
   int ende;
   if ((strat->ak>0) || currRing->pLexOrder) ende=strat->sl;
   else ende=posInS(strat,*max_ind,p,0)+1;
   if (ende>(*max_ind)) ende=(*max_ind);
 #else
   int ende=strat->sl;
 #endif
   (*max_ind)=ende;
   loop
   {
     if (j > ende) return -1;
 #if defined(PDEBUG) || defined(PDIV_DEBUG)
     if (p_LmShortDivisibleBy(strat->S[j], strat->sevS[j],
                              p, not_sev, currRing))
         {
 #ifdef HAVE_RINGS
             if(rField_is_Ring(currRing))
                 {if(n_DivBy(pGetCoeff(p), pGetCoeff(strat->S[j]), currRing))
                     return j;}
             else
 #endif
             return j;
         }
 #else
     if ( !(strat->sevS[j] & not_sev) &&
          p_LmDivisibleBy(strat->S[j], p, currRing))
         {
 #ifdef HAVE_RINGS
             if(rField_is_Ring(currRing))
                 {if(n_DivBy(pGetCoeff(p), pGetCoeff(strat->S[j]), currRing))
                     return j;}
             else
 #endif
             return j;
         }
 #endif
     j++;
   }
 }

TObject* kFindDivisibleByInS	(	kStrategy	strat,
		int	pos,
		LObject *	L,
		TObject *	T,
		long	ecart = `LONG_MAX`
	)

Definition at line 5872 of file kutil.cc.

 {
   int j = 0;
   const unsigned long not_sev = ~L->sev;
   const unsigned long* sev = strat->sevS;
   poly p;
   ring r;
   L->GetLm(p, r);
 
   assume(~not_sev == p_GetShortExpVector(p, r));
 
   if (r == currRing)
   {
     loop
     {
       if (j > pos) return NULL;
 #if defined(PDEBUG) || defined(PDIV_DEBUG)
       if (strat->S[j]!= NULL && p_LmShortDivisibleBy(strat->S[j], sev[j], p, not_sev, r) &&
           (ecart== LONG_MAX || ecart>= strat->ecartS[j]))
         {
 #ifdef HAVE_RINGS
             if(rField_is_Ring(r))
                 {if(n_DivBy(pGetCoeff(p), pGetCoeff(strat->S[j]), r))
                      break;}
             else
 #endif
             break;
         }
 #else
       if (!(sev[j] & not_sev) &&
           (ecart== LONG_MAX || ecart>= strat->ecartS[j]) &&
           p_LmDivisibleBy(strat->S[j], p, r))
         {
 #ifdef HAVE_RINGS
             if(rField_is_Ring(r))
                 {if(n_DivBy(pGetCoeff(p), pGetCoeff(strat->S[j]), r))
                     break;}
             else
 #endif
             break;
         }
 
 #endif
       j++;
     }
     // if called from NF, T objects do not exist:
     if (strat->tl < 0 || strat->S_2_R[j] == -1)
     {
       T->Set(strat->S[j], r, strat->tailRing);
       return T;
     }
     else
     {
 /////      assume (j >= 0 && j <= strat->tl && strat->S_2_T(j) != NULL
 /////      && strat->S_2_T(j)->p == strat->S[j]); // wrong?
 //      assume (j >= 0 && j <= strat->sl && strat->S_2_T(j) != NULL && strat->S_2_T(j)->p == strat->S[j]);
       return strat->S_2_T(j);
     }
   }
   else
   {
     TObject* t;
     loop
     {
       if (j > pos) return NULL;
       assume(strat->S_2_R[j] != -1);
 #if defined(PDEBUG) || defined(PDIV_DEBUG)
       t = strat->S_2_T(j);
       assume(t != NULL && t->t_p != NULL && t->tailRing == r);
       if (p_LmShortDivisibleBy(t->t_p, sev[j], p, not_sev, r) &&
           (ecart== LONG_MAX || ecart>= strat->ecartS[j]))
         {
 #ifdef HAVE_RINGS
             if(rField_is_Ring(r))
                 {if(n_DivBy(pGetCoeff(p), pGetCoeff(t->t_p), r))
                     return t;}
             else
 #endif
             return t;
         }
 #else
       if (! (sev[j] & not_sev) && (ecart== LONG_MAX || ecart>= strat->ecartS[j]))
       {
         t = strat->S_2_T(j);
         assume(t != NULL && t->t_p != NULL && t->tailRing == r && t->p == strat->S[j]);
         if (p_LmDivisibleBy(t->t_p, p, r))
         {
 #ifdef HAVE_RINGS
             if(rField_is_Ring(r))
                 {if(n_DivBy(pGetCoeff(p), pGetCoeff(t->t_p), r))
                     return t;}
             else
 #endif
             return t;
         }
       }
 #endif
       j++;
     }
   }
 }

int kFindDivisibleByInT	(	const kStrategy	strat,
		const LObject *	L,
		const int	start = `0`
	)

return -1 if no divisor is found number of first divisor in T, otherwise

Definition at line 104 of file kstd2.cc.

 {
   unsigned long not_sev = ~L->sev;
   int j = start;
 
   const TSet T=strat->T;
   const unsigned long* sevT=strat->sevT;
   if (L->p!=NULL)
   {
     const ring r=currRing;
     const poly p=L->p;
 
     pAssume(~not_sev == p_GetShortExpVector(p, r));
 
     loop
     {
       if (j > strat->tl) return -1;
 #if defined(PDEBUG) || defined(PDIV_DEBUG)
       if (p_LmShortDivisibleBy(T[j].p, sevT[j],p, not_sev, r))
         {
 #ifdef HAVE_RINGS
             if(rField_is_Ring(r))
                 {if(n_DivBy(pGetCoeff(p), pGetCoeff(T[j].p), r))
                     return j;}
             else {
                 return j;
                 }
 #else
             return j;
 #endif
 
         }
 #else
       if (!(sevT[j] & not_sev) &&
           p_LmDivisibleBy(T[j].p, p, r))
         {
 #ifdef HAVE_RINGS
             if(rField_is_Ring(r))
                 {if(n_DivBy(pGetCoeff(p), pGetCoeff(T[j].p), r))
                     return j;}
             else {
                 return j;
                 }
 #else
             return j;
 #endif
 
         }
 #endif
       j++;
     }
   }
   else
   {
     const poly p=L->t_p;
     const ring r=strat->tailRing;
     loop
     {
       if (j > strat->tl) return -1;
 #if defined(PDEBUG) || defined(PDIV_DEBUG)
       if (p_LmShortDivisibleBy(T[j].t_p, sevT[j],
                                p, not_sev, r))
         {
 #ifdef HAVE_RINGS
             if(rField_is_Ring(r))
                 {if(n_DivBy(pGetCoeff(p), pGetCoeff(T[j].t_p), r))
                     return j;}
             else {
                 return j;
             }
 #else
             return j;
 #endif
 
         }
 #else
       if (!(sevT[j] & not_sev) &&
           p_LmDivisibleBy(T[j].t_p, p, r))
         {
 #ifdef HAVE_RINGS
             if(rField_is_Ring(r))
                 {if(n_DivBy(pGetCoeff(p), pGetCoeff(T[j].t_p), r))
                     return j;}
             else {
                 return j;
             }
 #else
             return j;
 #endif
 
         }
 #endif
       j++;
     }
   }
 }

int kFindInT	(	poly	p,
		TSet	T,
		int	tlength
	)

returns index of p in TSet, or -1 if not found

Definition at line 617 of file kutil.cc.

 {
   int i;
 
   for (i=0; i<=tlength; i++)
   {
     if (T[i].p == p) return i;
   }
   return -1;
 }

int kFindNextDivisibleByInS	(	const kStrategy	strat,
		int	start,
		int	max_ind,
		LObject *	L
	)

Definition at line 250 of file kstd2.cc.

 {
   unsigned long not_sev = ~L->sev;
   poly p = L->GetLmCurrRing();
   int j = start;
 
   pAssume(~not_sev == p_GetShortExpVector(p, currRing));
 #if 1
   int ende=max_ind;
 #else
   int ende=strat->sl;
 #endif
   loop
   {
     if (j > ende) return -1;
 #if defined(PDEBUG) || defined(PDIV_DEBUG)
     if (p_LmShortDivisibleBy(strat->S[j], strat->sevS[j],
                              p, not_sev, currRing))
         {
 #ifdef HAVE_RINGS
             if(rField_is_Ring(currRing))
                 {if(n_DivBy(pGetCoeff(p), pGetCoeff(strat->S[j]), currRing))
                     return j;}
             else
 #endif
             return j;
         }
 #else
     if ( !(strat->sevS[j] & not_sev) &&
          p_LmDivisibleBy(strat->S[j], p, currRing))
         {
 #ifdef HAVE_RINGS
             if(rField_is_Ring(currRing))
                 {if(n_DivBy(pGetCoeff(p), pGetCoeff(strat->S[j]), currRing))
                     return j;}
             else
 #endif
             return j;
         }
 #endif
     j++;
   }
 }

poly kFindZeroPoly	(	poly	input_p,
		ring	leadRing,
		ring	tailRing
	)

Definition at line 295 of file kstd2.cc.

 {
   // m = currRing->ch
 
   if (input_p == NULL) return NULL;
 
   poly p = input_p;
   poly zeroPoly = NULL;
   unsigned long a = (unsigned long) pGetCoeff(p);
 
   int k_ind2 = 0;
   int a_ind2 = ind2(a);
 
   // unsigned long k = 1;
   // of interest is only k_ind2, special routine for improvement ... TODO OLIVER
   for (int i = 1; i <= leadRing->N; i++)
   {
     k_ind2 = k_ind2 + ind_fact_2(p_GetExp(p, i, leadRing));
   }
 
   a = (unsigned long) pGetCoeff(p);
 
   number tmp1;
   poly tmp2, tmp3;
   poly lead_mult = p_ISet(1, tailRing);
   if (n_GetChar(leadRing->cf) <= k_ind2 + a_ind2)
   {
     int too_much = k_ind2 + a_ind2 - n_GetChar(leadRing->cf);
     int s_exp;
     zeroPoly = p_ISet(a, tailRing);
     for (int i = 1; i <= leadRing->N; i++)
     {
       s_exp = p_GetExp(p, i,leadRing);
       if (s_exp % 2 != 0)
       {
         s_exp = s_exp - 1;
       }
       while ( (0 < ind2(s_exp)) && (ind2(s_exp) <= too_much) )
       {
         too_much = too_much - ind2(s_exp);
         s_exp = s_exp - 2;
       }
       p_SetExp(lead_mult, i, p_GetExp(p, i,leadRing) - s_exp, tailRing);
       for (int j = 1; j <= s_exp; j++)
       {
         tmp1 = nInit(j);
         tmp2 = p_ISet(1, tailRing);
         p_SetExp(tmp2, i, 1, tailRing);
         p_Setm(tmp2, tailRing);
         if (nIsZero(tmp1))
         { // should nowbe obsolet, test ! TODO OLIVER
           zeroPoly = p_Mult_q(zeroPoly, tmp2, tailRing);
         }
         else
         {
           tmp3 = p_NSet(nCopy(tmp1), tailRing);
           zeroPoly = p_Mult_q(zeroPoly, p_Add_q(tmp3, tmp2, tailRing), tailRing);
         }
       }
     }
     p_Setm(lead_mult, tailRing);
     zeroPoly = p_Mult_mm(zeroPoly, lead_mult, tailRing);
     tmp2 = p_NSet(nCopy(pGetCoeff(zeroPoly)), leadRing);
     for (int i = 1; i <= leadRing->N; i++)
     {
       pSetExp(tmp2, i, p_GetExp(zeroPoly, i, tailRing));
     }
     p_Setm(tmp2, leadRing);
     zeroPoly = p_LmDeleteAndNext(zeroPoly, tailRing);
     pNext(tmp2) = zeroPoly;
     return tmp2;
   }
 /*  unsigned long alpha_k = twoPow(leadRing->ch - k_ind2);
   if (1 == 0 && alpha_k <= a)
   {  // Temporarly disabled, reducing coefficients not compatible with std TODO Oliver
     zeroPoly = p_ISet((a / alpha_k)*alpha_k, tailRing);
     for (int i = 1; i <= leadRing->N; i++)
     {
       for (unsigned long j = 1; j <= p_GetExp(p, i, leadRing); j++)
       {
         tmp1 = nInit(j);
         tmp2 = p_ISet(1, tailRing);
         p_SetExp(tmp2, i, 1, tailRing);
         p_Setm(tmp2, tailRing);
         if (nIsZero(tmp1))
         {
           zeroPoly = p_Mult_q(zeroPoly, tmp2, tailRing);
         }
         else
         {
           tmp3 = p_ISet((unsigned long) tmp1, tailRing);
           zeroPoly = p_Mult_q(zeroPoly, p_Add_q(tmp2, tmp3, tailRing), tailRing);
         }
       }
     }
     tmp2 = p_ISet((unsigned long) pGetCoeff(zeroPoly), leadRing);
     for (int i = 1; i <= leadRing->N; i++)
     {
       pSetExp(tmp2, i, p_GetExp(zeroPoly, i, tailRing));
     }
     p_Setm(tmp2, leadRing);
     zeroPoly = p_LmDeleteAndNext(zeroPoly, tailRing);
     pNext(tmp2) = zeroPoly;
     return tmp2;
   } */
   return NULL;
 }

void kFreeStrat ( kStrategy strat )

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

Definition at line 2592 of file kstd2.cc.

 {
   assume(q!=NULL);
   assume(!(idIs0(F)&&(Q==NULL))); // NF(q, std(0) in polynomial ring?
 
 // lazy_reduce flags: can be combined by |
 //#define KSTD_NF_LAZY   1
   // do only a reduction of the leading term
 //#define KSTD_NF_NONORM 4
   // only global: avoid normalization, return a multiply of NF
   poly   p;
 
   //if ((idIs0(F))&&(Q==NULL))
   //  return pCopy(q); /*F=0*/
   //strat->ak = idRankFreeModule(F);
   /*- creating temp data structures------------------- -*/
   BITSET save1;
   SI_SAVE_OPT1(save1);
   si_opt_1|=Sy_bit(OPT_REDTAIL);
   initBuchMoraCrit(strat);
   strat->initEcart = initEcartBBA;
   strat->enterS = enterSBba;
 #ifndef NO_BUCKETS
   strat->use_buckets = (!TEST_OPT_NOT_BUCKETS) && (!rIsPluralRing(currRing));
 #endif
   /*- set S -*/
   strat->sl = -1;
   /*- init local data struct.---------------------------------------- -*/
   /*Shdl=*/initS(F,Q,strat);
   /*- compute------------------------------------------------------- -*/
   //if ((TEST_OPT_INTSTRATEGY)&&(lazyReduce==0))
   //{
   //  for (i=strat->sl;i>=0;i--)
   //    pNorm(strat->S[i]);
   //}
   kTest(strat);
   if (TEST_OPT_PROT) { PrintS("r"); mflush(); }
   if (BVERBOSE(23)) kDebugPrint(strat);
   int max_ind;
   p = redNF(pCopy(q),max_ind,lazyReduce & KSTD_NF_NONORM,strat);
   if ((p!=NULL)&&((lazyReduce & KSTD_NF_LAZY)==0))
   {
     if (TEST_OPT_PROT) { PrintS("t"); mflush(); }
     #ifdef HAVE_RINGS
     if (rField_is_Ring(currRing))
     {
       p = redtailBba_Z(p,max_ind,strat);
     }
     else
     #endif
     {
       si_opt_1 &= ~Sy_bit(OPT_INTSTRATEGY);
       p = redtailBba(p,max_ind,strat,(lazyReduce & KSTD_NF_NONORM)==0);
     }
   }
   /*- release temp data------------------------------- -*/
   assume(strat->L==NULL); /* strat->L unused */
   assume(strat->B==NULL); /* strat->B unused */
   omFree(strat->sevS);
   omFree(strat->ecartS);
   assume(strat->T==NULL);//omfree(strat->T);
   assume(strat->sevT==NULL);//omfree(strat->sevT);
   assume(strat->R==NULL);//omfree(strat->R);
   omfree(strat->S_2_R);
   omfree(strat->fromQ);
   idDelete(&strat->Shdl);
   SI_RESTORE_OPT1(save1);
   if (TEST_OPT_PROT) PrintLn();
   return p;
 }

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

Definition at line 2663 of file kstd2.cc.

 {
   assume(!idIs0(q));
   assume(!(idIs0(F)&&(Q==NULL)));
 // lazy_reduce flags: can be combined by |
 //#define KSTD_NF_LAZY   1
   // do only a reduction of the leading term
 //#define KSTD_NF_NONORM 4
   // only global: avoid normalization, return a multiply of NF
   poly   p;
   int   i;
   ideal res;
   int max_ind;
 
   //if (idIs0(q))
   //  return idInit(IDELEMS(q),si_max(q->rank,F->rank));
   //if ((idIs0(F))&&(Q==NULL))
   //  return idCopy(q); /*F=0*/
   //strat->ak = idRankFreeModule(F);
   /*- creating temp data structures------------------- -*/
   BITSET save1;
   SI_SAVE_OPT1(save1);
   si_opt_1|=Sy_bit(OPT_REDTAIL);
   initBuchMoraCrit(strat);
   strat->initEcart = initEcartBBA;
   strat->enterS = enterSBba;
   /*- set S -*/
   strat->sl = -1;
 #ifndef NO_BUCKETS
   strat->use_buckets = (!TEST_OPT_NOT_BUCKETS) && (!rIsPluralRing(currRing));
 #endif
   /*- init local data struct.---------------------------------------- -*/
   /*Shdl=*/initS(F,Q,strat);
   /*- compute------------------------------------------------------- -*/
   res=idInit(IDELEMS(q),si_max(q->rank,F->rank));
   si_opt_1 &= ~Sy_bit(OPT_INTSTRATEGY);
   for (i=IDELEMS(q)-1; i>=0; i--)
   {
     if (q->m[i]!=NULL)
     {
       if (TEST_OPT_PROT) { PrintS("r");mflush(); }
       p = redNF(pCopy(q->m[i]),max_ind,lazyReduce & KSTD_NF_NONORM,strat);
       if ((p!=NULL)&&((lazyReduce & KSTD_NF_LAZY)==0))
       {
         if (TEST_OPT_PROT) { PrintS("t"); mflush(); }
         #ifdef HAVE_RINGS
         if (rField_is_Ring(currRing))
         {
           p = redtailBba_Z(p,max_ind,strat);
         }
         else
         #endif
         {
           p = redtailBba(p,max_ind,strat,(lazyReduce & KSTD_NF_NONORM)==0);
         }
       }
       res->m[i]=p;
     }
     //else
     //  res->m[i]=NULL;
   }
   /*- release temp data------------------------------- -*/
   assume(strat->L==NULL); /* strat->L unused */
   assume(strat->B==NULL); /* strat->B unused */
   omFree(strat->sevS);
   omFree(strat->ecartS);
   assume(strat->T==NULL);//omfree(strat->T);
   assume(strat->sevT==NULL);//omfree(strat->sevT);
   assume(strat->R==NULL);//omfree(strat->R);
   omfree(strat->S_2_R);
   omfree(strat->fromQ);
   idDelete(&strat->Shdl);
   SI_RESTORE_OPT1(save1);
   if (TEST_OPT_PROT) PrintLn();
   return res;
 }

poly ksCreateShortSpoly	(	poly	p1,
		poly	p2,
		ring	tailRing
	)

Definition at line 566 of file kspoly.cc.

 {
   poly a1 = pNext(p1), a2 = pNext(p2);
   long c1=p_GetComp(p1, currRing),c2=p_GetComp(p2, currRing);
   long c;
   poly m1,m2;
   number t1 = NULL,t2 = NULL;
   int cm,i;
   BOOLEAN equal;
 
 #ifdef HAVE_RINGS
   BOOLEAN is_Ring=rField_is_Ring(currRing);
   number lc1 = pGetCoeff(p1), lc2 = pGetCoeff(p2);
   if (is_Ring)
   {
     ksCheckCoeff(&lc1, &lc2, currRing->cf); // gcd and zero divisors
     if (a1 != NULL) t2 = nMult(pGetCoeff(a1),lc2);
     if (a2 != NULL) t1 = nMult(pGetCoeff(a2),lc1);
     while (a1 != NULL && nIsZero(t2))
     {
       pIter(a1);
       nDelete(&t2);
       if (a1 != NULL) t2 = nMult(pGetCoeff(a1),lc2);
     }
     while (a2 != NULL && nIsZero(t1))
     {
       pIter(a2);
       nDelete(&t1);
       if (a2 != NULL) t1 = nMult(pGetCoeff(a2),lc1);
     }
   }
 #endif
 
   if (a1==NULL)
   {
     if(a2!=NULL)
     {
       m2=p_Init(currRing);
 x2:
       for (i = (currRing->N); i; i--)
       {
         c = p_GetExpDiff(p1, p2,i, currRing);
         if (c>0)
         {
           p_SetExp(m2,i,(c+p_GetExp(a2,i,tailRing)),currRing);
         }
         else
         {
           p_SetExp(m2,i,p_GetExp(a2,i,tailRing),currRing);
         }
       }
       if ((c1==c2)||(c2!=0))
       {
         p_SetComp(m2,p_GetComp(a2,tailRing), currRing);
       }
       else
       {
         p_SetComp(m2,c1,currRing);
       }
       p_Setm(m2, currRing);
 #ifdef HAVE_RINGS
       if (is_Ring)
       {
           nDelete(&lc1);
           nDelete(&lc2);
           nDelete(&t2);
           pSetCoeff0(m2, t1);
       }
       else
 #endif
         nNew(&(pGetCoeff(m2)));
       return m2;
     }
     else
     {
 #ifdef HAVE_RINGS
       if (is_Ring)
       {
         nDelete(&lc1);
         nDelete(&lc2);
         nDelete(&t1);
         nDelete(&t2);
       }
 #endif
       return NULL;
     }
   }
   if (a2==NULL)
   {
     m1=p_Init(currRing);
 x1:
     for (i = (currRing->N); i; i--)
     {
       c = p_GetExpDiff(p2, p1,i,currRing);
       if (c>0)
       {
         p_SetExp(m1,i,(c+p_GetExp(a1,i, tailRing)),currRing);
       }
       else
       {
         p_SetExp(m1,i,p_GetExp(a1,i, tailRing), currRing);
       }
     }
     if ((c1==c2)||(c1!=0))
     {
       p_SetComp(m1,p_GetComp(a1,tailRing),currRing);
     }
     else
     {
       p_SetComp(m1,c2,currRing);
     }
     p_Setm(m1, currRing);
 #ifdef HAVE_RINGS
     if (is_Ring)
     {
       pSetCoeff0(m1, t2);
       nDelete(&lc1);
       nDelete(&lc2);
       nDelete(&t1);
     }
     else
 #endif
       nNew(&(pGetCoeff(m1)));
     return m1;
   }
   m1 = p_Init(currRing);
   m2 = p_Init(currRing);
   loop
   {
     for (i = (currRing->N); i; i--)
     {
       c = p_GetExpDiff(p1, p2,i,currRing);
       if (c > 0)
       {
         p_SetExp(m2,i,(c+p_GetExp(a2,i,tailRing)), currRing);
         p_SetExp(m1,i,p_GetExp(a1,i, tailRing), currRing);
       }
       else
       {
         p_SetExp(m1,i,(p_GetExp(a1,i,tailRing)-c), currRing);
         p_SetExp(m2,i,p_GetExp(a2,i, tailRing), currRing);
       }
     }
     if(c1==c2)
     {
       p_SetComp(m1,p_GetComp(a1, tailRing), currRing);
       p_SetComp(m2,p_GetComp(a2, tailRing), currRing);
     }
     else
     {
       if(c1!=0)
       {
         p_SetComp(m1,p_GetComp(a1, tailRing), currRing);
         p_SetComp(m2,c1, currRing);
       }
       else
       {
         p_SetComp(m2,p_GetComp(a2, tailRing), currRing);
         p_SetComp(m1,c2, currRing);
       }
     }
     p_Setm(m1,currRing);
     p_Setm(m2,currRing);
     cm = p_LmCmp(m1, m2,currRing);
     if (cm!=0)
     {
       if(cm==1)
       {
         p_LmFree(m2,currRing);
 #ifdef HAVE_RINGS
         if (is_Ring)
         {
           pSetCoeff0(m1, t2);
           nDelete(&lc1);
           nDelete(&lc2);
           nDelete(&t1);
         }
         else
 #endif
           nNew(&(pGetCoeff(m1)));
         return m1;
       }
       else
       {
         p_LmFree(m1,currRing);
 #ifdef HAVE_RINGS
         if (is_Ring)
         {
           pSetCoeff0(m2, t1);
           nDelete(&lc1);
           nDelete(&lc2);
           nDelete(&t2);
         }
         else
 #endif
           nNew(&(pGetCoeff(m2)));
         return m2;
       }
     }
 #ifdef HAVE_RINGS
     if (is_Ring)
     {
       equal = nEqual(t1,t2);
     }
     else
 #endif
     {
       t1 = nMult(pGetCoeff(a2),pGetCoeff(p1));
       t2 = nMult(pGetCoeff(a1),pGetCoeff(p2));
       equal = nEqual(t1,t2);
       nDelete(&t2);
       nDelete(&t1);
     }
     if (!equal)
     {
       p_LmFree(m2,currRing);
 #ifdef HAVE_RINGS
       if (is_Ring)
       {
           pSetCoeff0(m1, nSub(t1, t2));
           nDelete(&lc1);
           nDelete(&lc2);
           nDelete(&t1);
           nDelete(&t2);
       }
       else
 #endif
         nNew(&(pGetCoeff(m1)));
       return m1;
     }
     pIter(a1);
     pIter(a2);
 #ifdef HAVE_RINGS
     if (is_Ring)
     {
       if (a2 != NULL)
       {
         nDelete(&t1);
         t1 = nMult(pGetCoeff(a2),lc1);
       }
       if (a1 != NULL)
       {
         nDelete(&t2);
         t2 = nMult(pGetCoeff(a1),lc2);
       }
       while ((a1 != NULL) && nIsZero(t2))
       {
         pIter(a1);
         if (a1 != NULL)
         {
           nDelete(&t2);
           t2 = nMult(pGetCoeff(a1),lc2);
         }
       }
       while ((a2 != NULL) && nIsZero(t1))
       {
         pIter(a2);
         if (a2 != NULL)
         {
           nDelete(&t1);
           t1 = nMult(pGetCoeff(a2),lc1);
         }
       }
     }
 #endif
     if (a2==NULL)
     {
       p_LmFree(m2,currRing);
       if (a1==NULL)
       {
 #ifdef HAVE_RINGS
         if (is_Ring)
         {
           nDelete(&lc1);
           nDelete(&lc2);
           nDelete(&t1);
           nDelete(&t2);
         }
 #endif
         p_LmFree(m1,currRing);
         return NULL;
       }
       goto x1;
     }
     if (a1==NULL)
     {
       p_LmFree(m1,currRing);
       goto x2;
     }
   }
 }

void ksCreateSpoly	(	LObject *	Pair,
		poly	spNoether = `NULL`,
		int	use_buckets = `0`,
		ring	tailRing = `currRing`,
		poly	m1 = `NULL`,
		poly	m2 = `NULL`,
		TObject **	R = `NULL`
	)

Definition at line 379 of file kspoly.cc.

 {
 #ifdef KDEBUG
   create_count++;
 #endif
   kTest_L(Pair);
   poly p1 = Pair->p1;
   poly p2 = Pair->p2;
   Pair->tailRing = tailRing;
 
   assume(p1 != NULL);
   assume(p2 != NULL);
   assume(tailRing != NULL);
 
   poly a1 = pNext(p1), a2 = pNext(p2);
   number lc1 = pGetCoeff(p1), lc2 = pGetCoeff(p2);
   int co=0/*, ct = ksCheckCoeff(&lc1, &lc2, currRing->cf)*/; // gcd and zero divisors
   (void) ksCheckCoeff(&lc1, &lc2, currRing->cf);
 
   int l1=0, l2=0;
 
   if (p_GetComp(p1, currRing)!=p_GetComp(p2, currRing))
   {
     if (p_GetComp(p1, currRing)==0)
     {
       co=1;
       p_SetCompP(p1,p_GetComp(p2, currRing), currRing, tailRing);
     }
     else
     {
       co=2;
       p_SetCompP(p2, p_GetComp(p1, currRing), currRing, tailRing);
     }
   }
 
   // get m1 = LCM(LM(p1), LM(p2))/LM(p1)
   //     m2 = LCM(LM(p1), LM(p2))/LM(p2)
   if (m1 == NULL)
     k_GetLeadTerms(p1, p2, currRing, m1, m2, tailRing);
 
   pSetCoeff0(m1, lc2);
   pSetCoeff0(m2, lc1);  // and now, m1 * LT(p1) == m2 * LT(p2)
 
   if (R != NULL)
   {
     if (Pair->i_r1 == -1)
     {
       l1 = pLength(p1) - 1;
     }
     else
     {
       l1 = (R[Pair->i_r1])->GetpLength() - 1;
     }
     if ((Pair->i_r2 == -1)||(R[Pair->i_r2]==NULL))
     {
       l2 = pLength(p2) - 1;
     }
     else
     {
       l2 = (R[Pair->i_r2])->GetpLength() - 1;
     }
   }
 
   // get m2 * a2
   if (spNoether != NULL)
   {
     l2 = -1;
     a2 = tailRing->p_Procs->pp_Mult_mm_Noether(a2, m2, spNoether, l2, tailRing);
     assume(l2 == pLength(a2));
   }
   else
     a2 = tailRing->p_Procs->pp_Mult_mm(a2, m2, tailRing);
 #ifdef HAVE_RINGS
   if (!(rField_is_Domain(currRing))) l2 = pLength(a2);
 #endif
 
   Pair->SetLmTail(m2, a2, l2, use_buckets, tailRing);
 
   // get m2*a2 - m1*a1
   Pair->Tail_Minus_mm_Mult_qq(m1, a1, l1, spNoether);
 
   // Clean-up time
   Pair->LmDeleteAndIter();
   p_LmDelete(m1, tailRing);
 
   if (co != 0)
   {
     if (co==1)
     {
       p_SetCompP(p1,0, currRing, tailRing);
     }
     else
     {
       p_SetCompP(p2,0, currRing, tailRing);
     }
   }
 
   // the following is commented out: shrinking
 #ifdef HAVE_SHIFTBBA_NONEXISTENT
   if (currRing->isLPring)
   {
     // assume? h->p in currRing
     Pair->GetP();
     poly qq = p_Shrink(Pair->p, currRing->isLPring, currRing);
     Pair->Clear(); // does the right things
     Pair->p = qq;
     Pair->t_p = NULL;
     Pair->SetShortExpVector();
   }
 #endif
 
 }

KINLINE poly ksOldCreateSpoly	(	poly	p1,
		poly	p2,
		poly	spNoether = `NULL`,
		ring	r = `currRing`
	)

Definition at line 1102 of file kInline.h.

 {
   LObject L(r);
   L.p1 = p1;
   L.p2 = p2;
 
   ksCreateSpoly(&L, spNoether);
   return L.GetLmCurrRing();
 }

KINLINE poly ksOldSpolyRed	(	poly	p1,
		poly	p2,
		poly	spNoether = `NULL`
	)

Definition at line 1082 of file kInline.h.

 {
   LObject L(p2);
   TObject T(p1);
 
   ksReducePoly(&L, &T, spNoether);
 
   return L.GetLmCurrRing();
 }

KINLINE poly ksOldSpolyRedNew	(	poly	p1,
		poly	p2,
		poly	spNoether = `NULL`
	)

Definition at line 1092 of file kInline.h.

 {
   LObject L(p_Copy(p2, currRing));
   TObject T(p1);
 
   ksReducePoly(&L, &T, spNoether);
 
   return L.GetLmCurrRing();
 }

KINLINE void ksOldSpolyTail	(	poly	p1,
		poly	q,
		poly	q2,
		poly	spNoether,
		ring	r = `currRing`
	)

Definition at line 1112 of file kInline.h.

 {
   LObject L(q,  currRing, r);
   TObject T(p1, currRing, r);
 
   ksReducePolyTail(&L, &T, q2, spNoether);
 }

int ksReducePoly	(	LObject *	PR,
		TObject *	PW,
		poly	spNoether = `NULL`,
		number *	coef = `NULL`,
		kStrategy	strat = `NULL`
	)

Definition at line 38 of file kspoly.cc.

 {
 #ifdef KDEBUG
   red_count++;
 #ifdef TEST_OPT_DEBUG_RED
   if (TEST_OPT_DEBUG)
   {
     Print("Red %d:", red_count); PR->wrp(); Print(" with:");
     PW->wrp();
     //printf("\necart(PR)-ecart(PW): %i\n",PR->ecart-PW->ecart);
     //pWrite(PR->p);
   }
 #endif
 #endif
   int ret = 0;
   ring tailRing = PR->tailRing;
   kTest_L(PR);
   kTest_T(PW);
 
   poly p1 = PR->GetLmTailRing();   // p2 | p1
   poly p2 = PW->GetLmTailRing();   // i.e. will reduce p1 with p2; lm = LT(p1) / LM(p2)
   poly t2 = pNext(p2), lm = p1;    // t2 = p2 - LT(p2); really compute P = LC(p2)*p1 - LT(p1)/LM(p2)*p2
   assume(p1 != NULL && p2 != NULL);// Attention, we have rings and there LC(p2) and LC(p1) are special
   p_CheckPolyRing(p1, tailRing);
   p_CheckPolyRing(p2, tailRing);
 
   pAssume1(p2 != NULL && p1 != NULL &&
            p_DivisibleBy(p2,  p1, tailRing));
 
   pAssume1(p_GetComp(p1, tailRing) == p_GetComp(p2, tailRing) ||
            (p_GetComp(p2, tailRing) == 0 &&
             p_MaxComp(pNext(p2),tailRing) == 0));
 
 #ifdef HAVE_PLURAL
   if (rIsPluralRing(currRing))
   {
     // for the time being: we know currRing==strat->tailRing
     // no exp-bound checking needed
     // (only needed if exp-bound(tailring)<exp-b(currRing))
     if (PR->bucket!=NULL)  nc_kBucketPolyRed(PR->bucket, p2,coef);
     else
     {
       poly _p = (PR->t_p != NULL ? PR->t_p : PR->p);
       assume(_p != NULL);
       nc_PolyPolyRed(_p, p2,coef, currRing);
       if (PR->t_p!=NULL) PR->t_p=_p; else PR->p=_p;
       PR->pLength=0; // usually not used, GetpLength re-computes it if needed
     }
     return 0;
   }
 #endif
 
   if (t2==NULL)           // Divisor is just one term, therefore it will
   {                       // just cancel the leading term
     PR->LmDeleteAndIter();
     if (coef != NULL) *coef = n_Init(1, tailRing);
     return 0;
   }
 
   p_ExpVectorSub(lm, p2, tailRing); // Calculate the Monomial we must multiply to p2
 
   if (tailRing != currRing)
   {
     // check that reduction does not violate exp bound
     while (PW->max != NULL && !p_LmExpVectorAddIsOk(lm, PW->max, tailRing))
     {
       // undo changes of lm
       p_ExpVectorAdd(lm, p2, tailRing);
       if (strat == NULL) return 2;
       if (! kStratChangeTailRing(strat, PR, PW)) return -1;
       tailRing = strat->tailRing;
       p1 = PR->GetLmTailRing();
       p2 = PW->GetLmTailRing();
       t2 = pNext(p2);
       lm = p1;
       p_ExpVectorSub(lm, p2, tailRing);
       ret = 1;
     }
   }
 
   // take care of coef buisness
   if (! n_IsOne(pGetCoeff(p2), tailRing))
   {
     number bn = pGetCoeff(lm);
     number an = pGetCoeff(p2);
     int ct = ksCheckCoeff(&an, &bn, tailRing->cf);    // Calculate special LC
     p_SetCoeff(lm, bn, tailRing);
     if ((ct == 0) || (ct == 2))
       PR->Tail_Mult_nn(an);
     if (coef != NULL) *coef = an;
     else n_Delete(&an, tailRing);
   }
   else
   {
     if (coef != NULL) *coef = n_Init(1, tailRing);
   }
 
 
   // and finally,
   PR->Tail_Minus_mm_Mult_qq(lm, t2, pLength(t2) /*PW->GetpLength() - 1*/, spNoether);
   assume(PW->GetpLength() == pLength(PW->p != NULL ? PW->p : PW->t_p));
   PR->LmDeleteAndIter();
 
   // the following is commented out: shrinking
 #ifdef HAVE_SHIFTBBA_NONEXISTENT
   if ( (currRing->isLPring) && (!strat->homog) )
   {
     // assume? h->p in currRing
     PR->GetP();
     poly qq = p_Shrink(PR->p, currRing->isLPring, currRing);
     PR->Clear(); // does the right things
     PR->p = qq;
     PR->t_p = NULL;
     PR->SetShortExpVector();
   }
 #endif
 
 #if defined(KDEBUG) && defined(TEST_OPT_DEBUG_RED)
   if (TEST_OPT_DEBUG)
   {
     Print(" to: "); PR->wrp(); Print("\n");
     //printf("\nt^%i ", PR->ecart);pWrite(pHead(PR->p));
   }
 #endif
   return ret;
 }

int ksReducePolySig	(	LObject *	PR,
		TObject *	PW,
		long	idx,
		poly	spNoether = `NULL`,
		number *	coef = `NULL`,
		kStrategy	strat = `NULL`
	)

Definition at line 175 of file kspoly.cc.

 {
 #ifdef KDEBUG
   red_count++;
 #ifdef TEST_OPT_DEBUG_RED
   if (TEST_OPT_DEBUG)
   {
     Print("Red %d:", red_count); PR->wrp(); Print(" with:");
     PW->wrp();
   }
 #endif
 #endif
   int ret = 0;
   ring tailRing = PR->tailRing;
   kTest_L(PR);
   kTest_T(PW);
 
   // signature-based stuff:
   // checking for sig-safeness first
   // NOTE: This has to be done in the current ring
   //
   /**********************************************
    *
    * TODO:
    * --------------------------------------------
    * if strat->sbaOrder == 1
    * Since we are subdividing lower index and
    * current index reductions it is enough to
    * look at the polynomial part of the signature
    * for a check. This should speed-up checking
    * a lot!
    * if !strat->sbaOrder == 0
    * We are not subdividing lower and current index
    * due to the fact that we are using the induced
    * Schreyer order
    *
    * nevertheless, this different behaviour is
    * taken care of by is_sigsafe
    * => one reduction procedure can be used for
    * both, the incremental and the non-incremental
    * attempt!
    * --------------------------------------------
    *
    *********************************************/
   //printf("COMPARE IDX: %ld -- %ld\n",idx,strat->currIdx);
   if (!PW->is_sigsafe)
   {
     poly sigMult = pCopy(PW->sig);   // copy signature of reducer
 //#if 1
 #ifdef DEBUGF5
     printf("IN KSREDUCEPOLYSIG: \n");
     pWrite(pHead(f1));
     pWrite(pHead(f2));
     pWrite(sigMult);
     printf("--------------\n");
 #endif
     p_ExpVectorAddSub(sigMult,PR->GetLmCurrRing(),PW->GetLmCurrRing(),currRing);
 //#if 1
 #ifdef DEBUGF5
     printf("------------------- IN KSREDUCEPOLYSIG: --------------------\n");
     pWrite(pHead(f1));
     pWrite(pHead(f2));
     pWrite(sigMult);
     pWrite(PR->sig);
     printf("--------------\n");
 #endif
     int sigSafe = p_LmCmp(PR->sig,sigMult,currRing);
     // now we can delete the copied polynomial data used for checking for
     // sig-safeness of the reduction step
 //#if 1
 #ifdef DEBUGF5
     printf("%d -- %d sig\n",sigSafe,PW->is_sigsafe);
 
 #endif
     //pDelete(&f1);
     pDelete(&sigMult);
     // go on with the computations only if the signature of p2 is greater than the
     // signature of fm*p1
     if(sigSafe != 1)
     {
       PR->is_redundant = TRUE;
       return 3;
     }
     //PW->is_sigsafe  = TRUE;
   }
   PR->is_redundant = FALSE;
   poly p1 = PR->GetLmTailRing();   // p2 | p1
   poly p2 = PW->GetLmTailRing();   // i.e. will reduce p1 with p2; lm = LT(p1) / LM(p2)
   poly t2 = pNext(p2), lm = p1;    // t2 = p2 - LT(p2); really compute P = LC(p2)*p1 - LT(p1)/LM(p2)*p2
   assume(p1 != NULL && p2 != NULL);// Attention, we have rings and there LC(p2) and LC(p1) are special
   p_CheckPolyRing(p1, tailRing);
   p_CheckPolyRing(p2, tailRing);
 
   pAssume1(p2 != NULL && p1 != NULL &&
       p_DivisibleBy(p2,  p1, tailRing));
 
   pAssume1(p_GetComp(p1, tailRing) == p_GetComp(p2, tailRing) ||
       (p_GetComp(p2, tailRing) == 0 &&
        p_MaxComp(pNext(p2),tailRing) == 0));
 
 #ifdef HAVE_PLURAL
   if (rIsPluralRing(currRing))
   {
     // for the time being: we know currRing==strat->tailRing
     // no exp-bound checking needed
     // (only needed if exp-bound(tailring)<exp-b(currRing))
     if (PR->bucket!=NULL)  nc_kBucketPolyRed(PR->bucket, p2,coef);
     else
     {
       poly _p = (PR->t_p != NULL ? PR->t_p : PR->p);
       assume(_p != NULL);
       nc_PolyPolyRed(_p, p2, coef, currRing);
       if (PR->t_p!=NULL) PR->t_p=_p; else PR->p=_p;
       PR->pLength=0; // usaully not used, GetpLength re-comoutes it if needed
     }
     return 0;
   }
 #endif
 
   if (t2==NULL)           // Divisor is just one term, therefore it will
   {                       // just cancel the leading term
     PR->LmDeleteAndIter();
     if (coef != NULL) *coef = n_Init(1, tailRing);
     return 0;
   }
 
   p_ExpVectorSub(lm, p2, tailRing); // Calculate the Monomial we must multiply to p2
 
   if (tailRing != currRing)
   {
     // check that reduction does not violate exp bound
     while (PW->max != NULL && !p_LmExpVectorAddIsOk(lm, PW->max, tailRing))
     {
       // undo changes of lm
       p_ExpVectorAdd(lm, p2, tailRing);
       if (strat == NULL) return 2;
       if (! kStratChangeTailRing(strat, PR, PW)) return -1;
       tailRing = strat->tailRing;
       p1 = PR->GetLmTailRing();
       p2 = PW->GetLmTailRing();
       t2 = pNext(p2);
       lm = p1;
       p_ExpVectorSub(lm, p2, tailRing);
       ret = 1;
     }
   }
 
   // take care of coef buisness
   if (! n_IsOne(pGetCoeff(p2), tailRing))
   {
     number bn = pGetCoeff(lm);
     number an = pGetCoeff(p2);
     int ct = ksCheckCoeff(&an, &bn, tailRing->cf);    // Calculate special LC
     p_SetCoeff(lm, bn, tailRing);
     if ((ct == 0) || (ct == 2))
       PR->Tail_Mult_nn(an);
     if (coef != NULL) *coef = an;
     else n_Delete(&an, tailRing);
   }
   else
   {
     if (coef != NULL) *coef = n_Init(1, tailRing);
   }
 
 
   // and finally,
   PR->Tail_Minus_mm_Mult_qq(lm, t2, PW->GetpLength() - 1, spNoether);
   assume(PW->GetpLength() == pLength(PW->p != NULL ? PW->p : PW->t_p));
   PR->LmDeleteAndIter();
 
   // the following is commented out: shrinking
 #ifdef HAVE_SHIFTBBA_NONEXISTENT
   if ( (currRing->isLPring) && (!strat->homog) )
   {
     // assume? h->p in currRing
     PR->GetP();
     poly qq = p_Shrink(PR->p, currRing->isLPring, currRing);
     PR->Clear(); // does the right things
     PR->p = qq;
     PR->t_p = NULL;
     PR->SetShortExpVector();
   }
 #endif
 
 #if defined(KDEBUG) && defined(TEST_OPT_DEBUG_RED)
   if (TEST_OPT_DEBUG)
   {
     Print(" to: "); PR->wrp(); Print("\n");
   }
 #endif
   return ret;
 }

int ksReducePolyTail	(	LObject *	PR,
		TObject *	PW,
		poly	Current,
		poly	spNoether = `NULL`
	)

Definition at line 494 of file kspoly.cc.

 {
   BOOLEAN ret;
   number coef;
   poly Lp =     PR->GetLmCurrRing();
   poly Save =   PW->GetLmCurrRing();
 
   kTest_L(PR);
   kTest_T(PW);
   pAssume(pIsMonomOf(Lp, Current));
 
   assume(Lp != NULL && Current != NULL && pNext(Current) != NULL);
   assume(PR->bucket == NULL);
 
   LObject Red(pNext(Current), PR->tailRing);
   TObject With(PW, Lp == Save);
 
   pAssume(!pHaveCommonMonoms(Red.p, With.p));
   ret = ksReducePoly(&Red, &With, spNoether, &coef);
 
   if (!ret)
   {
     if (! n_IsOne(coef, currRing))
     {
       pNext(Current) = NULL;
       if (Current == PR->p && PR->t_p != NULL)
         pNext(PR->t_p) = NULL;
       PR->Mult_nn(coef);
     }
 
     n_Delete(&coef, currRing);
     pNext(Current) = Red.GetLmTailRing();
     if (Current == PR->p && PR->t_p != NULL)
       pNext(PR->t_p) = pNext(Current);
   }
 
   if (Lp == Save)
     With.Delete();
 
   // the following is commented out: shrinking
 #ifdef HAVE_SHIFTBBA_NONEXISTENT
   if (currRing->isLPring)
   {
     // assume? h->p in currRing
     PR->GetP();
     poly qq = p_Shrink(PR->p, currRing->isLPring, currRing);
     PR->Clear(); // does the right things
     PR->p = qq;
     PR->t_p = NULL;
     PR->SetShortExpVector();
   }
 #endif
 
   return ret;
 }

KINLINE int ksReducePolyTail	(	LObject *	PR,
		TObject *	PW,
		LObject *	Red
	)

Definition at line 1055 of file kInline.h.

 {
   BOOLEAN ret;
   number coef;
 
   assume(PR->GetLmCurrRing() != PW->GetLmCurrRing());
   Red->HeadNormalize();
   ret = ksReducePoly(Red, PW, NULL, &coef);
 
   if (!ret)
   {
     if (! n_IsOne(coef, currRing->cf))
     {
       PR->Mult_nn(coef);
       // HANNES: mark for Normalize
     }
     n_Delete(&coef, currRing->cf);
   }
   return ret;
 }

BOOLEAN kStratChangeTailRing	(	kStrategy	strat,
		LObject *	L = `NULL`,
		TObject *	T = `NULL`,
		unsigned long	new_expbound = `0`
	)

Definition at line 9361 of file kutil.cc.

 {
   assume((strat->tailRing == currRing) || (strat->tailRing->bitmask <= currRing->bitmask));
   /* initial setup or extending */
 
   if (expbound == 0) expbound = strat->tailRing->bitmask << 1;
   if (expbound >= currRing->bitmask) return FALSE;
   strat->overflow=FALSE;
   ring new_tailRing = rModifyRing(currRing,
   // Hmmm .. the condition pFDeg == p_Deg
   // might be too strong
 #ifdef HAVE_RINGS
   (strat->homog && currRing->pFDeg == p_Deg && !(rField_is_Ring(currRing))), // TODO Oliver
 #else
   (strat->homog && currRing->pFDeg == p_Deg), // omit_degree
 #endif
   (strat->ak==0), // omit_comp if the input is an ideal
   expbound); // exp_limit
 
   if (new_tailRing == currRing) return TRUE;
 
   strat->pOrigFDeg_TailRing = new_tailRing->pFDeg;
   strat->pOrigLDeg_TailRing = new_tailRing->pLDeg;
 
   if (currRing->pFDeg != currRing->pFDegOrig)
   {
     new_tailRing->pFDeg = currRing->pFDeg;
     new_tailRing->pLDeg = currRing->pLDeg;
   }
 
   if (TEST_OPT_PROT)
     Print("[%lu:%d", (unsigned long) new_tailRing->bitmask, new_tailRing->ExpL_Size);
   kTest_TS(strat);
   assume(new_tailRing != strat->tailRing);
   pShallowCopyDeleteProc p_shallow_copy_delete
     = pGetShallowCopyDeleteProc(strat->tailRing, new_tailRing);
 
   omBin new_tailBin = omGetStickyBinOfBin(new_tailRing->PolyBin);
 
   int i;
   for (i=0; i<=strat->tl; i++)
   {
     strat->T[i].ShallowCopyDelete(new_tailRing, new_tailBin,
                                   p_shallow_copy_delete);
   }
   for (i=0; i<=strat->Ll; i++)
   {
     assume(strat->L[i].p != NULL);
     if (pNext(strat->L[i].p) != strat->tail)
       strat->L[i].ShallowCopyDelete(new_tailRing, p_shallow_copy_delete);
   }
   if ((strat->P.t_p != NULL) ||
       ((strat->P.p != NULL) && pNext(strat->P.p) != strat->tail))
     strat->P.ShallowCopyDelete(new_tailRing, p_shallow_copy_delete);
 
   if ((L != NULL) && (L->tailRing != new_tailRing))
   {
     if (L->i_r < 0)
       L->ShallowCopyDelete(new_tailRing, p_shallow_copy_delete);
     else
     {
       assume(L->i_r <= strat->tl);
       TObject* t_l = strat->R[L->i_r];
       assume(t_l != NULL);
       L->tailRing = new_tailRing;
       L->p = t_l->p;
       L->t_p = t_l->t_p;
       L->max = t_l->max;
     }
   }
 
   if ((T != NULL) && (T->tailRing != new_tailRing && T->i_r < 0))
     T->ShallowCopyDelete(new_tailRing, new_tailBin, p_shallow_copy_delete);
 
   omMergeStickyBinIntoBin(strat->tailBin, strat->tailRing->PolyBin);
   if (strat->tailRing != currRing)
     rKillModifiedRing(strat->tailRing);
 
   strat->tailRing = new_tailRing;
   strat->tailBin = new_tailBin;
   strat->p_shallow_copy_delete
     = pGetShallowCopyDeleteProc(currRing, new_tailRing);
 
   if (strat->kHEdge != NULL)
   {
     if (strat->t_kHEdge != NULL)
       p_LmFree(strat->t_kHEdge, strat->tailRing);
     strat->t_kHEdge=k_LmInit_currRing_2_tailRing(strat->kHEdge, new_tailRing);
   }
 
   if (strat->kNoether != NULL)
   {
     if (strat->t_kNoether != NULL)
       p_LmFree(strat->t_kNoether, strat->tailRing);
     strat->t_kNoether=k_LmInit_currRing_2_tailRing(strat->kNoether,
                                                    new_tailRing);
   }
   kTest_TS(strat);
   if (TEST_OPT_PROT)
     PrintS("]");
   return TRUE;
 }

void kStratInitChangeTailRing ( kStrategy strat )

Definition at line 9464 of file kutil.cc.

 {
   unsigned long l = 0;
   int i;
   long e;
 
   assume(strat->tailRing == currRing);
 
   for (i=0; i<= strat->Ll; i++)
   {
     l = p_GetMaxExpL(strat->L[i].p, currRing, l);
   }
   for (i=0; i<=strat->tl; i++)
   {
     // Hmm ... this we could do in one Step
     l = p_GetMaxExpL(strat->T[i].p, currRing, l);
   }
   if (rField_is_Ring(currRing))
   {
     l *= 2;
   }
   e = p_GetMaxExp(l, currRing);
   if (e <= 1) e = 2;
 
   kStratChangeTailRing(strat, NULL, NULL, e);
 }

void message	(	int	i,
		int *	reduc,
		int *	olddeg,
		kStrategy	strat,
		int	red_result
	)

Definition at line 6278 of file kutil.cc.

 {
   if (i != *olddeg)
   {
     Print("%d",i);
     *olddeg = i;
   }
   if (TEST_OPT_OLDSTD)
   {
     if (strat->Ll != *reduc)
     {
       if (strat->Ll != *reduc-1)
         Print("(%d)",strat->Ll+1);
       else
         PrintS("-");
       *reduc = strat->Ll;
     }
     else
       PrintS(".");
     mflush();
   }
   else
   {
     if (red_result == 0)
       PrintS("-");
     else if (red_result < 0)
       PrintS(".");
     if ((red_result > 0) || ((strat->Ll % 100)==99))
     {
       if (strat->Ll != *reduc && strat->Ll > 0)
       {
         Print("(%d)",strat->Ll+1);
         *reduc = strat->Ll;
       }
     }
   }
 }

void messageStat	(	int	hilbcount,
		kStrategy	strat
	)

Definition at line 6319 of file kutil.cc.

 {
   //PrintS("\nUsage/Allocation of temporary storage:\n");
   //Print("%d/%d polynomials in standard base\n",srmax,IDELEMS(Shdl));
   //Print("%d/%d polynomials in set L (for lazy alg.)",lrmax+1,strat->Lmax);
   Print("product criterion:%d chain criterion:%d\n",strat->cp,strat->c3);
   if (hilbcount!=0) Print("hilbert series criterion:%d\n",hilbcount);
   /* in usual case strat->cv is 0, it gets changed only in shift routines */
   if (strat->cv!=0) Print("shift V criterion:%d\n",strat->cv);
   /*mflush();*/
 }

BOOLEAN newHEdge ( kStrategy strat )

Definition at line 8924 of file kutil.cc.

 {
   if (currRing->pLexOrder || rHasMixedOrdering(currRing))
     return FALSE;
   int i,j;
   poly newNoether;
 
 #if 0
   if (currRing->weight_all_1)
     scComputeHC(strat->Shdl,NULL,strat->ak,strat->kHEdge, strat->tailRing);
   else
     scComputeHCw(strat->Shdl,NULL,strat->ak,strat->kHEdge, strat->tailRing);
 #else
   scComputeHC(strat->Shdl,NULL,strat->ak,strat->kHEdge, strat->tailRing);
 #endif
   if (strat->t_kHEdge != NULL) p_LmFree(strat->t_kHEdge, strat->tailRing);
   if (strat->tailRing != currRing)
     strat->t_kHEdge = k_LmInit_currRing_2_tailRing(strat->kHEdge, strat->tailRing);
   /* compare old and new noether*/
   newNoether = pLmInit(strat->kHEdge);
   j = p_FDeg(newNoether,currRing);
 /*  #ifdef HAVE_RINGS
   if (!rField_is_Ring(currRing))
   #endif */
   for (i=1; i<=(currRing->N); i++)
   {
     if (pGetExp(newNoether, i) > 0) pDecrExp(newNoether,i);
   }
   pSetm(newNoether);
   if (j < strat->HCord) /*- statistics -*/
   {
     if (TEST_OPT_PROT)
     {
       Print("H(%d)",j);
       mflush();
     }
     strat->HCord=j;
     #ifdef KDEBUG
     if (TEST_OPT_DEBUG)
     {
       Print("H(%d):",j);
       wrp(strat->kHEdge);
       PrintLn();
     }
     #endif
   }
   if (pCmp(strat->kNoether,newNoether)!=1)
   {
     pDelete(&strat->kNoether);
     strat->kNoether=newNoether;
     if (strat->t_kNoether != NULL) p_LmFree(strat->t_kNoether, strat->tailRing);
     if (strat->tailRing != currRing)
       strat->t_kNoether = k_LmInit_currRing_2_tailRing(strat->kNoether, strat->tailRing);
 
     return TRUE;
   }
   #ifdef HAVE_RINGS
   if (rField_is_Ring(currRing))
     pLmDelete(newNoether);
   else
   #endif
     pLmFree(newNoether);
   return FALSE;
 }

void pairs ( )

poly pCopyL2p	(	LObject	h,
		kStrategy	strat
	)

Definition at line 10059 of file kutil.cc.

 {
     /* restores a poly in currRing from LObject */
     LObject h = H;
     h.Copy();
     poly p;
     if (h.p == NULL)
     {
       if (h.t_p != NULL)
       {
          p = prMoveR(h.t_p, /* source ring: */ strat->tailRing, /* dest. ring: */ currRing);
         return(p);
       }
       else
       {
         /* h.tp == NULL -> the object is NULL */
         return(NULL);
       }
     }
     /* we're here if h.p != NULL */
     if (h.t_p == NULL)
     {
        /* then h.p is the whole poly in currRing */
        p = h.p;
       return(p);
     }
     /* we're here if h.p != NULL and h.t_p != NULL */
     // clean h.p, get poly from t_p
      pNext(h.p)=NULL;
      pDelete(&h.p);
      p = prMoveR(h.t_p, /* source ring: */ strat->tailRing,
                          /* dest. ring: */ currRing);
      // no need to clean h: we re-used the polys
     return(p);
 }

poly pMove2CurrTail	(	poly	p,
		kStrategy	strat
	)

Definition at line 10028 of file kutil.cc.

 {
   /* assume: p is completely in currRing */
   /* produces an object with LM in curring
      and TAIL in tailring */
   if (pNext(p)!=NULL)
   {
     pNext(p) = prMoveR(pNext(p), /* src */ currRing, /* dest */ strat->tailRing);
   }
   return(p);
 }

poly pMoveCurrTail2poly	(	poly	p,
		kStrategy	strat
	)

Definition at line 10042 of file kutil.cc.

 {
   /* assume: p has  LM in curring and TAIL in tailring */
   /* convert it to complete currRing */
 
   /* check that LM is in currRing */
   assume(p_LmCheckIsFromRing(p, currRing));
 
   if (pNext(p)!=NULL)
   {
     pNext(p) = prMoveR(pNext(p), /* src */ strat->tailRing, /* dest */currRing);
   }
   return(p);
 }

int posInL0	(	const LSet	set,
		const int	length,
		LObject *	L,
		const kStrategy	strat
	)

Definition at line 4909 of file kutil.cc.

 {
   if (length<0) return 0;
 
   if (pLmCmp(set[length].p,p->p)== currRing->OrdSgn)
     return length+1;
 
   int i;
   int an = 0;
   int en= length;
   loop
   {
     if (an >= en-1)
     {
       if (pLmCmp(set[an].p,p->p) == currRing->OrdSgn) return en;
       return an;
     }
     i=(an+en) / 2;
     if (pLmCmp(set[i].p,p->p) == currRing->OrdSgn) an=i;
     else                                 en=i;
     /*aend. fuer lazy == in !=- machen */
   }
 }

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

Definition at line 1046 of file kstd1.cc.

 {
   int j,dp,dL;
 
   if (length<0) return 0;
   if (hasPurePower(p,strat->lastAxis,&dp,strat))
   {
     int op= p->GetpFDeg() +p->ecart;
     for (j=length; j>=0; j--)
     {
       if (!hasPurePower(&(set[j]),strat->lastAxis,&dL,strat))
         return j+1;
       if (dp < dL)
         return j+1;
       if ((dp == dL)
           && (set[j].GetpFDeg()+set[j].ecart >= op))
         return j+1;
     }
   }
   j=length;
   loop
   {
     if (j<0) break;
     if (!hasPurePower(&(set[j]),strat->lastAxis,&dL,strat)) break;
     j--;
   }
   return strat->posInLOld(set,j,p,strat);
 }

int posInL11	(	const LSet	set,
		const int	length,
		LObject *	L,
		const kStrategy	strat
	)

Definition at line 5085 of file kutil.cc.

 {
   if (length<0) return 0;
 
   int o = p->GetpFDeg();
   int op = set[length].GetpFDeg();
 
   if ((op > o)
   || ((op == o) && (pLmCmp(set[length].p,p->p) != -currRing->OrdSgn)))
     return length+1;
   int i;
   int an = 0;
   int en= length;
   loop
   {
     if (an >= en-1)
     {
       op = set[an].GetpFDeg();
       if ((op > o)
       || ((op == o) && (pLmCmp(set[an].p,p->p) != -currRing->OrdSgn)))
         return en;
       return an;
     }
     i=(an+en) / 2;
     op = set[i].GetpFDeg();
     if ((op > o)
     || ((op == o) && (pLmCmp(set[i].p,p->p) != -currRing->OrdSgn)))
       an=i;
     else
       en=i;
   }
 }

int posInL110	(	const LSet	set,
		const int	length,
		LObject *	L,
		const kStrategy	strat
	)

Definition at line 5423 of file kutil.cc.

 {
   if (length<0) return 0;
 
   int o = p->GetpFDeg();
   int op = set[length].GetpFDeg();
 
   if ((op > o)
   || ((op == o) && (set[length].length >p->length))
   || ((op == o) && (set[length].length <= p->length)
      && (pLmCmp(set[length].p,p->p) != -currRing->OrdSgn)))
     return length+1;
   int i;
   int an = 0;
   int en= length;
   loop
   {
     if (an >= en-1)
     {
       op = set[an].GetpFDeg();
       if ((op > o)
       || ((op == o) && (set[an].length >p->length))
       || ((op == o) && (set[an].length <=p->length)
          && (pLmCmp(set[an].p,p->p) != -currRing->OrdSgn)))
         return en;
       return an;
     }
     i=(an+en) / 2;
     op = set[i].GetpFDeg();
     if ((op > o)
     || ((op == o) && (set[i].length > p->length))
     || ((op == o) && (set[i].length <= p->length)
        && (pLmCmp(set[i].p,p->p) != -currRing->OrdSgn)))
       an=i;
     else
       en=i;
   }
 }

int posInL11Ring	(	const LSet	set,
		const int	length,
		LObject *	L,
		const kStrategy	strat
	)

Definition at line 5143 of file kutil.cc.

 {
   if (length < 0) return 0;
   int an,en,i;
   an = 0;
   en = length+1;
   #if 0
   printf("\n----------------------\n");
   for(i=0;i<=length;i++)
     pWrite(set[i].p);
   printf("\n----------------------\n");
   #endif
   loop
   {
     if (an >= en-1)
     {
       if(an == en)
         return en;
       if (pLmCmp(set[an].p, p->p) == 1)
         return en;
       if (pLmCmp(set[an].p, p->p) == -1)
         return an;
       if (pLmCmp(set[an].p, p->p) == 0)
       {
         number lcset,lcp;
         lcset = pGetCoeff(set[an].p);
         lcp = pGetCoeff(p->p);
         if(!nGreaterZero(lcset))
         {
           set[an].p=p_Neg(set[an].p,currRing);
           if (set[an].t_p!=NULL)
             pSetCoeff0(set[an].t_p,pGetCoeff(set[an].p));
           lcset=pGetCoeff(set[an].p);
         }
         if(!nGreaterZero(lcp))
         {
           p->p=p_Neg(p->p,currRing);
           if (p->t_p!=NULL)
             pSetCoeff0(p->t_p,pGetCoeff(p->p));
           lcp=pGetCoeff(p->p);
         }
         if(nGreater(lcset, lcp))
         {
           return en;
         }
         else
         {
           return an;
         }
       }
     }
     i=(an+en) / 2;
     if (pLmCmp(set[i].p, p->p) == 1)
       an=i;
     if (pLmCmp(set[i].p, p->p) == -1)
       en=i;
     if (pLmCmp(set[i].p, p->p) == 0)
     {
       number lcset,lcp;
       lcset = pGetCoeff(set[i].p);
       lcp = pGetCoeff(p->p);
       if(!nGreaterZero(lcset))
       {
         set[i].p=p_Neg(set[i].p,currRing);
         if (set[i].t_p!=NULL)
           pSetCoeff0(set[i].t_p,pGetCoeff(set[i].p));
         lcset=pGetCoeff(set[i].p);
       }
       if(!nGreaterZero(lcp))
       {
         p->p=p_Neg(p->p,currRing);
         if (p->t_p!=NULL)
           pSetCoeff0(p->t_p,pGetCoeff(p->p));
         lcp=pGetCoeff(p->p);
       }
       if(nGreater(lcset, lcp))
       {
         an = i;
       }
       else
       {
         en = i;
       }
     }
   }
 }

int posInL11Ringls	(	const LSet	set,
		const int	length,
		LObject *	L,
		const kStrategy	strat
	)

Definition at line 5231 of file kutil.cc.

 {
   if (length < 0) return 0;
   int an,en,i;
   an = 0;
   en = length+1;
   #if 0
   printf("\n----------------------\n");
   for(i=0;i<=length;i++)
     pWrite(set[i].p);
   printf("\n----------------------\n");
   #endif
   loop
   {
     if (an >= en-1)
     {
       if(an == en)
         return en;
       if (set[an].FDeg > p->FDeg)
         return en;
       if (set[an].FDeg < p->FDeg)
         return an;
       if (set[an].FDeg == p->FDeg)
       {
         number lcset,lcp;
         lcset = pGetCoeff(set[an].p);
         lcp = pGetCoeff(p->p);
         if(!nGreaterZero(lcset))
         {
           set[an].p=p_Neg(set[an].p,currRing);
           if (set[an].t_p!=NULL)
             pSetCoeff0(set[an].t_p,pGetCoeff(set[an].p));
           lcset=pGetCoeff(set[an].p);
         }
         if(!nGreaterZero(lcp))
         {
           p->p=p_Neg(p->p,currRing);
           if (p->t_p!=NULL)
             pSetCoeff0(p->t_p,pGetCoeff(p->p));
           lcp=pGetCoeff(p->p);
         }
         if(nGreater(lcset, lcp))
         {
           return en;
         }
         else
         {
           return an;
         }
       }
     }
     i=(an+en) / 2;
     if (set[i].FDeg > p->FDeg)
       an=i;
     if (set[i].FDeg < p->FDeg)
       en=i;
     if (set[i].FDeg == p->FDeg)
     {
       number lcset,lcp;
       lcset = pGetCoeff(set[i].p);
       lcp = pGetCoeff(p->p);
       if(!nGreaterZero(lcset))
       {
         set[i].p=p_Neg(set[i].p,currRing);
         if (set[i].t_p!=NULL)
           pSetCoeff0(set[i].t_p,pGetCoeff(set[i].p));
         lcset=pGetCoeff(set[i].p);
       }
       if(!nGreaterZero(lcp))
       {
         p->p=p_Neg(p->p,currRing);
         if (p->t_p!=NULL)
           pSetCoeff0(p->t_p,pGetCoeff(p->p));
         lcp=pGetCoeff(p->p);
       }
       if(nGreater(lcset, lcp))
       {
         an = i;
       }
       else
       {
         en = i;
       }
     }
   }
 }

int posInL13	(	const LSet	set,
		const int	length,
		LObject *	L,
		const kStrategy	strat
	)

Definition at line 5469 of file kutil.cc.

 {
   if (length<0) return 0;
 
   int o = p->GetpFDeg();
 
   if (set[length].GetpFDeg() > o)
     return length+1;
 
   int i;
   int an = 0;
   int en= length;
   loop
   {
     if (an >= en-1)
     {
       if (set[an].GetpFDeg() >= o)
         return en;
       return an;
     }
     i=(an+en) / 2;
     if (set[i].GetpFDeg() >= o)
       an=i;
     else
       en=i;
   }
 }

int posInL15	(	const LSet	set,
		const int	length,
		LObject *	L,
		const kStrategy	strat
	)

Definition at line 5504 of file kutil.cc.

 {
   if (length<0) return 0;
 
   int o = p->GetpFDeg() + p->ecart;
   int op = set[length].GetpFDeg() + set[length].ecart;
 
   if ((op > o)
   || ((op == o) && (pLmCmp(set[length].p,p->p) != -currRing->OrdSgn)))
     return length+1;
   int i;
   int an = 0;
   int en= length;
   loop
   {
     if (an >= en-1)
     {
       op = set[an].GetpFDeg() + set[an].ecart;
       if ((op > o)
       || ((op == o) && (pLmCmp(set[an].p,p->p) != -currRing->OrdSgn)))
         return en;
       return an;
     }
     i=(an+en) / 2;
     op = set[i].GetpFDeg() + set[i].ecart;
     if ((op > o)
     || ((op == o) && (pLmCmp(set[i].p,p->p) != -currRing->OrdSgn)))
       an=i;
     else
       en=i;
   }
 }

int posInL17	(	const LSet	set,
		const int	length,
		LObject *	L,
		const kStrategy	strat
	)

Definition at line 5562 of file kutil.cc.

 {
   if (length<0) return 0;
 
   int o = p->GetpFDeg() + p->ecart;
 
   if ((set[length].GetpFDeg() + set[length].ecart > o)
   || ((set[length].GetpFDeg() + set[length].ecart == o)
      && (set[length].ecart > p->ecart))
   || ((set[length].GetpFDeg() + set[length].ecart == o)
      && (set[length].ecart == p->ecart)
      && (pLmCmp(set[length].p,p->p) != -currRing->OrdSgn)))
     return length+1;
   int i;
   int an = 0;
   int en= length;
   loop
   {
     if (an >= en-1)
     {
       if ((set[an].GetpFDeg() + set[an].ecart > o)
       || ((set[an].GetpFDeg() + set[an].ecart == o)
          && (set[an].ecart > p->ecart))
       || ((set[an].GetpFDeg() + set[an].ecart == o)
          && (set[an].ecart == p->ecart)
          && (pLmCmp(set[an].p,p->p) != -currRing->OrdSgn)))
         return en;
       return an;
     }
     i=(an+en) / 2;
     if ((set[i].GetpFDeg() + set[i].ecart > o)
     || ((set[i].GetpFDeg() + set[i].ecart == o)
        && (set[i].ecart > p->ecart))
     || ((set[i].GetpFDeg() +set[i].ecart == o)
        && (set[i].ecart == p->ecart)
        && (pLmCmp(set[i].p,p->p) != -currRing->OrdSgn)))
       an=i;
     else
       en=i;
   }
 }

int posInLF5C	(	const LSet	set,
		const int	length,
		LObject *	L,
		const kStrategy	strat
	)

Definition at line 5073 of file kutil.cc.

 {
   return strat->Ll+1;
 }

int posInLRing	(	const LSet	set,
		const int	length,
		LObject *	L,
		const kStrategy	strat
	)

Definition at line 4964 of file kutil.cc.

 {
   if (length < 0) return 0;
   if (set[length].FDeg > p->FDeg)
         return length+1;
   if (set[length].FDeg == p->FDeg)
     if(set[length].GetpLength() > p->GetpLength())
           return length+1;
   int i;
   int an = 0;
   int en= length+1;
   loop
   {
     if (an >= en-1)
     {
       if(an == en)
         return en;
       if (set[an].FDeg > p->FDeg)
         return en;
       if(set[an].FDeg == p->FDeg)
       {
         if(set[an].GetpLength() > p->GetpLength())
           {return en;}
         else
           {
             if(set[an].GetpLength() == p->GetpLength())
             {
                 if(nGreater(set[an].p->coef, p->p->coef))
                 {
                     return en;
                 }
                 else
                 {
                     return an;
                 }
             }
             else
             {
                 return an;
             }
           }
       }
       else
         {return an;}
     }
     i=(an+en) / 2;
     if (set[i].FDeg > p->FDeg)
       an=i;
     else
     {
         if(set[i].FDeg == p->FDeg)
         {
             if(set[i].GetpLength() > p->GetpLength())
                 an=i;
             else
             {
                 if(set[i].GetpLength() == p->GetpLength())
                 {
                     if(nGreater(set[i].p->coef, p->p->coef))
                     {
                         an = i;
                     }
                     else
                     {
                         en = i;
                     }
                 }
                 else
                 {
                     en=i;
                 }
             }
         }
         else
             en=i;
     }
   }
 }

int posInLSig	(	const LSet	set,
		const int	length,
		LObject *	L,
		const kStrategy	strat
	)

Definition at line 4940 of file kutil.cc.

 {
 if (length<0) return 0;
 if (pLmCmp(set[length].sig,p->sig)== currRing->OrdSgn)
   return length+1;
 
 int i;
 int an = 0;
 int en= length;
 loop
 {
   if (an >= en-1)
   {
     if (pLmCmp(set[an].sig,p->sig) == currRing->OrdSgn) return en;
     return an;
   }
   i=(an+en) / 2;
   if (pLmCmp(set[i].sig,p->sig) == currRing->OrdSgn) an=i;
   else                                      en=i;
   /*aend. fuer lazy == in !=- machen */
 }
 }

int posInS	(	const kStrategy	strat,
		const int	length,
		const poly	p,
		const int	ecart_p
	)

Definition at line 4201 of file kutil.cc.

 {
   if(length==-1) return 0;
   polyset set=strat->S;
   int i;
   int an = 0;
   int en = length;
   int cmp_int = currRing->OrdSgn;
   if ((rHasMixedOrdering(currRing))
 #ifdef HAVE_PLURAL
   && (currRing->real_var_start==0)
 #endif
 #if 0
   || ((strat->ak>0) && ((currRing->order[0]==ringorder_c)||((currRing->order[0]==ringorder_C))))
 #endif
   )
   {
     int o=p_Deg(p,currRing);
     int oo=p_Deg(set[length],currRing);
 
     if ((oo<o)
     || ((o==oo) && (pLmCmp(set[length],p)!= cmp_int)))
       return length+1;
 
     loop
     {
       if (an >= en-1)
       {
         if ((p_Deg(set[an],currRing)>=o) && (pLmCmp(set[an],p) == cmp_int))
         {
           return an;
         }
         return en;
       }
       i=(an+en) / 2;
       if ((p_Deg(set[i],currRing)>=o) && (pLmCmp(set[i],p) == cmp_int)) en=i;
       else                              an=i;
     }
   }
   else
   {
 #ifdef HAVE_RINGS
     if (rField_is_Ring(currRing))
     {
       if (pLmCmp(set[length],p)== -cmp_int)
         return length+1;
       int cmp;
       loop
       {
         if (an >= en-1)
         {
           cmp = pLmCmp(set[an],p);
           if (cmp == cmp_int)  return an;
           if (cmp == -cmp_int) return en;
           if (n_DivBy(pGetCoeff(p), pGetCoeff(set[an]), currRing->cf)) return en;
           return an;
         }
         i = (an+en) / 2;
         cmp = pLmCmp(set[i],p);
         if (cmp == cmp_int)         en = i;
         else if (cmp == -cmp_int)   an = i;
         else
         {
           if (n_DivBy(pGetCoeff(p), pGetCoeff(set[i]), currRing->cf)) an = i;
           else en = i;
         }
       }
     }
     else
 #endif
     if (pLmCmp(set[length],p)== -cmp_int)
       return length+1;
 
     loop
     {
       if (an >= en-1)
       {
         if (pLmCmp(set[an],p) == cmp_int) return an;
         if (pLmCmp(set[an],p) == -cmp_int) return en;
         if ((cmp_int!=1)
         && ((strat->ecartS[an])>ecart_p))
           return an;
         return en;
       }
       i=(an+en) / 2;
       if (pLmCmp(set[i],p) == cmp_int) en=i;
       else if (pLmCmp(set[i],p) == -cmp_int) an=i;
       else
       {
         if ((cmp_int!=1)
         &&((strat->ecartS[i])<ecart_p))
           en=i;
         else
           an=i;
       }
     }
   }
 }

int posInSyz	(	const kStrategy	strat,
		const poly	sig
	)

Definition at line 5045 of file kutil.cc.

 {
 if (strat->syzl==0) return 0;
 if (pLmCmp(strat->syz[strat->syzl-1],sig) != currRing->OrdSgn)
   return strat->syzl;
 int i;
 int an = 0;
 int en= strat->syzl-1;
 loop
 {
   if (an >= en-1)
   {
     if (pLmCmp(strat->syz[an],sig) != currRing->OrdSgn) return en;
     return an;
   }
   i=(an+en) / 2;
   if (pLmCmp(strat->syz[i],sig) != currRing->OrdSgn) an=i;
   else                                      en=i;
   /*aend. fuer lazy == in !=- machen */
 }
 }

int posInT0	(	const TSet	set,
		const int	length,
		LObject &	p
	)

Definition at line 4306 of file kutil.cc.

 {
   return (length+1);
 }

int posInT1	(	const TSet	set,
		const int	length,
		LObject &	p
	)

Definition at line 4317 of file kutil.cc.

 {
   if (length==-1) return 0;
 
   if (pLmCmp(set[length].p,p.p)!= currRing->OrdSgn) return length+1;
 
   int i;
   int an = 0;
   int en= length;
 
   loop
   {
     if (an >= en-1)
     {
       if (pLmCmp(set[an].p,p.p) == currRing->OrdSgn) return an;
       return en;
     }
     i=(an+en) / 2;
     if (pLmCmp(set[i].p,p.p) == currRing->OrdSgn) en=i;
     else                                 an=i;
   }
 }

int posInT11	(	const TSet	set,
		const int	length,
		LObject &	p
	)

Definition at line 4375 of file kutil.cc.

 {
   if (length==-1) return 0;
 
   int o = p.GetpFDeg();
   int op = set[length].GetpFDeg();
 
   if ((op < o)
   || ((op == o) && (pLmCmp(set[length].p,p.p) != currRing->OrdSgn)))
     return length+1;
 
   int i;
   int an = 0;
   int en= length;
 
   loop
   {
     if (an >= en-1)
     {
       op= set[an].GetpFDeg();
       if ((op > o)
       || (( op == o) && (pLmCmp(set[an].p,p.p) == currRing->OrdSgn)))
         return an;
       return en;
     }
     i=(an+en) / 2;
     op = set[i].GetpFDeg();
     if (( op > o)
     || (( op == o) && (pLmCmp(set[i].p,p.p) == currRing->OrdSgn)))
       en=i;
     else
       an=i;
   }
 }

int posInT110	(	const TSet	set,
		const int	length,
		LObject &	p
	)

Definition at line 4508 of file kutil.cc.

 {
   p.GetpLength();
   if (length==-1) return 0;
 
   int o = p.GetpFDeg();
   int op = set[length].GetpFDeg();
 
   if (( op < o)
   || (( op == o) && (set[length].length<p.length))
   || (( op == o) && (set[length].length == p.length)
      && (pLmCmp(set[length].p,p.p) != currRing->OrdSgn)))
     return length+1;
 
   int i;
   int an = 0;
   int en= length;
   loop
   {
     if (an >= en-1)
     {
       op = set[an].GetpFDeg();
       if (( op > o)
       || (( op == o) && (set[an].length > p.length))
       || (( op == o) && (set[an].length == p.length)
          && (pLmCmp(set[an].p,p.p) == currRing->OrdSgn)))
         return an;
       return en;
     }
     i=(an+en) / 2;
     op = set[i].GetpFDeg();
     if (( op > o)
     || (( op == o) && (set[i].length > p.length))
     || (( op == o) && (set[i].length == p.length)
        && (pLmCmp(set[i].p,p.p) == currRing->OrdSgn)))
       en=i;
     else
       an=i;
   }
 }

int posInT13	(	const TSet	set,
		const int	length,
		LObject &	p
	)

Definition at line 4554 of file kutil.cc.

 {
   if (length==-1) return 0;
 
   int o = p.GetpFDeg();
 
   if (set[length].GetpFDeg() <= o)
     return length+1;
 
   int i;
   int an = 0;
   int en= length;
   loop
   {
     if (an >= en-1)
     {
       if (set[an].GetpFDeg() > o)
         return an;
       return en;
     }
     i=(an+en) / 2;
     if (set[i].GetpFDeg() > o)
       en=i;
     else
       an=i;
   }
 }

int posInT15	(	const TSet	set,
		const int	length,
		LObject &	p
	)

Definition at line 4622 of file kutil.cc.

 {
   if (length==-1) return 0;
 
   int o = p.GetpFDeg() + p.ecart;
   int op = set[length].GetpFDeg()+set[length].ecart;
 
   if ((op < o)
   || ((op == o)
      && (pLmCmp(set[length].p,p.p) != currRing->OrdSgn)))
     return length+1;
 
   int i;
   int an = 0;
   int en= length;
   loop
   {
     if (an >= en-1)
     {
       op = set[an].GetpFDeg()+set[an].ecart;
       if (( op > o)
       || (( op  == o) && (pLmCmp(set[an].p,p.p) == currRing->OrdSgn)))
         return an;
       return en;
     }
     i=(an+en) / 2;
     op = set[i].GetpFDeg()+set[i].ecart;
     if (( op > o)
     || (( op == o) && (pLmCmp(set[i].p,p.p) == currRing->OrdSgn)))
       en=i;
     else
       an=i;
   }
 }

int posInT17	(	const TSet	set,
		const int	length,
		LObject &	p
	)

Definition at line 4680 of file kutil.cc.

 {
   if (length==-1) return 0;
 
   int o = p.GetpFDeg() + p.ecart;
   int op = set[length].GetpFDeg()+set[length].ecart;
 
   if ((op < o)
   || (( op == o) && (set[length].ecart > p.ecart))
   || (( op == o) && (set[length].ecart==p.ecart)
      && (pLmCmp(set[length].p,p.p) != currRing->OrdSgn)))
     return length+1;
 
   int i;
   int an = 0;
   int en= length;
   loop
   {
     if (an >= en-1)
     {
       op = set[an].GetpFDeg()+set[an].ecart;
       if (( op > o)
       || (( op == o) && (set[an].ecart < p.ecart))
       || (( op  == o) && (set[an].ecart==p.ecart)
          && (pLmCmp(set[an].p,p.p) == currRing->OrdSgn)))
         return an;
       return en;
     }
     i=(an+en) / 2;
     op = set[i].GetpFDeg()+set[i].ecart;
     if ((op > o)
     || (( op == o) && (set[i].ecart < p.ecart))
     || (( op == o) && (set[i].ecart == p.ecart)
        && (pLmCmp(set[i].p,p.p) == currRing->OrdSgn)))
       en=i;
     else
       an=i;
   }
 }

int posInT19	(	const TSet	set,
		const int	length,
		LObject &	p
	)

Definition at line 4809 of file kutil.cc.

 {
   p.GetpLength();
   if (length==-1) return 0;
 
   int o = p.ecart;
   int op=p.GetpFDeg();
 
   if (set[length].ecart < o)
     return length+1;
   if (set[length].ecart == o)
   {
      int oo=set[length].GetpFDeg();
      if ((oo < op) || ((oo==op) && (set[length].length < p.length)))
        return length+1;
   }
 
   int i;
   int an = 0;
   int en= length;
   loop
   {
     if (an >= en-1)
     {
       if (set[an].ecart > o)
         return an;
       if (set[an].ecart == o)
       {
          int oo=set[an].GetpFDeg();
          if((oo > op)
          || ((oo==op) && (set[an].length > p.length)))
            return an;
       }
       return en;
     }
     i=(an+en) / 2;
     if (set[i].ecart > o)
       en=i;
     else if (set[i].ecart == o)
     {
        int oo=set[i].GetpFDeg();
        if ((oo > op)
        || ((oo == op) && (set[i].length > p.length)))
          en=i;
        else
         an=i;
     }
     else
       an=i;
   }
 }

int posInT2	(	const TSet	set,
		const int	length,
		LObject &	p
	)

Definition at line 4345 of file kutil.cc.

 {
   p.GetpLength();
   if (length==-1)
     return 0;
   if (set[length].length<p.length)
     return length+1;
 
   int i;
   int an = 0;
   int en= length;
 
   loop
   {
     if (an >= en-1)
     {
       if (set[an].length>p.length) return an;
       return en;
     }
     i=(an+en) / 2;
     if (set[i].length>p.length) en=i;
     else                        an=i;
   }
 }

int posInT_EcartpLength	(	const TSet	set,
		const int	length,
		LObject &	p
	)

Definition at line 4583 of file kutil.cc.

 {
   int ol = p.GetpLength();
   if (length==-1) return 0;
 
   int op=p.ecart;
 
   int oo=set[length].ecart;
   if ((oo < op) || ((oo==op) && (set[length].length < ol)))
     return length+1;
 
   int i;
   int an = 0;
   int en= length;
   loop
     {
       if (an >= en-1)
       {
         int oo=set[an].ecart;
         if((oo > op)
            || ((oo==op) && (set[an].pLength > ol)))
           return an;
         return en;
       }
       i=(an+en) / 2;
       int oo=set[i].ecart;
       if ((oo > op)
           || ((oo == op) && (set[i].pLength > ol)))
         en=i;
       else
         an=i;
     }
 }

int posInTSig	(	const TSet	set,
		const int	length,
		LObject &	p
	)

void postReduceByMon	(	LObject *	h,
		kStrategy	strat
	)

used for GB over ZZ: intermediate reduction by monomial elements background: any known constant element of ideal suppresses intermediate coefficient swell

Definition at line 9225 of file kutil.cc.

 {
   if(!nCoeff_is_Ring_Z(currRing->cf))
       return;
   poly pH = h->GetP();
   poly p,pp;
   p = pH;
   bool deleted = FALSE, ok = FALSE;
   for(int i = 0; i<=strat->sl; i++)
   {
     p = pH;
     if(pNext(strat->S[i]) == NULL)
     {
       //pWrite(p);
       //pWrite(strat->S[i]);
       while(ok == FALSE)
       {
         if(pLmDivisibleBy(strat->S[i], p))
         {
           number dummy = n_IntMod(p->coef, strat->S[i]->coef, currRing->cf);
           p_SetCoeff(p,dummy,currRing);
         }
         if(nIsZero(p->coef))
         {
           pLmDelete(&p);
           deleted = TRUE;
         }
         else
         {
           ok = TRUE;
         }
       }
       pp = pNext(p);
       while(pp != NULL)
       {
         if(pLmDivisibleBy(strat->S[i], pp))
         {
           number dummy = n_IntMod(pp->coef, strat->S[i]->coef, currRing->cf);
           p_SetCoeff(pp,dummy,currRing);
           if(nIsZero(pp->coef))
           {
             pLmDelete(&pNext(p));
             pp = pNext(p);
             deleted = TRUE;
           }
           else
           {
             p = pp;
             pp = pNext(p);
           }
         }
         else
         {
           p = pp;
           pp = pNext(p);
         }
       }
     }
   }
   h->SetLmCurrRing();
   if(deleted)
     strat->initEcart(h);
 }

poly preIntegerCheck	(	ideal	F,
		ideal	Q
	)

used for GB over ZZ: look for constant and monomial elements in the ideal background: any known constant element of ideal suppresses intermediate coefficient swell

Definition at line 9052 of file kutil.cc.

 {
   assume(nCoeff_is_Ring_Z(currRing->cf));
   if(!nCoeff_is_Ring_Z(currRing->cf))
     return NULL;
   ideal F = idCopy(FOrig);
   idSkipZeroes(F);
   poly pmon;
   ring origR = currRing;
   ideal monred = idInit(1,1);
   for(int i=0; i<idElem(F); i++)
   {
     if(pNext(F->m[i]) == NULL)
         idInsertPoly(monred, F->m[i]);
   }
   int posconst = idPosConstant(F);
   if((posconst != -1) && (!nIsZero(F->m[posconst]->coef)))
   {
       pmon = pCopy(F->m[posconst]);
       idDelete(&F);
       idDelete(&monred);
       return pmon;
   }
   int idelemQ = 0;
   if(Q!=NULL)
   {
       idelemQ = IDELEMS(Q);
       for(int i=0; i<idelemQ; i++)
       {
         if(pNext(Q->m[i]) == NULL)
             idInsertPoly(monred, Q->m[i]);
       }
       idSkipZeroes(monred);
       posconst = idPosConstant(monred);
       //the constant, if found, will be from Q
       if((posconst != -1) && (!nIsZero(monred->m[posconst]->coef)))
       {
           pmon = pCopy(monred->m[posconst]);
           idDelete(&F);
           idDelete(&monred);
           return pmon;
       }
   }
   ring QQ_ring = rCopy0(currRing,FALSE);
   nKillChar(QQ_ring->cf);
   QQ_ring->cf = nInitChar(n_Q, NULL);
   rComplete(QQ_ring,1);
   QQ_ring = rAssure_c_dp(QQ_ring);
   rChangeCurrRing(QQ_ring);
   nMapFunc nMap = n_SetMap(origR->cf, QQ_ring->cf);
   ideal II = idInit(IDELEMS(F)+idelemQ+2,id_RankFreeModule(F, origR));
   for(int i = 0, j = 0; i<IDELEMS(F); i++)
       II->m[j++] = prMapR(F->m[i], nMap, origR, QQ_ring);
   for(int i = 0, j = IDELEMS(F); i<idelemQ; i++)
       II->m[j++] = prMapR(Q->m[i], nMap, origR, QQ_ring);
   ideal one = kStd(II, NULL, isNotHomog, NULL);
   idSkipZeroes(one);
   if(idIsConstant(one))
   {
       //one should be <1>
       for(int i = IDELEMS(II)-1; i>=0; i--)
           if(II->m[i] != NULL)
               II->m[i+1] = II->m[i];
       II->m[0] = pOne();
       ideal syz = idSyzygies(II, isNotHomog, NULL);
       poly integer = NULL;
       for(int i = IDELEMS(syz)-1;i>=0; i--)
       {
           if(pGetComp(syz->m[i]) == 1)
           {
               if(pIsConstant(syz->m[i]))
               {
                   integer = pHead(syz->m[i]);
                   pSetComp(integer, 0);
                   break;
               }
           }
       }
       rChangeCurrRing(origR);
       nMapFunc nMap2 = n_SetMap(QQ_ring->cf, origR->cf);
       pmon = prMapR(integer, nMap2, QQ_ring, origR);
       idDelete(&F);
       idDelete(&monred);
       idDelete(&II);
       idDelete(&one);
       idDelete(&syz);
       pDelete(&integer);
       rDelete(QQ_ring);
       return pmon;
   }
   else
   {
     if(idIs0(monred))
     {
       poly mindegmon = NULL;
       for(int i = 0; i<IDELEMS(one); i++)
       {
         if(pNext(one->m[i]) == NULL)
         {
           if(mindegmon == NULL)
             mindegmon = one->m[i];
           else
           {
             if(p_Deg(one->m[i], QQ_ring) < p_Deg(mindegmon, QQ_ring))
               mindegmon = one->m[i];
           }
         }
       }
       if(mindegmon != NULL)
       {
           for(int i = IDELEMS(II)-1; i>=0; i--)
               if(II->m[i] != NULL)
                   II->m[i+1] = II->m[i];
           II->m[0] = mindegmon;
           ideal syz = idSyzygies(II, isNotHomog, NULL);
           bool found = FALSE;
           for(int i = IDELEMS(syz)-1;i>=0; i--)
           {
               if(pGetComp(syz->m[i]) == 1)
               {
                   if(pIsConstant(syz->m[i]))
                   {
                       pSetCoeff(mindegmon, syz->m[i]->coef);
                       found = TRUE;
                         break;
                   }
               }
           }
           idDelete(&syz);
           if (found == FALSE)
           {
               rChangeCurrRing(origR);
               idDelete(&F);
               idDelete(&monred);
               idDelete(&II);
               idDelete(&one);
               pDelete(&mindegmon);
               pDelete(&pmon);
               rDelete(QQ_ring);
               return NULL;
           }
           rChangeCurrRing(origR);
           nMapFunc nMap2 = n_SetMap(QQ_ring->cf, origR->cf);
           pmon = prMapR(mindegmon, nMap2, QQ_ring, origR);
           idDelete(&F);
           idDelete(&monred);
           idDelete(&II);
           idDelete(&one);
           idDelete(&syz);
           pDelete(&mindegmon);
           rDelete(QQ_ring);
           return pmon;
       }
       else
           rChangeCurrRing(origR);
       pDelete(&mindegmon);
     }
     else
       rChangeCurrRing(origR);
   }
   idDelete(&F);
   idDelete(&monred);
   idDelete(&II);
   idDelete(&one);
   pDelete(&pmon);
   rDelete(QQ_ring);
   return NULL;
 }

int redFirstShift	(	LObject *	h,
		kStrategy	strat
	)

Definition at line 3440 of file kstd2.cc.

 {
   if (h->IsNull()) return 0;
 
   int at, reddeg,d;
   int pass = 0;
   int j = 0;
 
   if (! strat->homog)
   {
     d = h->GetpFDeg() + h->ecart;
     reddeg = strat->LazyDegree+d;
   }
   h->SetShortExpVector();
   loop
   {
     j = kFindDivisibleByInT(strat, h);
     if (j < 0)
     {
       h->SetDegStuffReturnLDeg(strat->LDegLast);
       return 1;
     }
 
     if (!TEST_OPT_INTSTRATEGY)
       strat->T[j].pNorm();
 #ifdef KDEBUG
     if (TEST_OPT_DEBUG)
     {
       PrintS("reduce ");
       h->wrp();
       PrintS(" with ");
       strat->T[j].wrp();
     }
 #endif
     ksReducePoly(h, &(strat->T[j]), strat->kNoetherTail(), NULL, strat);
     if (!h->IsNull())
     {
       poly qq=p_Shrink(h->GetTP(),strat->lV,strat->tailRing);
       h->p=NULL;
       h->t_p=qq;
       if (qq!=NULL) h->GetP(strat->lmBin);
     }
 
 #ifdef KDEBUG
     if (TEST_OPT_DEBUG)
     {
       PrintS(" to ");
       wrp(h->p);
       PrintLn();
     }
 #endif
     if (h->IsNull())
     {
       if (h->lcm!=NULL) pLmFree(h->lcm);
       h->Clear();
       return 0;
     }
     h->SetShortExpVector();
 
 #if 0
     if ((strat->syzComp!=0) && !strat->honey)
     {
       if ((strat->syzComp>0) &&
           (h->Comp() > strat->syzComp))
       {
         assume(h->MinComp() > strat->syzComp);
 #ifdef KDEBUG
         if (TEST_OPT_DEBUG) PrintS(" > syzComp\n");
 #endif
         if (strat->homog)
           h->SetDegStuffReturnLDeg(strat->LDegLast);
         return -2;
       }
     }
 #endif
     if (!strat->homog)
     {
       if (!TEST_OPT_OLDSTD && strat->honey)
       {
         h->SetpFDeg();
         if (strat->T[j].ecart <= h->ecart)
           h->ecart = d - h->GetpFDeg();
         else
           h->ecart = d - h->GetpFDeg() + strat->T[j].ecart - h->ecart;
 
         d = h->GetpFDeg() + h->ecart;
       }
       else
         d = h->SetDegStuffReturnLDeg(strat->LDegLast);
       /*- try to reduce the s-polynomial -*/
       pass++;
       /*
        *test whether the polynomial should go to the lazyset L
        *-if the degree jumps
        *-if the number of pre-defined reductions jumps
        */
       if (!TEST_OPT_REDTHROUGH && (strat->Ll >= 0)
           && ((d >= reddeg) || (pass > strat->LazyPass)))
       {
         h->SetLmCurrRing();
         if (strat->posInLDependsOnLength)
           h->SetLength(strat->length_pLength);
         at = strat->posInL(strat->L,strat->Ll,h,strat);
         if (at <= strat->Ll)
         {
           //int dummy=strat->sl;
           /*          if (kFindDivisibleByInS(strat,&dummy, h) < 0) */
           //if (kFindDivisibleByInT(strat->T,strat->sevT, dummy, h) < 0)
           if (kFindDivisibleByInT(strat, h) < 0)
             return 1;
           enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
 #ifdef KDEBUG
           if (TEST_OPT_DEBUG) Print(" degree jumped; ->L%d\n",at);
 #endif
           h->Clear();
           return -1;
         }
       }
       if ((TEST_OPT_PROT) && (strat->Ll < 0) && (d >= reddeg))
       {
         reddeg = d+1;
         Print(".%d",d);mflush();
       }
     }
   }
 }

int redHomog	(	LObject *	h,
		kStrategy	strat
	)

Definition at line 518 of file kstd2.cc.

 {
   if (strat->tl<0) return 1;
   //if (h->GetLmTailRing()==NULL) return 0; // HS: SHOULD NOT BE NEEDED!
   assume(h->FDeg == h->pFDeg());
 
   poly h_p;
   int i,j,at,pass, ii;
   unsigned long not_sev;
   // long reddeg,d;
 
   pass = j = 0;
   // d = reddeg = h->GetpFDeg();
   h->SetShortExpVector();
   int li;
   h_p = h->GetLmTailRing();
   not_sev = ~ h->sev;
   loop
   {
     j = kFindDivisibleByInT(strat, h);
     if (j < 0) return 1;
 
     li = strat->T[j].pLength;
     ii = j;
     /*
      * the polynomial to reduce with (up to the moment) is;
      * pi with length li
      */
     i = j;
 #if 1
     if (TEST_OPT_LENGTH)
     loop
     {
       /*- search the shortest possible with respect to length -*/
       i++;
       if (i > strat->tl)
         break;
       if (li<=1)
         break;
       if ((strat->T[i].pLength < li)
          &&
           p_LmShortDivisibleBy(strat->T[i].GetLmTailRing(), strat->sevT[i],
                                h_p, not_sev, strat->tailRing))
       {
         /*
          * the polynomial to reduce with is now;
          */
         li = strat->T[i].pLength;
         ii = i;
       }
     }
 #endif
 
     /*
      * end of search: have to reduce with pi
      */
 #ifdef KDEBUG
     if (TEST_OPT_DEBUG)
     {
       PrintS("red:");
       h->wrp();
       PrintS(" with ");
       strat->T[ii].wrp();
     }
 #endif
     assume(strat->fromT == FALSE);
 
     ksReducePoly(h, &(strat->T[ii]), NULL, NULL, strat);
 #if SBA_PRINT_REDUCTION_STEPS
     sba_interreduction_steps++;
 #endif
 #if SBA_PRINT_OPERATIONS
     sba_interreduction_operations  +=  pLength(strat->T[ii].p);
 #endif
 
 #ifdef KDEBUG
     if (TEST_OPT_DEBUG)
     {
       PrintS("\nto ");
       h->wrp();
       PrintLn();
     }
 #endif
 
     h_p = h->GetLmTailRing();
     if (h_p == NULL)
     {
       if (h->lcm!=NULL) pLmFree(h->lcm);
 #ifdef KDEBUG
       h->lcm=NULL;
 #endif
       return 0;
     }
     h->SetShortExpVector();
     not_sev = ~ h->sev;
     /*
      * try to reduce the s-polynomial h
      *test first whether h should go to the lazyset L
      *-if the degree jumps
      *-if the number of pre-defined reductions jumps
      */
     pass++;
     if (!TEST_OPT_REDTHROUGH && (strat->Ll >= 0) && (pass > strat->LazyPass))
     {
       h->SetLmCurrRing();
       at = strat->posInL(strat->L,strat->Ll,h,strat);
       if (at <= strat->Ll)
       {
         int dummy=strat->sl;
         if (kFindDivisibleByInS(strat, &dummy, h) < 0)
           return 1;
         enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
 #ifdef KDEBUG
         if (TEST_OPT_DEBUG)
           Print(" lazy: -> L%d\n",at);
 #endif
         h->Clear();
         return -1;
       }
     }
   }
 }

int redHoney	(	LObject *	h,
		kStrategy	strat
	)

Definition at line 1116 of file kstd2.cc.

 {
   if (strat->tl<0) return 1;
   //if (h->GetLmTailRing()==NULL) return 0; // HS: SHOULD NOT BE NEEDED!
   assume(h->FDeg == h->pFDeg());
   poly h_p;
   int i,j,at,pass,ei, ii, h_d;
   unsigned long not_sev;
   long reddeg,d;
 
   pass = j = 0;
   d = reddeg = h->GetpFDeg() + h->ecart;
   h->SetShortExpVector();
   int li;
   h_p = h->GetLmTailRing();
   not_sev = ~ h->sev;
 
   h->PrepareRed(strat->use_buckets);
   loop
   {
     j=kFindDivisibleByInT(strat, h);
     if (j < 0) return 1;
 
     ei = strat->T[j].ecart;
     li = strat->T[j].pLength;
     ii = j;
     /*
      * the polynomial to reduce with (up to the moment) is;
      * pi with ecart ei
      */
     i = j;
     if (TEST_OPT_LENGTH)
     loop
     {
       /*- takes the first possible with respect to ecart -*/
       i++;
       if (i > strat->tl)
         break;
       //if (ei < h->ecart)
       //  break;
       if (li<=1)
         break;
       if ((((strat->T[i].ecart < ei) && (ei> h->ecart))
          || ((strat->T[i].ecart <= h->ecart) && (strat->T[i].pLength < li)))
          &&
           p_LmShortDivisibleBy(strat->T[i].GetLmTailRing(), strat->sevT[i],
                                h_p, not_sev, strat->tailRing))
       {
         /*
          * the polynomial to reduce with is now;
          */
         ei = strat->T[i].ecart;
         li = strat->T[i].pLength;
         ii = i;
       }
     }
 
     /*
      * end of search: have to reduce with pi
      */
     if (!TEST_OPT_REDTHROUGH && (pass!=0) && (ei > h->ecart))
     {
       h->GetTP(); // clears bucket
       h->SetLmCurrRing();
       /*
        * It is not possible to reduce h with smaller ecart;
        * if possible h goes to the lazy-set L,i.e
        * if its position in L would be not the last one
        */
       if (strat->Ll >= 0) /* L is not empty */
       {
         at = strat->posInL(strat->L,strat->Ll,h,strat);
         if(at <= strat->Ll)
           /*- h will not become the next element to reduce -*/
         {
           enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
 #ifdef KDEBUG
           if (TEST_OPT_DEBUG) Print(" ecart too big: -> L%d\n",at);
 #endif
           h->Clear();
           return -1;
         }
       }
     }
 #ifdef KDEBUG
     if (TEST_OPT_DEBUG)
     {
       PrintS("red:");
       h->wrp();
       PrintS(" with ");
       strat->T[ii].wrp();
     }
 #endif
     assume(strat->fromT == FALSE);
 
     number coef;
     ksReducePoly(h,&(strat->T[ii]),strat->kNoetherTail(),&coef,strat);
 #if SBA_PRINT_REDUCTION_STEPS
     sba_interreduction_steps++;
 #endif
 #if SBA_PRINT_OPERATIONS
     sba_interreduction_operations  +=  pLength(strat->T[ii].p);
 #endif
 #ifdef KDEBUG
     if (TEST_OPT_DEBUG)
     {
       PrintS("\nto:");
       h->wrp();
       PrintLn();
     }
 #endif
     if(h->IsNull())
     {
       h->Clear();
       if (h->lcm!=NULL) pLmFree(h->lcm);
       #ifdef KDEBUG
       h->lcm=NULL;
       #endif
       return 0;
     }
     if (TEST_OPT_IDLIFT)
     {
       if (h->p!=NULL)
       {
         if(p_GetComp(h->p,currRing)>strat->syzComp)
         {
           h->Delete();
           return 0;
         }
       }
       else if (h->t_p!=NULL)
       {
         if(p_GetComp(h->t_p,strat->tailRing)>strat->syzComp)
         {
           h->Delete();
           return 0;
         }
       }
     }
     h->SetShortExpVector();
     not_sev = ~ h->sev;
     h_d = h->SetpFDeg();
     /* compute the ecart */
     if (ei <= h->ecart)
       h->ecart = d-h_d;
     else
       h->ecart = d-h_d+ei-h->ecart;
 
     /*
      * try to reduce the s-polynomial h
      *test first whether h should go to the lazyset L
      *-if the degree jumps
      *-if the number of pre-defined reductions jumps
      */
     pass++;
     d = h_d + h->ecart;
     if (!TEST_OPT_REDTHROUGH && (strat->Ll >= 0) && ((d > reddeg) || (pass > strat->LazyPass)))
     {
       h->GetTP(); // clear bucket
       h->SetLmCurrRing();
       at = strat->posInL(strat->L,strat->Ll,h,strat);
       if (at <= strat->Ll)
       {
         int dummy=strat->sl;
         if (kFindDivisibleByInS(strat, &dummy, h) < 0)
           return 1;
         enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
 #ifdef KDEBUG
         if (TEST_OPT_DEBUG)
           Print(" degree jumped: -> L%d\n",at);
 #endif
         h->Clear();
         return -1;
       }
     }
     else if (d > reddeg)
     {
       if (d>=(long)strat->tailRing->bitmask)
       {
         if (h->pTotalDeg()+h->ecart >= (long)strat->tailRing->bitmask)
         {
           strat->overflow=TRUE;
           //Print("OVERFLOW in redHoney d=%ld, max=%ld\n",d,strat->tailRing->bitmask);
           h->GetP();
           at = strat->posInL(strat->L,strat->Ll,h,strat);
           enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
           h->Clear();
           return -1;
         }
       }
       else if (TEST_OPT_PROT && (strat->Ll < 0) )
       {
         //h->wrp(); Print("<%d>\n",h->GetpLength());
         reddeg = d;
         Print(".%ld",d); mflush();
       }
     }
   }
 }

int redLazy	(	LObject *	h,
		kStrategy	strat
	)

TEST_OPT_REDTHROUGH &&

Definition at line 956 of file kstd2.cc.

 {
   if (strat->tl<0) return 1;
   int at,i,ii,li;
   int j = 0;
   int pass = 0;
   assume(h->pFDeg() == h->FDeg);
   long reddeg = h->GetpFDeg();
   long d;
   unsigned long not_sev;
 
   h->SetShortExpVector();
   poly h_p = h->GetLmTailRing();
   not_sev = ~ h->sev;
   loop
   {
     j = kFindDivisibleByInT(strat, h);
     if (j < 0) return 1;
 
     li = strat->T[j].pLength;
     #if 0
     if (li==0)
     {
       li=strat->T[j].pLength=pLength(strat->T[j].p);
     }
     #endif
     ii = j;
     /*
      * the polynomial to reduce with (up to the moment) is;
      * pi with length li
      */
 
     i = j;
 #if 1
     if (TEST_OPT_LENGTH)
     loop
     {
       /*- search the shortest possible with respect to length -*/
       i++;
       if (i > strat->tl)
         break;
       if (li<=1)
         break;
     #if 0
       if (strat->T[i].pLength==0)
       {
         PrintS("!");
         strat->T[i].pLength=pLength(strat->T[i].p);
       }
    #endif
       if ((strat->T[i].pLength < li)
          &&
           p_LmShortDivisibleBy(strat->T[i].GetLmTailRing(), strat->sevT[i],
                                h_p, not_sev, strat->tailRing))
       {
         /*
          * the polynomial to reduce with is now;
          */
         PrintS("+");
         li = strat->T[i].pLength;
         ii = i;
       }
     }
 #endif
 
     /*
      * end of search: have to reduce with pi
      */
 
 
 #ifdef KDEBUG
     if (TEST_OPT_DEBUG)
     {
       PrintS("red:");
       h->wrp();
       PrintS(" with ");
       strat->T[ii].wrp();
     }
 #endif
 
     ksReducePoly(h, &(strat->T[ii]), NULL, NULL, strat);
 #if SBA_PRINT_REDUCTION_STEPS
     sba_interreduction_steps++;
 #endif
 #if SBA_PRINT_OPERATIONS
     sba_interreduction_operations  +=  pLength(strat->T[ii].p);
 #endif
 
 #ifdef KDEBUG
     if (TEST_OPT_DEBUG)
     {
       PrintS("\nto ");
       h->wrp();
       PrintLn();
     }
 #endif
 
     h_p=h->GetLmTailRing();
 
     if (h_p == NULL)
     {
       if (h->lcm!=NULL) pLmFree(h->lcm);
 #ifdef KDEBUG
       h->lcm=NULL;
 #endif
       return 0;
     }
     h->SetShortExpVector();
     not_sev = ~ h->sev;
     d = h->SetpFDeg();
     /*- try to reduce the s-polynomial -*/
     pass++;
     if (//!TEST_OPT_REDTHROUGH &&
         (strat->Ll >= 0) && ((d > reddeg) || (pass > strat->LazyPass)))
     {
       h->SetLmCurrRing();
       at = strat->posInL(strat->L,strat->Ll,h,strat);
       if (at <= strat->Ll)
       {
 #if 1
         int dummy=strat->sl;
         if (kFindDivisibleByInS(strat, &dummy, h) < 0)
           return 1;
 #endif
 #ifdef KDEBUG
         if (TEST_OPT_DEBUG) Print(" ->L[%d]\n",at);
 #endif
         enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
         h->Clear();
         return -1;
       }
     }
     else if (d != reddeg)
     {
       if (d>=(long)strat->tailRing->bitmask)
       {
         if (h->pTotalDeg() >= (long)strat->tailRing->bitmask)
         {
           strat->overflow=TRUE;
           //Print("OVERFLOW in redLazy d=%ld, max=%ld\n",d,strat->tailRing->bitmask);
           h->GetP();
           at = strat->posInL(strat->L,strat->Ll,h,strat);
           enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
           h->Clear();
           return -1;
         }
       }
       else if ((TEST_OPT_PROT) && (strat->Ll < 0))
       {
         Print(".%ld",d);mflush();
         reddeg = d;
       }
     }
   }
 }

poly redNF	(	poly	h,
		int &	max_ind,
		int	nonorm,
		kStrategy	strat
	)

Definition at line 1320 of file kstd2.cc.

 {
   if (h==NULL) return NULL;
   int j;
   max_ind=strat->sl;
 
   if (0 > strat->sl)
   {
     return h;
   }
   LObject P(h);
   P.SetShortExpVector();
   P.bucket = kBucketCreate(currRing);
   kBucketInit(P.bucket,P.p,pLength(P.p));
   kbTest(P.bucket);
 #ifdef HAVE_RINGS
   BOOLEAN is_ring = rField_is_Ring(currRing);
 #endif
 #ifdef KDEBUG
 //  if (TEST_OPT_DEBUG)
 //  {
 //    PrintS("redNF: starting S:\n");
 //    for( j = 0; j <= max_ind; j++ )
 //    {
 //      Print("S[%d] (of size: %d): ", j, pSize(strat->S[j]));
 //      pWrite(strat->S[j]);
 //    }
 //  };
 #endif
 
   loop
   {
     j=kFindDivisibleByInS(strat,&max_ind,&P);
     if (j>=0)
     {
 #ifdef HAVE_RINGS
       if (!is_ring)
       {
 #endif
         int sl=pSize(strat->S[j]);
         int jj=j;
         loop
         {
           int sll;
           jj=kFindNextDivisibleByInS(strat,jj+1,max_ind,&P);
           if (jj<0) break;
           sll=pSize(strat->S[jj]);
           if (sll<sl)
           {
             #ifdef KDEBUG
             if (TEST_OPT_DEBUG) Print("better(S%d:%d -> S%d:%d)\n",j,sl,jj,sll);
             #endif
             //else if (TEST_OPT_PROT) { PrintS("b"); mflush(); }
             j=jj;
             sl=sll;
           }
         }
         if ((nonorm==0) && (!nIsOne(pGetCoeff(strat->S[j]))))
         {
           pNorm(strat->S[j]);
           //if (TEST_OPT_PROT) { PrintS("n"); mflush(); }
         }
 #ifdef HAVE_RINGS
       }
 #endif
       nNormalize(pGetCoeff(P.p));
 #ifdef KDEBUG
       if (TEST_OPT_DEBUG)
       {
         PrintS("red:");
         wrp(h);
         PrintS(" with ");
         wrp(strat->S[j]);
       }
 #endif
 #ifdef HAVE_PLURAL
       if (rIsPluralRing(currRing))
       {
         number coef;
         nc_kBucketPolyRed(P.bucket,strat->S[j],&coef);
         nDelete(&coef);
       }
       else
 #endif
       {
         number coef;
         coef=kBucketPolyRed(P.bucket,strat->S[j],pLength(strat->S[j]),strat->kNoether);
         nDelete(&coef);
       }
       h = kBucketGetLm(P.bucket);   // FRAGE OLIVER
       if (h==NULL)
       {
         kBucketDestroy(&P.bucket);
 
 #ifdef KDEBUG
 //        if (TEST_OPT_DEBUG)
 //        {
 //          PrintS("redNF: starting S:\n");
 //          for( j = 0; j <= max_ind; j++ )
 //          {
 //            Print("S[%d] (of size: %d): ", j, pSize(strat->S[j]));
 //            pWrite(strat->S[j]);
 //          }
 //        };
 #endif
 
         return NULL;
       }
       kbTest(P.bucket);
       P.p=h;
       P.t_p=NULL;
       P.SetShortExpVector();
 #ifdef KDEBUG
       if (TEST_OPT_DEBUG)
       {
         PrintS("\nto:");
         wrp(h);
         PrintLn();
       }
 #endif
     }
     else
     {
       P.p=kBucketClear(P.bucket);
       kBucketDestroy(&P.bucket);
       pNormalize(P.p);
 
 #ifdef KDEBUG
 //      if (TEST_OPT_DEBUG)
 //      {
 //        PrintS("redNF: starting S:\n");
 //        for( j = 0; j <= max_ind; j++ )
 //        {
 //          Print("S[%d] (of size: %d): ", j, pSize(strat->S[j]));
 //          pWrite(strat->S[j]);
 //        }
 //      };
 #endif
 
       return P.p;
     }
   }
 }

int redNF0	(	LObject *	P,
		kStrategy	strat
	)

poly redNFTail	(	poly	h,
		const int	sl,
		kStrategy	strat
	)

int redRiloc	(	LObject *	h,
		kStrategy	strat
	)

Definition at line 355 of file kstd1.cc.

 {
   int i,at,ei,li,ii;
   int j = 0;
   int pass = 0;
   long d,reddeg;
 
 
 #if ADIDEBUG_NF
   int iii;
   PrintS("\n---------------------------- NEW REDRILOC COMPUTATION ----------------------------\n");
   PrintS("    The pair h :\n");
   PrintS("\n      p1 = "); p_Write(h->p1,strat->tailRing);
   PrintS("\n      p2 = "); p_Write(h->p2,strat->tailRing);
   PrintS("\n      p  = "); p_Write(h->p,strat->tailRing);
   PrintS("\n    The actual reducer T is: ");
   if(strat->tl<0)
     {PrintS(" Empty.\n");}
   else
   {
     for (iii=0;iii<=strat->tl;iii++)
     {
       Print("\n      T[%i] = ",iii);p_Write(strat->T[iii].p,strat->tailRing);
     }
   }
 #endif /* ADIDEBUG_NF */
 
   d = h->GetpFDeg()+ h->ecart;
   reddeg = strat->LazyDegree+d;
   h->SetShortExpVector();
 #if ADIDEBUG_NF
   Print("\n  Searching for a poly in T that divides h (of ecart %i) ...\n",h->ecart);
 #endif
   loop
   {
     j = kFindDivisibleByInT(strat, h);
 #if ADIDEBUG_NF
     if(j != -1)
     {
       ei = strat->T[j].ecart;
       Print("\n    Found one: T[%i] of ecart %i: ",j,ei);
       p_Write(strat->T[j].p,strat->tailRing);
       PrintS("\n    Try to find another with smaller ecart:\n");
     }
     else
     {
       PrintS("\n    No poly in T divides h.\n");
     }
     //getchar();
 #endif
     if (j < 0)
     {
       // over ZZ: cleanup coefficients by complete reduction with monomials
       postReduceByMon(h, strat);
       if(h->p == NULL)
       {
         if (h->lcm!=NULL) pLmDelete(h->lcm);
         h->Clear();
         return 0;
       }
       if (strat->honey) h->SetLength(strat->length_pLength);
       if(strat->tl >= 0)
           h->i_r1 = strat->tl;
       else
           h->i_r1 = -1;
       if (h->GetLmTailRing() == NULL)
       {
         if (h->lcm!=NULL) pLmDelete(h->lcm);
         h->Clear();
         return 0;
       }
       return 1;
     }
 
     ei = strat->T[j].ecart;
     ii = j;
 #if ADIDEBUG_NF
     iii=ii;
 #endif
     if (ei > h->ecart && ii < strat->tl)
     {
       li = strat->T[j].length;
       // the polynomial to reduce with (up to the moment) is;
       // pi with ecart ei and length li
       // look for one with smaller ecart
       i = j;
       loop
       {
         /*- takes the first possible with respect to ecart -*/
         i++;
 #if 1
         if (i > strat->tl) break;
         if ((strat->T[i].ecart < ei || (strat->T[i].ecart == ei &&
                                         strat->T[i].length < li))
             &&
             p_LmShortDivisibleBy(strat->T[i].GetLmTailRing(), strat->sevT[i], h->GetLmTailRing(), ~h->sev, strat->tailRing)
             &&
             n_DivBy(h->p->coef,strat->T[i].p->coef,strat->tailRing))
 #else
           j = kFindDivisibleByInT(strat, h, i);
         if (j < 0) break;
         i = j;
         if (strat->T[i].ecart < ei || (strat->T[i].ecart == ei &&
                                         strat->T[i].length < li))
 #endif
         {
           // the polynomial to reduce with is now
           #if ADIDEBUG_NF
           printf("\n    Intermidiate one, h.ecart = %i < ecart = %i < ei = %i: ",h->ecart,strat->T[i].ecart, ei);
           pWrite(strat->T[i].p);
           #endif
           ii = i;
           ei = strat->T[i].ecart;
           if (ei <= h->ecart) break;
           li = strat->T[i].length;
         }
       }
 
 #if ADIDEBUG_NF
       if(iii == ii)
       {
         PrintS("\n    None was found.\n");
       }
       else
       {
         Print("\n    A better one (ecart = %i): T[%i] = ",ei,ii);
         p_Write(strat->T[ii].p,strat->tailRing);
         PrintLn();
       }
 #endif
     }
 
     // end of search: have to reduce with pi
     if (ei > h->ecart)
     {
       #if ADIDEBUG_NF
       printf("\nHAD TO REDUCE WITH BIGGER ECART!!!\n");
       #endif
       // It is not possible to reduce h with smaller ecart;
       // if possible h goes to the lazy-set L,i.e
       // if its position in L would be not the last one
       strat->fromT = TRUE;
       if (!TEST_OPT_REDTHROUGH && strat->Ll >= 0) /*- L is not empty -*/
       {
         h->SetLmCurrRing();
         if (strat->honey && strat->posInLDependsOnLength)
           h->SetLength(strat->length_pLength);
         assume(h->FDeg == h->pFDeg());
         at = strat->posInL(strat->L,strat->Ll,h,strat);
         #if 0
         //#ifdef HAVE_RINGS
         if(rField_is_Ring(currRing))
           strat->fromT=FALSE;
         #endif
         if (at <= strat->Ll && pLmCmp(h->p, strat->L[strat->Ll].p) != 0 && !nEqual(h->p->coef, strat->L[strat->Ll].p->coef))
         {
           /*- h will not become the next element to reduce -*/
           enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
           #ifdef KDEBUG
           if (TEST_OPT_DEBUG) Print(" ecart too big; -> L%d\n",at);
           #endif
           h->Clear();
           strat->fromT = FALSE;
           return -1;
         }
       }
       doRed(h,&(strat->T[ii]),strat->fromT,strat,TRUE);
     }
     else
     {
       // now we finally can reduce
       doRed(h,&(strat->T[ii]),strat->fromT,strat,FALSE);
     }
     strat->fromT=FALSE;
     // are we done ???
     if (h->IsNull())
     {
       #if ADIDEBUG_NF
       printf("\nReduced to 0. Exit\n");
       #endif
       if (h->lcm!=NULL) pLmDelete(h->lcm);
       h->Clear();
       return 0;
     }
 
     // NO!
     h->SetShortExpVector();
     h->SetpFDeg();
     if (strat->honey)
     {
       if (ei <= h->ecart)
         h->ecart = d-h->GetpFDeg();
       else
         h->ecart = d-h->GetpFDeg()+ei-h->ecart;
     }
     else
       // this has the side effect of setting h->length
       h->ecart = h->pLDeg(strat->LDegLast) - h->GetpFDeg();
     #if ADIDEBUG_NF
     printf("\n  Partial Reduced (ecart %i) h = ",h->ecart);p_Write(h->p,strat->tailRing);
     PrintLn();
     #endif
     /*- try to reduce the s-polynomial -*/
     pass++;
     d = h->GetpFDeg()+h->ecart;
     /*
      *test whether the polynomial should go to the lazyset L
      *-if the degree jumps
      *-if the number of pre-defined reductions jumps
      */
     if (!TEST_OPT_REDTHROUGH && (strat->Ll >= 0)
         && ((d >= reddeg) || (pass > strat->LazyPass)))
     {
       h->SetLmCurrRing();
       if (strat->honey && strat->posInLDependsOnLength)
         h->SetLength(strat->length_pLength);
       assume(h->FDeg == h->pFDeg());
       at = strat->posInL(strat->L,strat->Ll,h,strat);
       if (at <= strat->Ll)
       {
         int dummy=strat->sl;
         if (kFindDivisibleByInS(strat, &dummy, h) < 0)
         {
           if (strat->honey && !strat->posInLDependsOnLength)
             h->SetLength(strat->length_pLength);
           return 1;
         }
         enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
 #ifdef KDEBUG
         if (TEST_OPT_DEBUG) Print(" degree jumped; ->L%d\n",at);
 #endif
         h->Clear();
         return -1;
       }
     }
     else if ((TEST_OPT_PROT) && (strat->Ll < 0) && (d >= reddeg))
     {
       Print(".%ld",d);mflush();
       reddeg = d+1;
       if (h->pTotalDeg()+h->ecart >= (int)strat->tailRing->bitmask)
       {
         strat->overflow=TRUE;
         //Print("OVERFLOW in redEcart d=%ld, max=%ld",d,strat->tailRing->bitmask);
         h->GetP();
         at = strat->posInL(strat->L,strat->Ll,h,strat);
         enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
         h->Clear();
         return -1;
       }
     }
   }
 }

int redRing	(	LObject *	h,
		kStrategy	strat
	)

Definition at line 409 of file kstd2.cc.

 {
   if (h->IsNull()) return 0; // spoly is zero (can only occure with zero divisors)
   if (strat->tl<0) return 1;
 
   int at/*,i*/;
   long d;
   int j = 0;
   int pass = 0;
   // poly zeroPoly = NULL;
 
 // TODO warum SetpFDeg notwendig?
   h->SetpFDeg();
   assume(h->pFDeg() == h->FDeg);
   long reddeg = h->GetpFDeg();
 
   h->SetShortExpVector();
   loop
   {
     j = kFindDivisibleByInT(strat, h);
     if (j < 0)
     {
       // over ZZ: cleanup coefficients by complete reduction with monomials
       postReduceByMon(h, strat);
       if(nIsZero(pGetCoeff(h->p))) return 2;
       j = kFindDivisibleByInT(strat, h);
       if(j < 0)
       {
         if(strat->tl >= 0)
             h->i_r1 = strat->tl;
         else
             h->i_r1 = -1;
         if (h->GetLmTailRing() == NULL)
         {
           if (h->lcm!=NULL) pLmDelete(h->lcm);
           h->Clear();
           return 0;
         }
         return 1;
       }
     }
     #if ADIDEBUG
     pWrite(h->p);
     printf("\nFound j = %i\n",j);pWrite(strat->T[j].p);
     #endif
     ksReducePoly(h, &(strat->T[j]), NULL, NULL, strat); // with debug output
     #if ADIDEBUG
     printf("\nand after reduce: \n");pWrite(h->p);
     #endif
 
     if (h->GetLmTailRing() == NULL)
     {
       if (h->lcm!=NULL) pLmDelete(h->lcm);
 #ifdef KDEBUG
       h->lcm=NULL;
 #endif
       h->Clear();
       return 0;
     }
     h->SetShortExpVector();
     d = h->SetpFDeg();
     /*- try to reduce the s-polynomial -*/
     pass++;
     if (!TEST_OPT_REDTHROUGH &&
         (strat->Ll >= 0) && ((d > reddeg) || (pass > strat->LazyPass)))
     {
       h->SetLmCurrRing();
       if (strat->posInLDependsOnLength)
         h->SetLength(strat->length_pLength);
       at = strat->posInL(strat->L,strat->Ll,h,strat);
       if (at <= strat->Ll)
       {
 #ifdef KDEBUG
         if (TEST_OPT_DEBUG) Print(" ->L[%d]\n",at);
 #endif
         enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);     // NOT RING CHECKED OLIVER
         h->Clear();
         return -1;
       }
     }
     if (d != reddeg)
     {
       if (d >= (long)strat->tailRing->bitmask)
       {
         if (h->pTotalDeg() >= (long)strat->tailRing->bitmask)
         {
           strat->overflow=TRUE;
           //Print("OVERFLOW in redRing d=%ld, max=%ld\n",d,strat->tailRing->bitmask);
           h->GetP();
           at = strat->posInL(strat->L,strat->Ll,h,strat);
           enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
           h->Clear();
           return -1;
         }
       }
       else if ((TEST_OPT_PROT) && (strat->Ll < 0))
       {
         Print(".%ld",d);mflush();
         reddeg = d;
       }
     }
   }
 }

int redSig	(	LObject *	h,
		kStrategy	strat
	)

Definition at line 677 of file kstd2.cc.

 {
   if (strat->tl<0) return 1;
   //if (h->GetLmTailRing()==NULL) return 0; // HS: SHOULD NOT BE NEEDED!
   //printf("FDEGS: %ld -- %ld\n",h->FDeg, h->pFDeg());
   assume(h->FDeg == h->pFDeg());
 //#if 1
 #ifdef DEBUGF5
   Print("------- IN REDSIG -------\n");
   Print("p: ");
   pWrite(pHead(h->p));
   Print("p1: ");
   pWrite(pHead(h->p1));
   Print("p2: ");
   pWrite(pHead(h->p2));
   Print("---------------------------\n");
 #endif
   poly h_p;
   int i,j,at,pass, ii;
   int start=0;
   int sigSafe;
   unsigned long not_sev;
   // long reddeg,d;
 
   pass = j = 0;
   // d = reddeg = h->GetpFDeg();
   h->SetShortExpVector();
   int li;
   h_p = h->GetLmTailRing();
   not_sev = ~ h->sev;
   loop
   {
     j = kFindDivisibleByInT(strat, h, start);
     if (j < 0)
     {
       return 1;
     }
 
     li = strat->T[j].pLength;
     ii = j;
     /*
      * the polynomial to reduce with (up to the moment) is;
      * pi with length li
      */
     i = j;
 #if 1
     if (TEST_OPT_LENGTH)
     loop
     {
       /*- search the shortest possible with respect to length -*/
       i++;
       if (i > strat->tl)
         break;
       if (li<=1)
         break;
       if ((strat->T[i].pLength < li)
          &&
           p_LmShortDivisibleBy(strat->T[i].GetLmTailRing(), strat->sevT[i],
                                h_p, not_sev, strat->tailRing))
       {
         /*
          * the polynomial to reduce with is now;
          */
         li = strat->T[i].pLength;
         ii = i;
       }
     }
     start = ii+1;
 #endif
 
     /*
      * end of search: have to reduce with pi
      */
 #ifdef KDEBUG
     if (TEST_OPT_DEBUG)
     {
       PrintS("red:");
       h->wrp();
       PrintS(" with ");
       strat->T[ii].wrp();
     }
 #endif
     assume(strat->fromT == FALSE);
 //#if 1
 #ifdef DEBUGF5
     Print("BEFORE REDUCTION WITH %d:\n",ii);
     Print("--------------------------------\n");
     pWrite(h->sig);
     pWrite(strat->T[ii].sig);
     pWrite(h->GetLmCurrRing());
     pWrite(pHead(h->p1));
     pWrite(pHead(h->p2));
     pWrite(pHead(strat->T[ii].p));
     Print("--------------------------------\n");
     printf("INDEX OF REDUCER T: %d\n",ii);
 #endif
     sigSafe = ksReducePolySig(h, &(strat->T[ii]), strat->S_2_R[ii], NULL, NULL, strat);
 #if SBA_PRINT_REDUCTION_STEPS
     if (sigSafe != 3)
       sba_reduction_steps++;
 #endif
 #if SBA_PRINT_OPERATIONS
     if (sigSafe != 3)
       sba_operations  +=  pLength(strat->T[ii].p);
 #endif
     // if reduction has taken place, i.e. the reduction was sig-safe
     // otherwise start is already at the next position and the loop
     // searching reducers in T goes on from index start
 //#if 1
 #ifdef DEBUGF5
     Print("SigSAFE: %d\n",sigSafe);
 #endif
     if (sigSafe != 3)
     {
       // start the next search for reducers in T from the beginning
       start = 0;
 #ifdef KDEBUG
       if (TEST_OPT_DEBUG)
       {
         PrintS("\nto ");
         h->wrp();
         PrintLn();
       }
 #endif
 
       h_p = h->GetLmTailRing();
       if (h_p == NULL)
       {
         if (h->lcm!=NULL) pLmFree(h->lcm);
 #ifdef KDEBUG
         h->lcm=NULL;
 #endif
         return 0;
       }
       h->SetShortExpVector();
       not_sev = ~ h->sev;
       /*
       * try to reduce the s-polynomial h
       *test first whether h should go to the lazyset L
       *-if the degree jumps
       *-if the number of pre-defined reductions jumps
       */
       pass++;
       if (!TEST_OPT_REDTHROUGH && (strat->Ll >= 0) && (pass > strat->LazyPass))
       {
         h->SetLmCurrRing();
         at = strat->posInL(strat->L,strat->Ll,h,strat);
         if (at <= strat->Ll)
         {
           int dummy=strat->sl;
           if (kFindDivisibleByInS(strat, &dummy, h) < 0)
           {
             return 1;
           }
           enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
 #ifdef KDEBUG
           if (TEST_OPT_DEBUG)
             Print(" lazy: -> L%d\n",at);
 #endif
           h->Clear();
           return -1;
         }
       }
     }
   }
 }

poly redtail	(	poly	p,
		int	pos,
		kStrategy	strat
	)

Definition at line 6045 of file kutil.cc.

 {
   LObject L(p, currRing);
   return redtail(&L, pos, strat);
 }

poly redtail	(	LObject *	L,
		int	pos,
		kStrategy	strat
	)

Definition at line 5975 of file kutil.cc.

 {
   poly h, hn;
   strat->redTailChange=FALSE;
 
   L->GetP();
   poly p = L->p;
   if (strat->noTailReduction || pNext(p) == NULL)
     return p;
 
   LObject Ln(strat->tailRing);
   TObject* With;
   // placeholder in case strat->tl < 0
   TObject  With_s(strat->tailRing);
   h = p;
   hn = pNext(h);
   long op = strat->tailRing->pFDeg(hn, strat->tailRing);
   long e;
   int l;
   BOOLEAN save_HE=strat->kHEdgeFound;
   strat->kHEdgeFound |=
     ((Kstd1_deg>0) && (op<=Kstd1_deg)) || TEST_OPT_INFREDTAIL;
 
   while(hn != NULL)
   {
     op = strat->tailRing->pFDeg(hn, strat->tailRing);
     if ((Kstd1_deg>0)&&(op>Kstd1_deg)) goto all_done;
     e = strat->tailRing->pLDeg(hn, &l, strat->tailRing) - op;
     loop
     {
       Ln.Set(hn, strat->tailRing);
       Ln.sev = p_GetShortExpVector(hn, strat->tailRing);
       if (strat->kHEdgeFound)
         With = kFindDivisibleByInS(strat, pos, &Ln, &With_s);
       else
         With = kFindDivisibleByInS(strat, pos, &Ln, &With_s, e);
       if (With == NULL) break;
       With->length=0;
       With->pLength=0;
       strat->redTailChange=TRUE;
       if (ksReducePolyTail(L, With, h, strat->kNoetherTail()))
       {
         // reducing the tail would violate the exp bound
         if (kStratChangeTailRing(strat, L))
         {
           strat->kHEdgeFound = save_HE;
           return redtail(L, pos, strat);
         }
         else
           return NULL;
       }
       hn = pNext(h);
       if (hn == NULL) goto all_done;
       op = strat->tailRing->pFDeg(hn, strat->tailRing);
       if ((Kstd1_deg>0)&&(op>Kstd1_deg)) goto all_done;
       e = strat->tailRing->pLDeg(hn, &l, strat->tailRing) - op;
     }
     h = hn;
     hn = pNext(h);
   }
 
   all_done:
   if (strat->redTailChange)
   {
     L->pLength = 0;
   }
   strat->kHEdgeFound = save_HE;
   return p;
 }

KINLINE poly redtailBba	(	poly	p,
		int	pos,
		kStrategy	strat,
		BOOLEAN	normalize = `FALSE`
	)

Definition at line 1120 of file kInline.h.

 {
   LObject L(p, currRing, strat->tailRing);
   return redtailBba(&L, pos, strat,FALSE, normalize);
 }

poly redtailBba	(	LObject *	L,
		int	pos,
		kStrategy	strat,
		BOOLEAN	withT = `FALSE`,
		BOOLEAN	normalize = `FALSE`
	)

Definition at line 6051 of file kutil.cc.

 {
 #define REDTAIL_CANONICALIZE 100
   strat->redTailChange=FALSE;
   if (strat->noTailReduction) return L->GetLmCurrRing();
   poly h, p;
   p = h = L->GetLmTailRing();
   if ((h==NULL) || (pNext(h)==NULL))
     return L->GetLmCurrRing();
 
   TObject* With;
   // placeholder in case strat->tl < 0
   TObject  With_s(strat->tailRing);
 
   LObject Ln(pNext(h), strat->tailRing);
   Ln.pLength = L->GetpLength() - 1;
 
   pNext(h) = NULL;
   if (L->p != NULL) pNext(L->p) = NULL;
   L->pLength = 1;
 
   Ln.PrepareRed(strat->use_buckets);
 
   int cnt=REDTAIL_CANONICALIZE;
   while(!Ln.IsNull())
   {
     loop
     {
       if (TEST_OPT_IDLIFT)
       {
         if (Ln.p!=NULL)
         {
           if (p_GetComp(Ln.p,currRing)> strat->syzComp) break;
         }
         else
         {
           if (p_GetComp(Ln.t_p,strat->tailRing)> strat->syzComp) break;
         }
       }
       Ln.SetShortExpVector();
       if (withT)
       {
         int j;
         j = kFindDivisibleByInT(strat, &Ln);
         if (j < 0) break;
         With = &(strat->T[j]);
       }
       else
       {
         With = kFindDivisibleByInS(strat, pos, &Ln, &With_s);
         if (With == NULL) break;
       }
       cnt--;
       if (cnt==0)
       {
         cnt=REDTAIL_CANONICALIZE;
         /*poly tmp=*/Ln.CanonicalizeP();
         if (normalize)
         {
           Ln.Normalize();
           //pNormalize(tmp);
           //if (TEST_OPT_PROT) { PrintS("n"); mflush(); }
         }
       }
       if (normalize && (!TEST_OPT_INTSTRATEGY) && (!nIsOne(pGetCoeff(With->p))))
       {
         With->pNorm();
       }
       strat->redTailChange=TRUE;
       if (ksReducePolyTail(L, With, &Ln))
       {
         // reducing the tail would violate the exp bound
         //  set a flag and hope for a retry (in bba)
         strat->completeReduce_retry=TRUE;
         if ((Ln.p != NULL) && (Ln.t_p != NULL)) Ln.p=NULL;
         do
         {
           pNext(h) = Ln.LmExtractAndIter();
           pIter(h);
           L->pLength++;
         } while (!Ln.IsNull());
         goto all_done;
       }
       if (Ln.IsNull()) goto all_done;
       if (! withT) With_s.Init(currRing);
     }
     pNext(h) = Ln.LmExtractAndIter();
     pIter(h);
     pNormalize(h);
     L->pLength++;
   }
 
   all_done:
   Ln.Delete();
   if (L->p != NULL) pNext(L->p) = pNext(p);
 
   if (strat->redTailChange)
   {
     L->length = 0;
     L->pLength = 0;
   }
 
   //if (TEST_OPT_PROT) { PrintS("N"); mflush(); }
   //L->Normalize(); // HANNES: should have a test
   kTest_L(L);
   return L->GetLmCurrRing();
 }

poly redtailBba	(	TObject *	T,
		int	pos,
		kStrategy	strat
	)

Definition at line 1134 of file kInline.h.

 {
   LObject L;
   L = *T;
   poly p = redtailBba(&L, pos, strat, FALSE);
   *T = L;
   //kTest_T(T);
   assume( p == T->p);
   return p;
 }

KINLINE poly redtailBba_Z	(	poly	p,
		int	pos,
		kStrategy	strat
	)

Definition at line 1127 of file kInline.h.

 {
   LObject L(p, currRing, strat->tailRing);
   return redtailBba_Z(&L, pos, strat);
 }

poly redtailBba_Z	(	LObject *	L,
		int	pos,
		kStrategy	strat
	)

Definition at line 6160 of file kutil.cc.

 {
   strat->redTailChange=FALSE;
   if (strat->noTailReduction) return L->GetLmCurrRing();
   poly h, p;
   p = h = L->GetLmTailRing();
   if ((h==NULL) || (pNext(h)==NULL))
     return L->GetLmCurrRing();
 
   TObject* With;
   // placeholder in case strat->tl < 0
   TObject  With_s(strat->tailRing);
 
   LObject Ln(pNext(h), strat->tailRing);
   Ln.pLength = L->GetpLength() - 1;
 
   pNext(h) = NULL;
   if (L->p != NULL) pNext(L->p) = NULL;
   L->pLength = 1;
 
   Ln.PrepareRed(strat->use_buckets);
 
   int cnt=REDTAIL_CANONICALIZE;
   while(!Ln.IsNull())
   {
     loop
     {
       Ln.SetShortExpVector();
       With = kFindDivisibleByInS(strat, pos, &Ln, &With_s);
       if (With == NULL) break;
       cnt--;
       if (cnt==0)
       {
         cnt=REDTAIL_CANONICALIZE;
         /*poly tmp=*/Ln.CanonicalizeP();
       }
       // we are in Z, do not call pNorm
       strat->redTailChange=TRUE;
       // test divisibility of coefs:
       poly p_Ln=Ln.GetLmCurrRing();
       poly p_With=With->GetLmCurrRing();
       number z=n_IntMod(pGetCoeff(p_Ln),pGetCoeff(p_With), currRing->cf);
       if (!nIsZero(z))
       {
         // subtract z*Ln, add z.Ln to L
         poly m=pHead(p_Ln);
         pSetCoeff(m,z);
         poly mm=pHead(m);
         pNext(h) = m;
         pIter(h);
         L->pLength++;
         mm=pNeg(mm);
         if (Ln.bucket!=NULL)
         {
           int dummy=1;
           kBucket_Add_q(Ln.bucket,mm,&dummy);
         }
         else
         {
           if ((Ln.t_p!=NULL)&&(Ln.p==NULL))
             Ln.GetP();
           if (Ln.p!=NULL)
           {
             Ln.p=pAdd(Ln.p,mm);
             if (Ln.t_p!=NULL)
             {
               pNext(Ln.t_p)=NULL;
               p_LmDelete(Ln.t_p,strat->tailRing);
             }
           }
         }
       }
       else
         nDelete(&z);
 
       if (ksReducePolyTail(L, With, &Ln))
       {
         // reducing the tail would violate the exp bound
         //  set a flag and hope for a retry (in bba)
         strat->completeReduce_retry=TRUE;
         if ((Ln.p != NULL) && (Ln.t_p != NULL)) Ln.p=NULL;
         do
         {
           pNext(h) = Ln.LmExtractAndIter();
           pIter(h);
           L->pLength++;
         } while (!Ln.IsNull());
         goto all_done;
       }
       if (Ln.IsNull()) goto all_done;
       With_s.Init(currRing);
     }
     pNext(h) = Ln.LmExtractAndIter();
     pIter(h);
     pNormalize(h);
     L->pLength++;
   }
 
   all_done:
   Ln.Delete();
   if (L->p != NULL) pNext(L->p) = pNext(p);
 
   if (strat->redTailChange)
   {
     L->length = 0;
   }
 
   //if (TEST_OPT_PROT) { PrintS("N"); mflush(); }
   //L->Normalize(); // HANNES: should have a test
   kTest_L(L);
   return L->GetLmCurrRing();
 }

poly redtailBbaShift	(	LObject *	L,
		int	pos,
		kStrategy	strat,
		BOOLEAN	withT,
		BOOLEAN	normalize
	)

Definition at line 10846 of file kutil.cc.

 {
   /* for the shift case need to run it with withT = TRUE */
   strat->redTailChange=FALSE;
   if (strat->noTailReduction) return L->GetLmCurrRing();
   poly h, p;
   p = h = L->GetLmTailRing();
   if ((h==NULL) || (pNext(h)==NULL))
     return L->GetLmCurrRing();
 
   TObject* With;
   // placeholder in case strat->tl < 0
   TObject  With_s(strat->tailRing);
 
   LObject Ln(pNext(h), strat->tailRing);
   Ln.pLength = L->GetpLength() - 1;
 
   pNext(h) = NULL;
   if (L->p != NULL) pNext(L->p) = NULL;
   L->pLength = 1;
 
   Ln.PrepareRed(strat->use_buckets);
 
   while(!Ln.IsNull())
   {
     loop
     {
       Ln.SetShortExpVector();
       if (withT)
       {
         int j;
         j = kFindDivisibleByInT(strat, &Ln);
         if (j < 0) break;
         With = &(strat->T[j]);
       }
       else
       {
         With = kFindDivisibleByInS(strat, pos, &Ln, &With_s);
         if (With == NULL) break;
       }
       if (normalize && (!TEST_OPT_INTSTRATEGY) && (!nIsOne(pGetCoeff(With->p))))
       {
         With->pNorm();
         //if (TEST_OPT_PROT) { PrintS("n"); mflush(); }
       }
       strat->redTailChange=TRUE;
       if (ksReducePolyTail(L, With, &Ln))
       {
         // reducing the tail would violate the exp bound
         //  set a flag and hope for a retry (in bba)
         strat->completeReduce_retry=TRUE;
         if ((Ln.p != NULL) && (Ln.t_p != NULL)) Ln.p=NULL;
         do
         {
           pNext(h) = Ln.LmExtractAndIter();
           pIter(h);
           L->pLength++;
         } while (!Ln.IsNull());
         goto all_done;
       }
       if (Ln.IsNull()) goto all_done;
       if (! withT) With_s.Init(currRing);
     }
     pNext(h) = Ln.LmExtractAndIter();
     pIter(h);
     L->pLength++;
   }
 
   all_done:
   Ln.Delete();
   if (L->p != NULL) pNext(L->p) = pNext(p);
 
   if (strat->redTailChange)
   {
     L->length = 0;
   }
   L->Normalize(); // HANNES: should have a test
   kTest_L(L);
   return L->GetLmCurrRing();
 }

poly redtailSba	(	LObject *	L,
		int	pos,
		kStrategy	strat,
		BOOLEAN	withT = `FALSE`,
		BOOLEAN	normalize = `FALSE`
	)

Definition at line 845 of file kstd2.cc.

 {
 #define REDTAIL_CANONICALIZE 100
   strat->redTailChange=FALSE;
   if (strat->noTailReduction) return L->GetLmCurrRing();
   poly h, p;
   p = h = L->GetLmTailRing();
   if ((h==NULL) || (pNext(h)==NULL))
     return L->GetLmCurrRing();
 
   TObject* With;
   // placeholder in case strat->tl < 0
   TObject  With_s(strat->tailRing);
 
   LObject Ln(pNext(h), strat->tailRing);
   Ln.sig      = L->sig;
   Ln.sevSig   = L->sevSig;
   Ln.pLength  = L->GetpLength() - 1;
 
   pNext(h) = NULL;
   if (L->p != NULL) pNext(L->p) = NULL;
   L->pLength = 1;
 
   Ln.PrepareRed(strat->use_buckets);
 
   int cnt=REDTAIL_CANONICALIZE;
   while(!Ln.IsNull())
   {
     loop
     {
       Ln.SetShortExpVector();
       if (withT)
       {
         int j;
         j = kFindDivisibleByInT(strat, &Ln);
         if (j < 0) break;
         With = &(strat->T[j]);
       }
       else
       {
         With = kFindDivisibleByInS(strat, pos, &Ln, &With_s);
         if (With == NULL) break;
       }
       cnt--;
       if (cnt==0)
       {
         cnt=REDTAIL_CANONICALIZE;
         /*poly tmp=*/Ln.CanonicalizeP();
         if (normalize)
         {
           Ln.Normalize();
           //pNormalize(tmp);
           //if (TEST_OPT_PROT) { PrintS("n"); mflush(); }
         }
       }
       if (normalize && (!TEST_OPT_INTSTRATEGY) && (!nIsOne(pGetCoeff(With->p))))
       {
         With->pNorm();
       }
       strat->redTailChange=TRUE;
       int ret = ksReducePolyTailSig(L, With, &Ln);
 #if SBA_PRINT_REDUCTION_STEPS
       if (ret != 3)
         sba_reduction_steps++;
 #endif
 #if SBA_PRINT_OPERATIONS
       if (ret != 3)
         sba_operations  +=  pLength(With->p);
 #endif
       if (ret)
       {
         // reducing the tail would violate the exp bound
         //  set a flag and hope for a retry (in bba)
         strat->completeReduce_retry=TRUE;
         if ((Ln.p != NULL) && (Ln.t_p != NULL)) Ln.p=NULL;
         do
         {
           pNext(h) = Ln.LmExtractAndIter();
           pIter(h);
           L->pLength++;
         } while (!Ln.IsNull());
         goto all_done;
       }
       if (Ln.IsNull()) goto all_done;
       if (! withT) With_s.Init(currRing);
     }
     pNext(h) = Ln.LmExtractAndIter();
     pIter(h);
     pNormalize(h);
     L->pLength++;
   }
 
   all_done:
   Ln.Delete();
   if (L->p != NULL) pNext(L->p) = pNext(p);
 
   if (strat->redTailChange)
   {
     L->length = 0;
   }
 
   //if (TEST_OPT_PROT) { PrintS("N"); mflush(); }
   //L->Normalize(); // HANNES: should have a test
   kTest_L(L);
   return L->GetLmCurrRing();
 }

void reorderS	(	int *	suc,
		kStrategy	strat
	)

Definition at line 4148 of file kutil.cc.

 {
   int i,j,at,ecart, s2r;
   int fq=0;
   unsigned long sev;
   poly  p;
   int new_suc=strat->sl+1;
   i= *suc;
   if (i<0) i=0;
 
   for (; i<=strat->sl; i++)
   {
     at = posInS(strat,i-1,strat->S[i],strat->ecartS[i]);
     if (at != i)
     {
       if (new_suc > at) new_suc = at;
       p = strat->S[i];
       ecart = strat->ecartS[i];
       sev = strat->sevS[i];
       s2r = strat->S_2_R[i];
       if (strat->fromQ!=NULL) fq=strat->fromQ[i];
       for (j=i; j>=at+1; j--)
       {
         strat->S[j] = strat->S[j-1];
         strat->ecartS[j] = strat->ecartS[j-1];
         strat->sevS[j] = strat->sevS[j-1];
         strat->S_2_R[j] = strat->S_2_R[j-1];
       }
       strat->S[at] = p;
       strat->ecartS[at] = ecart;
       strat->sevS[at] = sev;
       strat->S_2_R[at] = s2r;
       if (strat->fromQ!=NULL)
       {
         for (j=i; j>=at+1; j--)
         {
           strat->fromQ[j] = strat->fromQ[j-1];
         }
         strat->fromQ[at]=fq;
       }
     }
   }
   if (new_suc <= strat->sl) *suc=new_suc;
   else                      *suc=-1;
 }

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

Definition at line 1872 of file kstd2.cc.

 {
   // ring order stuff:
   // in sba we have (until now) two possibilities:
   // 1. an incremental computation w.r.t. (C,monomial order)
   // 2. a (possibly non-incremental) computation w.r.t. the
   //    induced Schreyer order.
   // The corresponding orders are computed in sbaRing(), depending
   // on the flag strat->sbaOrder
 #if SBA_PRINT_ZERO_REDUCTIONS
   long zeroreductions           = 0;
 #endif
 #if SBA_PRINT_PRODUCT_CRITERION
   long product_criterion        = 0;
 #endif
 #if SBA_PRINT_SIZE_G
   int size_g                    = 0;
   int size_g_non_red            = 0;
 #endif
 #if SBA_PRINT_SIZE_SYZ
   long size_syz                 = 0;
 #endif
   // global variable
 #if SBA_PRINT_REDUCTION_STEPS
   sba_reduction_steps           = 0;
   sba_interreduction_steps      = 0;
 #endif
 #if SBA_PRINT_OPERATIONS
   sba_operations                = 0;
   sba_interreduction_operations = 0;
 #endif
 
   ideal F1 = F0;
   ring sRing, currRingOld;
   currRingOld  = currRing;
   if (strat->sbaOrder == 1 || strat->sbaOrder == 3)
   {
     sRing = sbaRing(strat);
     if (sRing!=currRingOld)
     {
       rChangeCurrRing (sRing);
       F1 = idrMoveR (F0, currRingOld, currRing);
     }
   }
   // sort ideal F
   ideal F       = idInit(IDELEMS(F1),F1->rank);
   intvec *sort  = idSort(F1);
   for (int i=0; i<sort->length();++i)
     F->m[i] = F1->m[(*sort)[i]-1];
 #if SBA_INTERRED_START
   F = kInterRed(F,NULL);
 #endif
 #if F5DEBUG
   printf("SBA COMPUTATIONS DONE IN THE FOLLOWING RING:\n");
   rWrite (currRing);
   printf("ordSgn = %d\n",currRing->OrdSgn);
   printf("\n");
 #endif
   int   srmax,lrmax, red_result = 1;
   int   olddeg,reduc;
   int hilbeledeg=1,hilbcount=0,minimcnt=0;
   LObject L;
   BOOLEAN withT     = TRUE;
   strat->max_lower_index = 0;
 
   //initBuchMoraCrit(strat); /*set Gebauer, honey, sugarCrit*/
   initSbaCrit(strat); /*set Gebauer, honey, sugarCrit*/
   initSbaPos(strat);
   //initBuchMoraPos(strat);
   initHilbCrit(F,Q,&hilb,strat);
   initSba(F,strat);
   /*set enterS, spSpolyShort, reduce, red, initEcart, initEcartPair*/
   /*Shdl=*/initSbaBuchMora(F, Q,strat);
   if (strat->minim>0) strat->M=idInit(IDELEMS(F),F->rank);
   srmax = strat->sl;
   reduc = olddeg = lrmax = 0;
 
 #ifndef NO_BUCKETS
   if (!TEST_OPT_NOT_BUCKETS)
     strat->use_buckets = 1;
 #endif
 
   // redtailBBa against T for inhomogenous input
   // if (!TEST_OPT_OLDSTD)
   //   withT = ! strat->homog;
 
   // strat->posInT = posInT_pLength;
   kTest_TS(strat);
 
 #ifdef KDEBUG
 #if MYTEST
   if (TEST_OPT_DEBUG)
   {
     PrintS("bba start GB: currRing: ");
     // rWrite(currRing);PrintLn();
     rDebugPrint(currRing);
     PrintLn();
   }
 #endif /* MYTEST */
 #endif /* KDEBUG */
 
 #ifdef HAVE_TAIL_RING
   if(!idIs0(F) &&(!rField_is_Ring(currRing)))  // create strong gcd poly computes with tailring and S[i] ->to be fixed
     kStratInitChangeTailRing(strat);
 #endif
   if (BVERBOSE(23))
   {
     if (test_PosInT!=NULL) strat->posInT=test_PosInT;
     if (test_PosInL!=NULL) strat->posInL=test_PosInL;
     kDebugPrint(strat);
   }
 
 
 #ifdef KDEBUG
   //kDebugPrint(strat);
 #endif
   /* compute------------------------------------------------------- */
   while (strat->Ll >= 0)
   {
     if (strat->Ll > lrmax) lrmax =strat->Ll;/*stat.*/
     #ifdef KDEBUG
       if (TEST_OPT_DEBUG) messageSets(strat);
     #endif
     if (strat->Ll== 0) strat->interpt=TRUE;
     /*
     if (TEST_OPT_DEGBOUND
         && ((strat->honey && (strat->L[strat->Ll].ecart+currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg))
             || ((!strat->honey) && (currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg))))
     {
 
        //stops computation if
        // 24 IN test and the degree +ecart of L[strat->Ll] is bigger then
        //a predefined number Kstd1_deg
       while ((strat->Ll >= 0)
         && (strat->L[strat->Ll].p1!=NULL) && (strat->L[strat->Ll].p2!=NULL)
         && ((strat->honey && (strat->L[strat->Ll].ecart+currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg))
             || ((!strat->honey) && (currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg)))
         )
         deleteInL(strat->L,&strat->Ll,strat->Ll,strat);
       if (strat->Ll<0) break;
       else strat->noClearS=TRUE;
     }
     */
     if (strat->sbaOrder == 1 && pGetComp(strat->L[strat->Ll].sig) != strat->currIdx)
     {
       strat->currIdx  = pGetComp(strat->L[strat->Ll].sig);
 #if F5C
       // 1. interreduction of the current standard basis
       // 2. generation of new principal syzygy rules for syzCriterion
       f5c ( strat, olddeg, minimcnt, hilbeledeg, hilbcount, srmax,
           lrmax, reduc, Q, w, hilb );
 #endif
       // initialize new syzygy rules for the next iteration step
       initSyzRules(strat);
 
     }
     /*********************************************************************
       * interrreduction step is done, we can go on with the next iteration
       * step of the signature-based algorithm
       ********************************************************************/
     /* picks the last element from the lazyset L */
     strat->P = strat->L[strat->Ll];
     strat->Ll--;
     /* reduction of the element chosen from L */
 
     if (!strat->rewCrit2(strat->P.sig, ~strat->P.sevSig, strat->P.GetLmCurrRing(), strat, strat->P.checked+1)) {
       //#if 1
 #ifdef DEBUGF5
       Print("SIG OF NEXT PAIR TO HANDLE IN SIG-BASED ALGORITHM\n");
       Print("-------------------------------------------------\n");
       pWrite(strat->P.sig);
       pWrite(pHead(strat->P.p));
       pWrite(pHead(strat->P.p1));
       pWrite(pHead(strat->P.p2));
       Print("-------------------------------------------------\n");
 #endif
       if (pNext(strat->P.p) == strat->tail)
       {
         // deletes the short spoly
         /*
 #ifdef HAVE_RINGS
         if (rField_is_Ring(currRing))
           pLmDelete(strat->P.p);
         else
 #endif
           pLmFree(strat->P.p);
 */
           // TODO: needs some masking
           // TODO: masking needs to vanish once the signature
           //       sutff is completely implemented
           strat->P.p = NULL;
         poly m1 = NULL, m2 = NULL;
 
         // check that spoly creation is ok
         while (strat->tailRing != currRing &&
             !kCheckSpolyCreation(&(strat->P), strat, m1, m2))
         {
           assume(m1 == NULL && m2 == NULL);
           // if not, change to a ring where exponents are at least
           // large enough
           if (!kStratChangeTailRing(strat))
           {
             WerrorS("OVERFLOW...");
             break;
           }
         }
         // create the real one
         ksCreateSpoly(&(strat->P), NULL, strat->use_buckets,
             strat->tailRing, m1, m2, strat->R);
 
       }
       else if (strat->P.p1 == NULL)
       {
         if (strat->minim > 0)
           strat->P.p2=p_Copy(strat->P.p, currRing, strat->tailRing);
         // for input polys, prepare reduction
         strat->P.PrepareRed(strat->use_buckets);
       }
       if (strat->P.p == NULL && strat->P.t_p == NULL)
       {
         red_result = 0;
       }
       else
       {
         //#if 1
 #ifdef DEBUGF5
         Print("Poly before red: ");
         pWrite(pHead(strat->P.p));
         pWrite(strat->P.sig);
 #endif
 #if SBA_PRODUCT_CRITERION
         if (strat->P.prod_crit) {
 #if SBA_PRINT_PRODUCT_CRITERION
           product_criterion++;
 #endif
           int pos = posInSyz(strat, strat->P.sig);
           enterSyz(strat->P, strat, pos);
           if (strat->P.lcm!=NULL)
             pLmFree(strat->P.lcm);
           red_result = 2;
         } else {
           red_result = strat->red(&strat->P,strat);
         }
 #else
         red_result = strat->red(&strat->P,strat);
 #endif
       }
     } else {
       /*
       if (strat->P.lcm != NULL)
         pLmFree(strat->P.lcm);
         */
       red_result = 2;
     }
     if (errorreported)  break;
 
 //#if 1
 #ifdef DEBUGF5
     if (red_result != 0) {
         Print("Poly after red: ");
         pWrite(pHead(strat->P.p));
         pWrite(strat->P.GetLmCurrRing());
         pWrite(strat->P.sig);
         printf("%d\n",red_result);
     }
 #endif
 
     if (strat->overflow)
     {
         if (!kStratChangeTailRing(strat)) { Werror("OVERFLOW.."); break;}
     }
 
     // reduction to non-zero new poly
     if (red_result == 1)
     {
       // get the polynomial (canonicalize bucket, make sure P.p is set)
       strat->P.GetP(strat->lmBin);
 
       // sig-safe computations may lead to wrong FDeg computation, thus we need
       // to recompute it to make sure everything is alright
       (strat->P).FDeg = (strat->P).pFDeg();
       // in the homogeneous case FDeg >= pFDeg (sugar/honey)
       // but now, for entering S, T, we reset it
       // in the inhomogeneous case: FDeg == pFDeg
       if (strat->homog) strat->initEcart(&(strat->P));
 
       /* statistic */
       if (TEST_OPT_PROT) PrintS("s");
 
       //int pos=posInS(strat,strat->sl,strat->P.p,strat->P.ecart);
       // in F5E we know that the last reduced element is already the
       // the one with highest signature
       int pos = strat->sl+1;
 
 #ifdef KDEBUG
 #if MYTEST
       PrintS("New S: "); pDebugPrint(strat->P.p); PrintLn();
 #endif /* MYTEST */
 #endif /* KDEBUG */
 
       // reduce the tail and normalize poly
       // in the ring case we cannot expect LC(f) = 1,
       // therefore we call pContent instead of pNorm
 #if SBA_TAIL_RED
       if (strat->sbaOrder != 2) {
         if ((TEST_OPT_INTSTRATEGY) || (rField_is_Ring(currRing)))
         {
           strat->P.pCleardenom();
           if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
           {
             strat->P.p = redtailSba(&(strat->P),pos-1,strat, withT);
             strat->P.pCleardenom();
           }
         }
         else
         {
           strat->P.pNorm();
           if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
             strat->P.p = redtailSba(&(strat->P),pos-1,strat, withT);
         }
       }
 #endif
 
     // remove sigsafe label since it is no longer valid for the next element to
     // be reduced
     if (strat->sbaOrder == 1)
     {
       for (int jj = 0; jj<strat->tl+1; jj++)
       {
         if (pGetComp(strat->T[jj].sig) == strat->currIdx)
         {
           strat->T[jj].is_sigsafe = FALSE;
         }
       }
     }
     else
     {
       for (int jj = 0; jj<strat->tl+1; jj++)
       {
         strat->T[jj].is_sigsafe = FALSE;
       }
     }
 #ifdef KDEBUG
       if (TEST_OPT_DEBUG){PrintS("new s:");strat->P.wrp();PrintLn();}
 #if MYTEST
 //#if 1
       PrintS("New (reduced) S: "); pDebugPrint(strat->P.p); PrintLn();
 #endif /* MYTEST */
 #endif /* KDEBUG */
 
       // min_std stuff
       if ((strat->P.p1==NULL) && (strat->minim>0))
       {
         if (strat->minim==1)
         {
           strat->M->m[minimcnt]=p_Copy(strat->P.p,currRing,strat->tailRing);
           p_Delete(&strat->P.p2, currRing, strat->tailRing);
         }
         else
         {
           strat->M->m[minimcnt]=strat->P.p2;
           strat->P.p2=NULL;
         }
         if (strat->tailRing!=currRing && pNext(strat->M->m[minimcnt])!=NULL)
           pNext(strat->M->m[minimcnt])
             = strat->p_shallow_copy_delete(pNext(strat->M->m[minimcnt]),
                                            strat->tailRing, currRing,
                                            currRing->PolyBin);
         minimcnt++;
       }
 
       // enter into S, L, and T
       //if ((!TEST_OPT_IDLIFT) || (pGetComp(strat->P.p) <= strat->syzComp))
       enterT(strat->P, strat);
       strat->T[strat->tl].is_sigsafe = FALSE;
       /*
       printf("hier\n");
       pWrite(strat->P.GetLmCurrRing());
       pWrite(strat->P.sig);
       */
 #ifdef HAVE_RINGS
       if (rField_is_Ring(currRing))
         superenterpairs(strat->P.p,strat->sl,strat->P.ecart,pos,strat, strat->tl);
       else
 #endif
         enterpairsSig(strat->P.p,strat->P.sig,strat->sl+1,strat->sl,strat->P.ecart,pos,strat, strat->tl);
       // posInS only depends on the leading term
       strat->enterS(strat->P, pos, strat, strat->tl);
       if(strat->sbaOrder != 1)
       {
         BOOLEAN overwrite = FALSE;
         for (int tk=0; tk<strat->sl+1; tk++)
         {
           if (pGetComp(strat->sig[tk]) == pGetComp(strat->P.sig))
           {
             //printf("TK %d / %d\n",tk,strat->sl);
             overwrite = FALSE;
             break;
           }
         }
         //printf("OVERWRITE %d\n",overwrite);
         if (overwrite)
         {
           int cmp = pGetComp(strat->P.sig);
           int* vv = (int*)omAlloc((currRing->N+1)*sizeof(int));
           pGetExpV (strat->P.p,vv);
           pSetExpV (strat->P.sig, vv);
           pSetComp (strat->P.sig,cmp);
 
           strat->P.sevSig = pGetShortExpVector (strat->P.sig);
           int i;
           LObject Q;
           for(int ps=0;ps<strat->sl+1;ps++)
           {
 
             strat->newt = TRUE;
             if (strat->syzl == strat->syzmax)
             {
               pEnlargeSet(&strat->syz,strat->syzmax,setmaxTinc);
               strat->sevSyz = (unsigned long*) omRealloc0Size(strat->sevSyz,
                   (strat->syzmax)*sizeof(unsigned long),
                   ((strat->syzmax)+setmaxTinc)
                   *sizeof(unsigned long));
               strat->syzmax += setmaxTinc;
             }
             Q.sig = pCopy(strat->P.sig);
             // add LM(F->m[i]) to the signature to get a Schreyer order
             // without changing the underlying polynomial ring at all
             if (strat->sbaOrder == 0)
               p_ExpVectorAdd (Q.sig,strat->S[ps],currRing);
             // since p_Add_q() destroys all input
             // data we need to recreate help
             // each time
             // ----------------------------------------------------------
             // in the Schreyer order we always know that the multiplied
             // module monomial strat->P.sig gives the leading monomial of
             // the corresponding principal syzygy
             // => we do not need to compute the "real" syzygy completely
             poly help = p_Copy(strat->sig[ps],currRing);
             p_ExpVectorAdd (help,strat->P.p,currRing);
             Q.sig = p_Add_q(Q.sig,help,currRing);
             //printf("%d. SYZ  ",i+1);
             //pWrite(strat->syz[i]);
             Q.sevSig = p_GetShortExpVector(Q.sig,currRing);
             i = posInSyz(strat, Q.sig);
             enterSyz(Q, strat, i);
           }
         }
       }
       // deg - idx - lp/rp
       // => we need to add syzygies with indices > pGetComp(strat->P.sig)
       if(strat->sbaOrder == 0 || strat->sbaOrder == 3)
       {
         int cmp     = pGetComp(strat->P.sig);
         int max_cmp = IDELEMS(F);
         int* vv = (int*)omAlloc((currRing->N+1)*sizeof(int));
         pGetExpV (strat->P.p,vv);
         LObject Q;
         int pos;
         int idx = p_GetComp(strat->P.sig,currRing);
         //printf("++ -- adding syzygies -- ++\n");
         // if new element is the first one in this index
         if (strat->currIdx < idx) {
           for (int i=0; i<strat->sl; ++i) {
             Q.sig = p_Copy(strat->P.sig,currRing);
             p_ExpVectorAdd(Q.sig,strat->S[i],currRing);
             poly help = p_Copy(strat->sig[i],currRing);
             p_ExpVectorAdd(help,strat->P.p,currRing);
             Q.sig = p_Add_q(Q.sig,help,currRing);
             //pWrite(Q.sig);
             pos = posInSyz(strat, Q.sig);
             enterSyz(Q, strat, pos);
           }
           strat->currIdx = idx;
         } else {
           // if the element is not the first one in the given index we build all
           // possible syzygies with elements of higher index
           for (int i=cmp+1; i<=max_cmp; ++i) {
             pos = -1;
             for (int j=0; j<strat->sl; ++j) {
               if (p_GetComp(strat->sig[j],currRing) == i) {
                 pos = j;
                 break;
               }
             }
             if (pos != -1) {
               Q.sig = p_One(currRing);
               p_SetExpV(Q.sig, vv, currRing);
               // F->m[i-1] corresponds to index i
               p_ExpVectorAdd(Q.sig,F->m[i-1],currRing);
               p_SetComp(Q.sig, i, currRing);
               poly help = p_Copy(strat->P.sig,currRing);
               p_ExpVectorAdd(help,strat->S[pos],currRing);
               Q.sig = p_Add_q(Q.sig,help,currRing);
               if (strat->sbaOrder == 0) {
                 if (p_LmCmp(Q.sig,strat->syz[strat->syzl-1],currRing) == -currRing->OrdSgn) {
                   pos = posInSyz(strat, Q.sig);
                   enterSyz(Q, strat, pos);
                 }
               } else {
                 pos = posInSyz(strat, Q.sig);
                 enterSyz(Q, strat, pos);
               }
             }
           }
           //printf("++ -- done adding syzygies -- ++\n");
         }
       }
 //#if 1
 #if DEBUGF50
     printf("---------------------------\n");
     Print(" %d. ELEMENT ADDED TO GCURR:\n",strat->sl+1);
     Print("LEAD POLY:  "); pWrite(pHead(strat->S[strat->sl]));
     Print("SIGNATURE:  "); pWrite(strat->sig[strat->sl]);
 #endif
       /*
       if (newrules)
       {
         newrules  = FALSE;
       }
       */
 #if 0
       int pl=pLength(strat->P.p);
       if (pl==1)
       {
         //if (TEST_OPT_PROT)
         //PrintS("<1>");
       }
       else if (pl==2)
       {
         //if (TEST_OPT_PROT)
         //PrintS("<2>");
       }
 #endif
       if (hilb!=NULL) khCheck(Q,w,hilb,hilbeledeg,hilbcount,strat);
 //      Print("[%d]",hilbeledeg);
       if (strat->P.lcm!=NULL)
 #ifdef HAVE_RINGS
         pLmDelete(strat->P.lcm);
 #else
         pLmFree(strat->P.lcm);
 #endif
       if (strat->sl>srmax) srmax = strat->sl;
     }
     else
     {
       // adds signature of the zero reduction to
       // strat->syz. This is the leading term of
       // syzygy and can be used in syzCriterion()
       // the signature is added if and only if the
       // pair was not detected by the rewritten criterion in strat->red = redSig
       if (red_result!=2) {
 #if SBA_PRINT_ZERO_REDUCTIONS
         zeroreductions++;
 #endif
         int pos = posInSyz(strat, strat->P.sig);
         enterSyz(strat->P, strat, pos);
 //#if 1
 #ifdef DEBUGF5
         Print("ADDING STUFF TO SYZ :  ");
         //pWrite(strat->P.p);
         pWrite(strat->P.sig);
 #endif
       }
       if (strat->P.p1 == NULL && strat->minim > 0)
       {
         p_Delete(&strat->P.p2, currRing, strat->tailRing);
       }
     }
 
 #ifdef KDEBUG
     memset(&(strat->P), 0, sizeof(strat->P));
 #endif /* KDEBUG */
     kTest_TS(strat);
   }
 #ifdef KDEBUG
 #if MYTEST
   PrintS("bba finish GB: currRing: "); rWrite(currRing);
 #endif /* MYTEST */
   if (TEST_OPT_DEBUG) messageSets(strat);
 #endif /* KDEBUG */
 
   if (TEST_OPT_SB_1)
   {
     #ifdef HAVE_RINGS
     if(!rField_is_Ring(currRing))
     #endif
     {
         int k=1;
         int j;
         while(k<=strat->sl)
         {
           j=0;
           loop
           {
             if (j>=k) break;
             clearS(strat->S[j],strat->sevS[j],&k,&j,strat);
             j++;
           }
           k++;
         }
     }
   }
 
   /* complete reduction of the standard basis--------- */
   if (TEST_OPT_REDSB)
   {
     completeReduce(strat);
 #ifdef HAVE_TAIL_RING
     if (strat->completeReduce_retry)
     {
       // completeReduce needed larger exponents, retry
       // to reduce with S (instead of T)
       // and in currRing (instead of strat->tailRing)
       cleanT(strat);strat->tailRing=currRing;
       int i;
       for(i=strat->sl;i>=0;i--) strat->S_2_R[i]=-1;
       completeReduce(strat);
     }
 #endif
   }
   else if (TEST_OPT_PROT) PrintLn();
 
 #if SBA_PRINT_SIZE_SYZ
   // that is correct, syzl is counting one too far
   size_syz = strat->syzl;
 #endif
   exitSba(strat);
 //  if (TEST_OPT_WEIGHTM)
 //  {
 //    pRestoreDegProcs(pFDegOld, pLDegOld);
 //    if (ecartWeights)
 //    {
 //      omFreeSize((ADDRESS)ecartWeights,(pVariables+1)*sizeof(short));
 //      ecartWeights=NULL;
 //    }
 //  }
   if (TEST_OPT_PROT) messageStat(hilbcount,strat);
   if (Q!=NULL) updateResult(strat->Shdl,Q,strat);
 
 #ifdef KDEBUG
 #if MYTEST
   PrintS("bba_end: currRing: "); rWrite(currRing);
 #endif /* MYTEST */
 #endif /* KDEBUG */
 #if SBA_PRINT_SIZE_G
   size_g_non_red  = IDELEMS(strat->Shdl);
 #endif
   if ((strat->sbaOrder == 1 || strat->sbaOrder == 3) && sRing!=currRingOld)
   {
     rChangeCurrRing (currRingOld);
     F0          = idrMoveR (F1, sRing, currRing);
     strat->Shdl = idrMoveR_NoSort (strat->Shdl, sRing, currRing);
     rDelete (sRing);
   }
   id_DelDiv(strat->Shdl, currRing);
   idSkipZeroes(strat->Shdl);
   idTest(strat->Shdl);
 
 #if SBA_PRINT_SIZE_G
   size_g   = IDELEMS(strat->Shdl);
 #endif
 #ifdef DEBUGF5
   printf("SIZE OF SHDL: %d\n",IDELEMS(strat->Shdl));
   int oo = 0;
   while (oo<IDELEMS(strat->Shdl))
   {
     printf(" %d.   ",oo+1);
     pWrite(pHead(strat->Shdl->m[oo]));
     oo++;
   }
 #endif
 #if SBA_PRINT_ZERO_REDUCTIONS
   printf("----------------------------------------------------------\n");
   printf("ZERO REDUCTIONS:            %ld\n",zeroreductions);
   zeroreductions  = 0;
 #endif
 #if SBA_PRINT_REDUCTION_STEPS
   printf("----------------------------------------------------------\n");
   printf("S-REDUCTIONS:               %ld\n",sba_reduction_steps);
 #endif
 #if SBA_PRINT_OPERATIONS
   printf("OPERATIONS:                 %ld\n",sba_operations);
 #endif
 #if SBA_PRINT_REDUCTION_STEPS
   printf("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - \n");
   printf("INTERREDUCTIONS:            %ld\n",sba_interreduction_steps);
 #endif
 #if SBA_PRINT_OPERATIONS
   printf("INTERREDUCTION OPERATIONS:  %ld\n",sba_interreduction_operations);
 #endif
 #if SBA_PRINT_REDUCTION_STEPS
   printf("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - \n");
   printf("ALL REDUCTIONS:             %ld\n",sba_reduction_steps+sba_interreduction_steps);
   sba_interreduction_steps  = 0;
   sba_reduction_steps       = 0;
 #endif
 #if SBA_PRINT_OPERATIONS
   printf("ALL OPERATIONS:             %ld\n",sba_operations+sba_interreduction_operations);
   sba_interreduction_operations = 0;
   sba_operations                = 0;
 #endif
 #if SBA_PRINT_SIZE_G
   printf("----------------------------------------------------------\n");
   printf("SIZE OF G:                  %d / %d\n",size_g,size_g_non_red);
   size_g          = 0;
   size_g_non_red  = 0;
 #endif
 #if SBA_PRINT_SIZE_SYZ
   printf("SIZE OF SYZ:                %ld\n",size_syz);
   printf("----------------------------------------------------------\n");
   size_syz  = 0;
 #endif
 #if SBA_PRINT_PRODUCT_CRITERION
   printf("PRODUCT CRITERIA:           %ld\n",product_criterion);
   product_criterion = 0;
 #endif
   return (strat->Shdl);
 }

ring sbaRing	(	kStrategy	strat,
		const ring	r = `currRing`,
		BOOLEAN	complete = `TRUE`,
		int	sgn = `1`
	)

Definition at line 9491 of file kutil.cc.

 {
   int n = rBlocks(r); // Including trailing zero!
   // if sbaOrder == 1 => use (C,monomial order from r)
   if (strat->sbaOrder == 1)
   {
     if (r->order[0] == ringorder_C || r->order[0] == ringorder_c)
     {
       return r;
     }
     ring res = rCopy0(r, TRUE, FALSE);
     res->order  = (int *)omAlloc0((n+1)*sizeof(int));
     res->block0 = (int *)omAlloc0((n+1)*sizeof(int));
     res->block1 = (int *)omAlloc0((n+1)*sizeof(int));
     int **wvhdl = (int **)omAlloc0((n+1)*sizeof(int*));
     res->wvhdl  = wvhdl;
     for (int i=1; i<n; i++)
     {
       res->order[i]   = r->order[i-1];
       res->block0[i]  = r->block0[i-1];
       res->block1[i]  = r->block1[i-1];
       res->wvhdl[i]   = r->wvhdl[i-1];
     }
 
     // new 1st block
     res->order[0]   = ringorder_C; // Prefix
     // removes useless secondary component order if defined in old ring
     for (int i=rBlocks(res); i>0; --i) {
       if (res->order[i] == ringorder_C || res->order[i] == ringorder_c) {
         res->order[i] = 0;
       }
     }
     rComplete(res, 1);
 #ifdef HAVE_PLURAL
     if (rIsPluralRing(r))
     {
       if ( nc_rComplete(r, res, false) ) // no qideal!
       {
 #ifndef SING_NDEBUG
         WarnS("error in nc_rComplete");
 #endif
         // cleanup?
 
         //      rDelete(res);
         //      return r;
 
         // just go on..
       }
     }
 #endif
     strat->tailRing = res;
     return (res);
   }
   // if sbaOrder == 3 => degree - position - ring order
   if (strat->sbaOrder == 3)
   {
     ring res = rCopy0(r, TRUE, FALSE);
     res->order  = (int *)omAlloc0((n+2)*sizeof(int));
     res->block0 = (int *)omAlloc0((n+2)*sizeof(int));
     res->block1 = (int *)omAlloc0((n+2)*sizeof(int));
     int **wvhdl = (int **)omAlloc0((n+2)*sizeof(int*));
     res->wvhdl  = wvhdl;
     for (int i=2; i<n+2; i++)
     {
       res->order[i]   = r->order[i-2];
       res->block0[i]  = r->block0[i-2];
       res->block1[i]  = r->block1[i-2];
       res->wvhdl[i]   = r->wvhdl[i-2];
     }
 
     // new 1st block
     res->order[0]   = ringorder_a; // Prefix
     res->block0[0]  = 1;
     res->wvhdl[0]   = (int *)omAlloc(res->N*sizeof(int));
     for (int i=0; i<res->N; ++i)
       res->wvhdl[0][i]  = 1;
     res->block1[0]  = si_min(res->N, rVar(res));
     // new 2nd block
     res->order[1]   = ringorder_C; // Prefix
     res->wvhdl[1]   = NULL;
     // removes useless secondary component order if defined in old ring
     for (int i=rBlocks(res); i>1; --i) {
       if (res->order[i] == ringorder_C || res->order[i] == ringorder_c) {
         res->order[i] = 0;
       }
     }
     rComplete(res, 1);
 #ifdef HAVE_PLURAL
     if (rIsPluralRing(r))
     {
       if ( nc_rComplete(r, res, false) ) // no qideal!
       {
 #ifndef SING_NDEBUG
         WarnS("error in nc_rComplete");
 #endif
         // cleanup?
 
         //      rDelete(res);
         //      return r;
 
         // just go on..
       }
     }
 #endif
     strat->tailRing = res;
     return (res);
   }
 
   // not sbaOrder == 1 => use Schreyer order
   // this is done by a trick when initializing the signatures
   // in initSLSba():
   // Instead of using the signature 1e_i for F->m[i], we start
   // with the signature LM(F->m[i])e_i for F->m[i]. Doing this we get a
   // Schreyer order w.r.t. the underlying monomial order.
   // => we do not need to change the underlying polynomial ring at all!
 
   // UPDATE/NOTE/TODO: use induced Schreyer ordering 'IS'!!!!????
 
   /*
   else
   {
     ring res = rCopy0(r, FALSE, FALSE);
     // Create 2 more blocks for prefix/suffix:
     res->order=(int *)omAlloc0((n+2)*sizeof(int)); // 0  ..  n+1
     res->block0=(int *)omAlloc0((n+2)*sizeof(int));
     res->block1=(int *)omAlloc0((n+2)*sizeof(int));
     int ** wvhdl =(int **)omAlloc0((n+2)*sizeof(int**));
 
     // Encapsulate all existing blocks between induced Schreyer ordering markers: prefix and suffix!
     // Note that prefix and suffix have the same ringorder marker and only differ in block[] parameters!
 
     // new 1st block
     int j = 0;
     res->order[j] = ringorder_IS; // Prefix
     res->block0[j] = res->block1[j] = 0;
     // wvhdl[j] = NULL;
     j++;
 
     for(int i = 0; (i < n) && (r->order[i] != 0); i++, j++) // i = [0 .. n-1] <- non-zero old blocks
     {
       res->order [j] = r->order [i];
       res->block0[j] = r->block0[i];
       res->block1[j] = r->block1[i];
 
       if (r->wvhdl[i] != NULL)
       {
         wvhdl[j] = (int*) omMemDup(r->wvhdl[i]);
       } // else wvhdl[j] = NULL;
     }
 
     // new last block
     res->order [j] = ringorder_IS; // Suffix
     res->block0[j] = res->block1[j] = sgn; // Sign of v[o]: 1 for C, -1 for c
     // wvhdl[j] = NULL;
     j++;
 
     // res->order [j] = 0; // The End!
     res->wvhdl = wvhdl;
 
     // j == the last zero block now!
     assume(j == (n+1));
     assume(res->order[0]==ringorder_IS);
     assume(res->order[j-1]==ringorder_IS);
     assume(res->order[j]==0);
 
     if (complete)
     {
       rComplete(res, 1);
 
 #ifdef HAVE_PLURAL
       if (rIsPluralRing(r))
       {
         if ( nc_rComplete(r, res, false) ) // no qideal!
         {
         }
       }
       assume(rIsPluralRing(r) == rIsPluralRing(res));
 #endif
 
 
 #ifdef HAVE_PLURAL
       ring old_ring = r;
 
 #endif
 
       if (r->qideal!=NULL)
       {
         res->qideal= idrCopyR_NoSort(r->qideal, r, res);
 
         assume(idRankFreeModule(res->qideal, res) == 0);
 
 #ifdef HAVE_PLURAL
         if( rIsPluralRing(res) )
           if( nc_SetupQuotient(res, r, true) )
           {
             //          WarnS("error in nc_SetupQuotient"); // cleanup?      rDelete(res);       return r;  // just go on...?
           }
 
 #endif
         assume(idRankFreeModule(res->qideal, res) == 0);
       }
 
 #ifdef HAVE_PLURAL
       assume((res->qideal==NULL) == (old_ring->qideal==NULL));
       assume(rIsPluralRing(res) == rIsPluralRing(old_ring));
       assume(rIsSCA(res) == rIsSCA(old_ring));
       assume(ncRingType(res) == ncRingType(old_ring));
 #endif
     }
     strat->tailRing = res;
     return res;
   }
   */
 
   assume(FALSE);
   return(NULL);
 }

void superenterpairs	(	poly	h,
		int	k,
		int	ecart,
		int	pos,
		kStrategy	strat,
		int	atR = `-1`
	)

Definition at line 3904 of file kutil.cc.

 {
 #if ADIDEBUG
   PrintS("\nEnter superenterpairs\n");
   int iii = strat->Ll;
   printf("\nstrat->tl = %i\n",strat->tl);
 #endif
   assume (rField_is_Ring(currRing));
   // enter also zero divisor * poly, if this is non zero and of smaller degree
   if (!(rField_is_Domain(currRing))) enterExtendedSpoly(h, strat);
 //#if ADIDEBUG
   #if 0
   if(iii==strat->Ll)
   {
     PrintS("\n                enterExtendedSpoly has not changed the list L.\n");
   }
   else
   {
     PrintLn();
     PrintS("\n                enterExtendedSpoly changed the list L:\n");
     for(iii=0;iii<=strat->Ll;iii++)
     {
       Print("\n                L[%d]:\n",iii);
       PrintS("                     ");p_Write(strat->L[iii].p,strat->tailRing);
       PrintS("                     ");p_Write(strat->L[iii].p1,strat->tailRing);
       PrintS("                     ");p_Write(strat->L[iii].p2,strat->tailRing);
     }
   }
   printf("\nstrat->tl = %i\n",strat->tl);
   iii = strat->Ll;
 #endif
   initenterpairs(h, k, ecart, 0, strat, atR);
 //#if ADIDEBUG
   #if 0
   if(iii==strat->Ll)
   {
     PrintS("\n                initenterpairs has not changed the list L.\n");
   }
   else
   {
     PrintS("\n                initenterpairs changed the list L:\n");
     for(iii=0;iii<=strat->Ll;iii++)
     {
       Print("\n                L[%d]:\n",iii);
       PrintS("                     ");p_Write(strat->L[iii].p1,strat->tailRing);
       PrintS("                     ");p_Write(strat->L[iii].p2,strat->tailRing);
       PrintS("                     ");p_Write(strat->L[iii].p,strat->tailRing);
     }
   }
   printf("\nstrat->tl = %i\n",strat->tl);
   iii = strat->Ll;
 #endif
   initenterstrongPairs(h, k, ecart, 0, strat, atR);
 //#if ADIDEBUG
   #if 0
   if(iii==strat->Ll)
   {
     PrintS("\n                initenterstrongPairs has not changed the list L.\n");
   }
   else
   {
     PrintS("\n                initenterstrongPairs changed the list L:\n");
     for(iii=0;iii<=strat->Ll;iii++)
     {
       Print("\n                L[%d]:\n",iii);
       PrintS("                     ");p_Write(strat->L[iii].p1,strat->tailRing);
       PrintS("                     ");p_Write(strat->L[iii].p2,strat->tailRing);
       PrintS("                     ");p_Write(strat->L[iii].p,strat->tailRing);
     }
   }
   printf("\nstrat->tl = %i\n",strat->tl);
   PrintS("\nEnd of superenterpairs\n");
 #endif
   clearSbatch(h, k, pos, strat);
 #if ADIDEBUG
   printf("\nstrat->tl = %i\n",strat->tl);
 #endif
 }

BOOLEAN syzCriterion	(	poly	sig,
		unsigned long	not_sevSig,
		kStrategy	strat
	)

Definition at line 5676 of file kutil.cc.

 {
 //#if 1
 #ifdef DEBUGF5
   Print("syzygy criterion checks:  ");
   pWrite(sig);
 #endif
   for (int k=0; k<strat->syzl; k++)
   {
     //printf("-%d",k);
 //#if 1
 #ifdef DEBUGF5
     Print("checking with: %d / %d --  \n",k,strat->syzl);
     pWrite(pHead(strat->syz[k]));
 #endif
     if (p_LmShortDivisibleBy(strat->syz[k], strat->sevSyz[k], sig, not_sevSig, currRing))
     {
 //#if 1
 #ifdef DEBUGF5
       PrintS("DELETE!\n");
 #endif
       //printf("- T -\n\n");
       return TRUE;
     }
   }
   //printf("- F -\n\n");
   return FALSE;
 }

BOOLEAN syzCriterionInc	(	poly	sig,
		unsigned long	not_sevSig,
		kStrategy	strat
	)

Definition at line 5708 of file kutil.cc.

 {
 //#if 1
 #ifdef DEBUGF5
   Print("--- syzygy criterion checks:  ");
   pWrite(sig);
 #endif
   int comp = p_GetComp(sig, currRing);
   int min, max;
   if (comp<=1)
     return FALSE;
   else
   {
     min = strat->syzIdx[comp-2];
     //printf("SYZIDX %d/%d\n",strat->syzIdx[comp-2],comp-2);
     //printf("SYZIDX %d/%d\n",strat->syzIdx[comp-1],comp-1);
     //printf("SYZIDX %d/%d\n",strat->syzIdx[comp],comp);
     if (comp == strat->currIdx)
     {
       max = strat->syzl;
     }
     else
     {
       max = strat->syzIdx[comp-1];
     }
     for (int k=min; k<max; k++)
     {
 #ifdef F5DEBUG
       Print("COMP %d/%d - MIN %d - MAX %d - SYZL %ld\n",comp,strat->currIdx,min,max,strat->syzl);
       Print("checking with: %d --  ",k);
       pWrite(pHead(strat->syz[k]));
 #endif
       if (p_LmShortDivisibleBy(strat->syz[k], strat->sevSyz[k], sig, not_sevSig, currRing))
         return TRUE;
     }
     return FALSE;
   }
 }

long twoPow ( long arg )

Definition at line 3366 of file kutil.cc.

 {
   return 1L << arg;
 }

void updateResult	(	ideal	r,
		ideal	Q,
		kStrategy	strat
	)

Definition at line 8648 of file kutil.cc.

 {
   int l;
   if (strat->ak>0)
   {
     for (l=IDELEMS(r)-1;l>=0;l--)
     {
       if ((r->m[l]!=NULL) && (pGetComp(r->m[l])==0))
       {
         pDelete(&r->m[l]); // and set it to NULL
       }
     }
     int q;
     poly p;
     for (l=IDELEMS(r)-1;l>=0;l--)
     {
       if ((r->m[l]!=NULL)
       //&& (strat->syzComp>0)
       //&& (pGetComp(r->m[l])<=strat->syzComp)
       )
       {
         for(q=IDELEMS(Q)-1; q>=0;q--)
         {
           if ((Q->m[q]!=NULL)
           &&(pLmDivisibleBy(Q->m[q],r->m[l])))
           {
             #if HAVE_RINGS
             if(!rField_is_Ring(currRing) || n_DivBy(r->m[l]->coef, Q->m[q]->coef, currRing))
             #endif
             {
                 if (TEST_OPT_REDSB)
                 {
                   p=r->m[l];
                   r->m[l]=kNF(Q,NULL,p);
                   pDelete(&p);
                 }
                 else
                 {
                   pDelete(&r->m[l]); // and set it to NULL
                 }
                 break;
             }
           }
         }
       }
     }
   }
   else
   {
     int q;
     poly p;
     BOOLEAN reduction_found=FALSE;
     if (!rField_is_Ring(currRing))
     {
       for (l=IDELEMS(r)-1;l>=0;l--)
       {
         if (r->m[l]!=NULL)
         {
           for(q=IDELEMS(Q)-1; q>=0;q--)
           {
             if ((Q->m[q]!=NULL)&&(pLmEqual(Q->m[q],r->m[l])))
             {
               if (TEST_OPT_REDSB)
               {
                 p=r->m[l];
                 r->m[l]=kNF(Q,NULL,p);
                 pDelete(&p);
                 reduction_found=TRUE;
               }
               else
               {
                 pDelete(&r->m[l]); // and set it to NULL
               }
               break;
             }
           }
         }
       }
     }
     #ifdef HAVE_RINGS
     //Also need divisibility of the leading coefficients
     else
     {
       for (l=IDELEMS(r)-1;l>=0;l--)
       {
         if (r->m[l]!=NULL)
         {
           for(q=IDELEMS(Q)-1; q>=0;q--)
           {
             if(!rField_is_Ring(currRing) || n_DivBy(r->m[l]->coef, Q->m[q]->coef, currRing))
             {
                 if ((Q->m[q]!=NULL)&&(pLmEqual(Q->m[q],r->m[l])) && pDivisibleBy(Q->m[q],r->m[l]))
                 {
                   if (TEST_OPT_REDSB)
                   {
                     p=r->m[l];
                     r->m[l]=kNF(Q,NULL,p);
                     pDelete(&p);
                     reduction_found=TRUE;
                   }
                   else
                   {
                     pDelete(&r->m[l]); // and set it to NULL
                   }
               break;
               }
             }
           }
         }
       }
     }
     #endif
     if (/*TEST_OPT_REDSB &&*/ reduction_found)
     {
       for (l=IDELEMS(r)-1;l>=0;l--)
       {
         if (r->m[l]!=NULL)
         {
           for(q=IDELEMS(r)-1;q>=0;q--)
           {
             if ((l!=q)
             && (r->m[q]!=NULL)
             &&(pLmDivisibleBy(r->m[l],r->m[q]))
             #if HAVE_RINGS
             && (!rField_is_Ring(currRing) ||
                 n_DivBy(r->m[q]->coef, r->m[l]->coef, currRing))
             #endif
             )
             {
                 //If they are equal then take the one with the smallest length
                 if(pLmDivisibleBy(r->m[q],r->m[l])
                 #ifdef HAVE_RINGS
                 && ((rField_is_Ring(currRing)
                 && n_DivBy(r->m[q]->coef, r->m[l]->coef, currRing))
                 || !(rField_is_Ring(currRing)))
                 #endif
                 && (pLength(r->m[q]) < pLength(r->m[l]) ||
                 (pLength(r->m[q]) == pLength(r->m[l]) && nGreaterZero(r->m[q]->coef))))
                 {
                   pDelete(&r->m[l]);
                   break;
                 }
                 else
                   pDelete(&r->m[q]);
             }
           }
         }
       }
     }
   }
   idSkipZeroes(r);
 }

void updateS	(	BOOLEAN	toT,
		kStrategy	strat
	)

Definition at line 7345 of file kutil.cc.

 {
   LObject h;
   int i, suc=0;
   poly redSi=NULL;
   BOOLEAN change,any_change;
 //  Print("nach initS: updateS start mit sl=%d\n",(strat->sl));
 //  for (i=0; i<=(strat->sl); i++)
 //  {
 //    Print("s%d:",i);
 //    if (strat->fromQ!=NULL) Print("(Q:%d) ",strat->fromQ[i]);
 //    pWrite(strat->S[i]);
 //  }
 //  Print("currRing->OrdSgn=%d\n", currRing->OrdSgn);
   any_change=FALSE;
   if (rHasGlobalOrdering(currRing))
   {
     while (suc != -1)
     {
       i=suc+1;
       while (i<=strat->sl)
       {
         change=FALSE;
         #ifdef HAVE_RINGS
         if(rField_is_Ring(currRing))
             any_change = FALSE;
         #endif
         if (((strat->fromQ==NULL) || (strat->fromQ[i]==0)) && (i>0))
         {
           redSi = pHead(strat->S[i]);
           strat->S[i] = redBba(strat->S[i],i-1,strat);
           //if ((strat->ak!=0)&&(strat->S[i]!=NULL))
           //  strat->S[i]=redQ(strat->S[i],i+1,strat); /*reduce S[i] mod Q*/
           if (pCmp(redSi,strat->S[i])!=0)
           {
             change=TRUE;
             any_change=TRUE;
             #ifdef KDEBUG
             if (TEST_OPT_DEBUG)
             {
               PrintS("reduce:");
               wrp(redSi);PrintS(" to ");p_wrp(strat->S[i], currRing, strat->tailRing);PrintLn();
             }
             #endif
             if (TEST_OPT_PROT)
             {
               if (strat->S[i]==NULL)
                 PrintS("V");
               else
                 PrintS("v");
               mflush();
             }
           }
           pLmDelete(&redSi);
           if (strat->S[i]==NULL)
           {
             deleteInS(i,strat);
             i--;
           }
           else if (change)
           {
             if (TEST_OPT_INTSTRATEGY)
             {
               if (TEST_OPT_CONTENTSB)
                 {
                   number n;
                   p_Cleardenom_n(strat->S[i], currRing, n);// also does a pContent
                   if (!nIsOne(n))
                     {
                       denominator_list denom=(denominator_list)omAlloc(sizeof(denominator_list_s));
                       denom->n=nInvers(n);
                       denom->next=DENOMINATOR_LIST;
                       DENOMINATOR_LIST=denom;
                     }
                   nDelete(&n);
                 }
               else
                 {
                   //pContent(strat->S[i]);
                   strat->S[i]=p_Cleardenom(strat->S[i], currRing);// also does a pContent
                 }
             }
             else
             {
               pNorm(strat->S[i]);
             }
             strat->sevS[i] = pGetShortExpVector(strat->S[i]);
           }
         }
         i++;
       }
       if (any_change) reorderS(&suc,strat);
       else break;
     }
     if (toT)
     {
       for (i=0; i<=strat->sl; i++)
       {
         if ((strat->fromQ==NULL) || (strat->fromQ[i]==0))
         {
           h.p = redtailBba(strat->S[i],i-1,strat);
           if (TEST_OPT_INTSTRATEGY)
           {
             h.pCleardenom();// also does a pContent
           }
         }
         else
         {
           h.p = strat->S[i];
         }
         strat->initEcart(&h);
         if (strat->honey)
         {
           strat->ecartS[i] = h.ecart;
         }
         if (strat->sevS[i] == 0) {strat->sevS[i] = pGetShortExpVector(h.p);}
         else assume(strat->sevS[i] == pGetShortExpVector(h.p));
         h.sev = strat->sevS[i];
         /*puts the elements of S also to T*/
         strat->initEcart(&h);
         enterT(h,strat);
         strat->S_2_R[i] = strat->tl;
       }
     }
   }
   else
   {
     while (suc != -1)
     {
       i=suc;
       while (i<=strat->sl)
       {
         change=FALSE;
         if (((strat->fromQ==NULL) || (strat->fromQ[i]==0)) && (i>0))
         {
           redSi=pHead((strat->S)[i]);
           (strat->S)[i] = redMora((strat->S)[i],i-1,strat);
           if ((strat->S)[i]==NULL)
           {
             deleteInS(i,strat);
             i--;
           }
           else if (pCmp((strat->S)[i],redSi)!=0)
           {
             any_change=TRUE;
             h.p = strat->S[i];
             strat->initEcart(&h);
             strat->ecartS[i] = h.ecart;
             if (TEST_OPT_INTSTRATEGY)
             {
               if (TEST_OPT_CONTENTSB)
                 {
                   number n;
                   p_Cleardenom_n(strat->S[i], currRing, n);// also does a pContent
                   if (!nIsOne(n))
                     {
                       denominator_list denom=(denominator_list)omAlloc(sizeof(denominator_list_s));
                       denom->n=nInvers(n);
                       denom->next=DENOMINATOR_LIST;
                       DENOMINATOR_LIST=denom;
                     }
                   nDelete(&n);
                 }
               else
                 {
                   //pContent(strat->S[i]);
                   strat->S[i]=p_Cleardenom(strat->S[i], currRing);// also does a pContent
                 }
             }
             else
             {
               pNorm(strat->S[i]); // == h.p
             }
             h.sev =  pGetShortExpVector(h.p);
             strat->sevS[i] = h.sev;
           }
           pLmDelete(&redSi);
           kTest(strat);
         }
         i++;
       }
 #ifdef KDEBUG
       kTest(strat);
 #endif
       if (any_change) reorderS(&suc,strat);
       else { suc=-1; break; }
       if (h.p!=NULL)
       {
         if (!strat->kHEdgeFound)
         {
           /*strat->kHEdgeFound =*/ HEckeTest(h.p,strat);
         }
         if (strat->kHEdgeFound)
           newHEdge(strat);
       }
     }
     for (i=0; i<=strat->sl; i++)
     {
       if ((strat->fromQ==NULL) || (strat->fromQ[i]==0))
       {
         strat->S[i] = h.p = redtail(strat->S[i],strat->sl,strat);
         strat->initEcart(&h);
         strat->ecartS[i] = h.ecart;
         h.sev = pGetShortExpVector(h.p);
         strat->sevS[i] = h.sev;
       }
       else
       {
         h.p = strat->S[i];
         h.ecart=strat->ecartS[i];
         h.sev = strat->sevS[i];
         h.length = h.pLength = pLength(h.p);
       }
       if ((strat->fromQ==NULL) || (strat->fromQ[i]==0))
         cancelunit1(&h,&suc,strat->sl,strat);
       h.SetpFDeg();
       /*puts the elements of S also to T*/
       enterT(h,strat);
       strat->S_2_R[i] = strat->tl;
     }
     if (suc!= -1) updateS(toT,strat);
   }
 #ifdef KDEBUG
   kTest(strat);
 #endif
 }

void updateSShift	(	kStrategy	strat,
		int	uptodeg,
		int	lV
	)

Definition at line 10152 of file kutil.cc.

 {
   /* to use after updateS(toT=FALSE,strat) */
   /* fills T with shifted elt's of S */
   int i;
   LObject h;
   int atT = -1; // or figure out smth better
   strat->tl = -1; // init
   for (i=0; i<=strat->sl; i++)
   {
     memset(&h,0,sizeof(h));
     h.p =  strat->S[i]; // lm in currRing, tail in TR
     strat->initEcart(&h);
     h.sev = strat->sevS[i];
     h.t_p = NULL;
     h.GetTP(); // creates correct t_p
     /*puts the elements of S with their shifts to T*/
     //    int atT, int uptodeg, int lV)
     strat->S_2_R[i] = strat->tl + 1; // the el't with shift 0 will be inserted first
     // need a small check for above; we insert >=1 elements
     // insert this check into kTest_TS ?
     enterTShift(h,strat,atT,uptodeg,lV);
   }
   /* what about setting strat->tl? */
 }

Variable Documentation

denominator_list DENOMINATOR_LIST

Definition at line 81 of file kutil.cc.

int HCord

Definition at line 227 of file kutil.cc.

int strat_nr

Definition at line 27 of file kstdfac.cc.

int(* test_PosInL) (const LSet set, const int length, LObject *L, const kStrategy strat)

Definition at line 99 of file kstd2.cc.

int(* test_PosInT) (const TSet T, const int tl, LObject &h)

Definition at line 98 of file kstd2.cc.

Data Structures

Macros

Typedefs

Functions

Variables

Data Structure Documentation

Macro Definition Documentation

Typedef Documentation

Function Documentation

Variable Documentation