My Project
Macros | Functions | Variables
kutil.cc File Reference
#include "kernel/mod2.h"
#include "misc/mylimits.h"
#include "misc/options.h"
#include "polys/nc/nc.h"
#include "polys/nc/sca.h"
#include "polys/weight.h"
#include <stdlib.h>
#include <string.h>
#include "kernel/GBEngine/kutil.h"
#include "polys/kbuckets.h"
#include "coeffs/numbers.h"
#include "kernel/polys.h"
#include "polys/monomials/ring.h"
#include "kernel/ideals.h"
#include "kernel/combinatorics/stairc.h"
#include "kernel/GBEngine/kstd1.h"
#include "polys/operations/pShallowCopyDelete.h"
#include "polys/shiftop.h"
#include "polys/prCopy.h"
#include "kernel/GBEngine/ratgring.h"

Go to the source code of this file.

Macros

#define KUTIL_CC
 
#define MYTEST   0
 
#define ALL_VS_JUST   0
 
#define EXT_POLY_NEW   0
 
#define KDEBUG   2
 
#define ENTER_USE_MEMMOVE
 
#define KDEBUG   2
 
#define pDivComp_EQUAL   2
 
#define pDivComp_LESS   1
 
#define pDivComp_GREATER   -1
 
#define pDivComp_INCOMP   0
 
#define kFalseReturn(x)   do { if (!x) return FALSE;} while (0)
 

Functions

static poly redMora (poly h, int maxIndex, kStrategy strat)
 
static poly redBba (poly h, int maxIndex, kStrategy strat)
 
static int pDivCompRing (poly p, poly q)
 
static int pDivComp (poly p, poly q)
 
static int pLPDivComp (poly p, poly q)
 
static void deleteHCBucket (LObject *L, kStrategy strat)
 
void deleteHC (LObject *L, kStrategy strat, BOOLEAN fromNext)
 
void deleteHC (poly *p, int *e, int *l, kStrategy strat)
 
void cancelunit (LObject *L, BOOLEAN inNF)
 
void HEckeTest (poly pp, kStrategy strat)
 
static intset initec (const int maxnr)
 
static unsigned long * initsevS (const int maxnr)
 
static int * initS_2_R (const int maxnr)
 
static void enlargeT (TSet &T, TObject **&R, unsigned long *&sevT, int &length, const int incr)
 
void cleanT (kStrategy strat)
 
void cleanTSbaRing (kStrategy strat)
 
static void enlargeL (LSet *L, int *length, const int incr)
 
void initPairtest (kStrategy strat)
 
BOOLEAN isInPairsetL (int length, poly p1, poly p2, int *k, kStrategy strat)
 
BOOLEAN isInPairsetB (poly q, int *k, kStrategy strat)
 
int kFindInT (poly p, TSet T, int tlength)
 returns index of p in TSet, or -1 if not found More...
 
int kFindInT (poly p, kStrategy strat)
 
int kFindInTShift (poly p, TSet T, int tlength)
 
int kFindInTShift (poly p, kStrategy strat)
 
static const char * kTest_LmEqual (poly p, poly t_p, ring tailRing)
 
BOOLEAN kTest_T (TObject *T, kStrategy strat, int i, char TN)
 
BOOLEAN kTest_L (LObject *L, kStrategy strat, BOOLEAN testp, int lpos, TSet T, int tlength)
 
BOOLEAN kTest (kStrategy strat)
 
BOOLEAN kTest_S (kStrategy strat)
 
BOOLEAN kTest_TS (kStrategy strat)
 
void deleteInS (int i, kStrategy strat)
 
void deleteInSSba (int i, kStrategy strat)
 
static BOOLEAN is_shifted_p1 (const poly p, const kStrategy strat)
 
void deleteInL (LSet set, int *length, int j, kStrategy strat)
 
void enterL (LSet *set, int *length, int *LSetmax, LObject p, int at)
 
void initEcartNormal (TObject *h)
 
void initEcartBBA (TObject *h)
 
void initEcartPairBba (LObject *Lp, poly, poly, int, int)
 
void initEcartPairMora (LObject *Lp, poly, poly, int ecartF, int ecartG)
 
static BOOLEAN sugarDivisibleBy (int ecart1, int ecart2)
 
static void enterOnePairRing (int i, poly p, int, int isFromQ, kStrategy strat, int atR)
 
static BOOLEAN enterOneStrongPoly (int i, poly p, int, int, kStrategy strat, int atR, bool enterTstrong)
 
BOOLEAN sbaCheckGcdPair (LObject *h, kStrategy strat)
 
static BOOLEAN enterOneStrongPolySig (int i, poly p, poly sig, int, int, kStrategy strat, int atR)
 
void enterOnePairNormal (int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR=-1)
 
static BOOLEAN p_HasNotCF_Lift (poly p1, poly p2, const ring r)
 p_HasNotCF for the IDLIFT case and syzComp==1: ignore component More...
 
static void enterOnePairLift (int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR=-1)
 
static void enterOnePairSig (int i, poly p, poly pSig, int, int ecart, int isFromQ, kStrategy strat, int atR=-1)
 
static void enterOnePairSigRing (int i, poly p, poly pSig, int, int ecart, int isFromQ, kStrategy strat, int atR=-1)
 
void enterOnePairSpecial (int i, poly p, int ecart, kStrategy strat, int atR=-1)
 
void kMergeBintoL (kStrategy strat)
 
void kMergeBintoLSba (kStrategy strat)
 
void chainCritNormal (poly p, int ecart, kStrategy strat)
 
void chainCritOpt_1 (poly, int, kStrategy strat)
 
void chainCritSig (poly p, int, kStrategy strat)
 
void chainCritPart (poly p, int ecart, kStrategy strat)
 
void initenterpairs (poly h, int k, int ecart, int isFromQ, kStrategy strat, int atR)
 
void initenterpairsSig (poly h, poly hSig, int hFrom, int k, int ecart, int isFromQ, kStrategy strat, int atR=-1)
 
void initenterpairsSigRing (poly h, poly hSig, int hFrom, int k, int ecart, int isFromQ, kStrategy strat, int atR=-1)
 
void chainCritRing (poly p, int, kStrategy strat)
 
void initenterstrongPairs (poly h, int k, int ecart, int isFromQ, kStrategy strat, int atR=-1)
 
static void initenterstrongPairsSig (poly h, poly hSig, int k, int ecart, int isFromQ, kStrategy strat, int atR=-1)
 
void enterExtendedSpoly (poly h, kStrategy strat)
 
void enterExtendedSpolySig (poly h, poly hSig, kStrategy strat)
 
void clearSbatch (poly h, int k, int pos, kStrategy strat)
 
void superenterpairs (poly h, int k, int ecart, int pos, kStrategy strat, int atR)
 
void superenterpairsSig (poly h, poly hSig, int hFrom, int k, int ecart, int pos, kStrategy strat, int atR)
 
void enterpairs (poly h, int k, int ecart, int pos, kStrategy strat, int atR)
 
void enterpairsSig (poly h, poly hSig, int hFrom, int k, int ecart, int pos, kStrategy strat, int atR)
 
void enterpairsSpecial (poly h, int k, int ecart, int pos, kStrategy strat, int atR=-1)
 
void reorderS (int *suc, kStrategy strat)
 
int posInS (const kStrategy strat, const int length, const poly p, const int ecart_p)
 
int posInSMonFirst (const kStrategy strat, const int length, const poly p)
 
int posInIdealMonFirst (const ideal F, const poly p, int start, int end)
 
int posInT0 (const TSet, const int length, LObject &)
 
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 posInT11Ring (const TSet set, const int length, LObject &p)
 
int posInTrg0 (const TSet set, const int length, LObject &p)
 
int posInT110 (const TSet set, const int length, LObject &p)
 
int posInT110Ring (const TSet set, const int length, LObject &p)
 
int posInT13 (const TSet set, const int length, LObject &p)
 
int posInT_EcartpLength (const TSet set, const int length, LObject &p)
 
int posInT15 (const TSet set, const int length, LObject &p)
 
int posInT15Ring (const TSet set, const int length, LObject &p)
 
int posInT17 (const TSet set, const int length, LObject &p)
 
int posInT17Ring (const TSet set, const int length, LObject &p)
 
int posInT17_c (const TSet set, const int length, LObject &p)
 
int posInT17_cRing (const TSet set, const int length, LObject &p)
 
int posInT19 (const TSet set, const int length, LObject &p)
 
int posInLSpecial (const LSet set, const int length, LObject *p, const kStrategy)
 
int posInL0 (const LSet set, const int length, LObject *p, const kStrategy)
 
int posInL0Ring (const LSet set, const int length, LObject *p, const kStrategy)
 
int posInLSig (const LSet set, const int length, LObject *p, const kStrategy)
 
int posInLSigRing (const LSet set, const int length, LObject *p, const kStrategy)
 
int posInLRing (const LSet set, const int length, LObject *p, const kStrategy)
 
int posInSyz (const kStrategy strat, poly sig)
 
int posInLF5C (const LSet, const int, LObject *, const kStrategy strat)
 
int posInL11 (const LSet set, const int length, LObject *p, const kStrategy)
 
int posInL11Ring (const LSet set, const int length, LObject *p, const kStrategy)
 
int posInLF5CRing (const LSet set, int start, const int length, LObject *p, const kStrategy)
 
int posInL11Ringls (const LSet set, const int length, LObject *p, const kStrategy)
 
int getIndexRng (long coeff)
 
int posInLrg0 (const LSet set, const int length, LObject *p, const kStrategy)
 
int posInL110 (const LSet set, const int length, LObject *p, const kStrategy)
 
int posInL110Ring (const LSet set, const int length, LObject *p, const kStrategy)
 
int posInL13 (const LSet set, const int length, LObject *p, const kStrategy)
 
int posInL15 (const LSet set, const int length, LObject *p, const kStrategy)
 
int posInL15Ring (const LSet set, const int length, LObject *p, const kStrategy)
 
int posInL17 (const LSet set, const int length, LObject *p, const kStrategy)
 
int posInL17Ring (const LSet set, const int length, LObject *p, const kStrategy)
 
int posInL17_c (const LSet set, const int length, LObject *p, const kStrategy)
 
int posInL17_cRing (const LSet set, const int length, LObject *p, const kStrategy)
 
BOOLEAN syzCriterion (poly sig, unsigned long not_sevSig, kStrategy strat)
 
BOOLEAN syzCriterionInc (poly sig, unsigned long not_sevSig, kStrategy strat)
 
BOOLEAN faugereRewCriterion (poly sig, unsigned long not_sevSig, poly, kStrategy strat, int start=0)
 
BOOLEAN arriRewCriterion (poly, unsigned long, poly, kStrategy strat, int start=0)
 
BOOLEAN arriRewCriterionPre (poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int)
 
TObjectkFindDivisibleByInS_T (kStrategy strat, int end_pos, LObject *L, TObject *T, long ecart)
 
poly redtail (LObject *L, int end_pos, kStrategy strat)
 
poly redtail (poly p, int end_pos, kStrategy strat)
 
poly redtailBba (LObject *L, int end_pos, kStrategy strat, BOOLEAN withT, BOOLEAN normalize)
 
poly redtailBbaBound (LObject *L, int end_pos, kStrategy strat, int bound, BOOLEAN withT, BOOLEAN normalize)
 
void redtailBbaAlsoLC_Z (LObject *L, int end_pos, kStrategy strat)
 
poly redtailBba_Z (LObject *L, int end_pos, kStrategy strat)
 
poly redtailBba_Ring (LObject *L, int end_pos, kStrategy strat)
 
void message (int i, int *reduc, int *olddeg, kStrategy strat, int red_result)
 
void messageStat (int hilbcount, kStrategy strat)
 
void messageStatSBA (int hilbcount, kStrategy strat)
 
void messageSets (kStrategy strat)
 
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 initSSpecial (ideal F, ideal Q, ideal P, kStrategy strat)
 
void initSSpecialSba (ideal F, ideal Q, ideal P, kStrategy strat)
 
static poly redBba1 (poly h, int maxIndex, kStrategy strat)
 
void cancelunit1 (LObject *p, int *suc, int index, kStrategy strat)
 
void updateS (BOOLEAN toT, kStrategy strat)
 
void enterSBba (LObject &p, int atS, kStrategy strat, int atR)
 
void enterSBbaShift (LObject &p, int atS, kStrategy strat, int atR)
 
void enterSSba (LObject &p, int atS, kStrategy strat, int atR)
 
void replaceInLAndSAndT (LObject &p, int tj, kStrategy strat)
 
void enterT (LObject &p, kStrategy strat, int atT)
 
void enterT_strong (LObject &p, kStrategy strat, int atT)
 
void enterSyz (LObject &p, kStrategy strat, int atT)
 
void initHilbCrit (ideal, ideal, intvec **hilb, kStrategy strat)
 
void initBuchMoraCrit (kStrategy strat)
 
void initSbaCrit (kStrategy strat)
 
BOOLEAN kPosInLDependsOnLength (int(*pos_in_l)(const LSet set, const int length, LObject *L, const kStrategy strat))
 
void initBuchMoraPos (kStrategy strat)
 
void initBuchMoraPosRing (kStrategy strat)
 
void initBuchMora (ideal F, ideal Q, kStrategy strat)
 
void exitBuchMora (kStrategy strat)
 
void initSbaPos (kStrategy strat)
 
void initSbaBuchMora (ideal F, ideal Q, kStrategy strat)
 
void exitSba (kStrategy strat)
 
void updateResult (ideal r, ideal Q, kStrategy strat)
 
void completeReduce (kStrategy strat, BOOLEAN withT)
 
BOOLEAN newHEdge (kStrategy strat)
 
BOOLEAN kCheckSpolyCreation (LObject *L, kStrategy strat, poly &m1, poly &m2)
 
BOOLEAN kCheckStrongCreation (int atR, poly m1, int atS, poly m2, kStrategy strat)
 
poly preIntegerCheck (const ideal Forig, const ideal Q)
 used for GB over ZZ: look for constant and monomial elements in the ideal background: any known 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 postReduceByMonSig (LObject *h, kStrategy strat)
 
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, TObject *T, unsigned long expbound)
 
void kStratInitChangeTailRing (kStrategy strat)
 
ring sbaRing (kStrategy strat, const ring r, BOOLEAN, int)
 
int posInT_EcartFDegpLength (const TSet set, const int length, LObject &p)
 
int posInT_FDegpLength (const TSet set, const int length, LObject &p)
 
int posInT_pLength (const TSet set, const int length, LObject &p)
 
int redFirst (LObject *h, kStrategy strat)
 
int redEcart (LObject *h, kStrategy strat)
 
void enterSMora (LObject &p, int atS, kStrategy strat, int atR=-1)
 
void enterSMoraNF (LObject &p, int atS, kStrategy strat, int atR=-1)
 
char * showOption ()
 
void kDebugPrint (kStrategy strat)
 Output some debug info about a given strategy. More...
 
poly pMove2CurrTail (poly p, kStrategy strat)
 
poly pMoveCurrTail2poly (poly p, kStrategy strat)
 
poly pCopyL2p (LObject H, kStrategy strat)
 
static BOOLEAN enterOneStrongPolyShift (poly q, poly p, int, int, kStrategy strat, int atR, int, int, int shiftcount, int ifromS)
 
static void enterOnePairRingShift (poly q, poly p, int, int isFromQ, kStrategy strat, int atR, int, int qisFromQ, int shiftcount, int ifromS)
 
static BOOLEAN enterOneStrongPolyAndEnterOnePairRingShift (poly q, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int ecartq, int qisFromQ, int shiftcount, int ifromS)
 
static BOOLEAN enterOnePairWithShifts (int q_inS, poly q, poly p, int ecartp, int p_isFromQ, kStrategy strat, int, int p_lastVblock, int q_lastVblock)
 
static BOOLEAN enterOnePairWithoutShifts (int p_inS, poly q, poly p, int ecartq, int q_isFromQ, kStrategy strat, int, int p_lastVblock, int q_shift)
 
BOOLEAN enterOnePairShift (poly q, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int ecartq, int qisFromQ, int shiftcount, int ifromS)
 
void initenterpairsShift (poly h, int k, int ecart, int isFromQ, kStrategy strat, int atR)
 
void initenterstrongPairsShift (poly h, int k, int ecart, int isFromQ, kStrategy strat, int atR)
 
void enterpairsShift (poly h, int k, int ecart, int pos, kStrategy strat, int atR)
 
void enterTShift (LObject p, kStrategy strat, int atT)
 
poly redtailBbaShift (LObject *L, int pos, kStrategy strat, BOOLEAN withT, BOOLEAN normalize)
 

Variables

VAR denominator_list DENOMINATOR_LIST =NULL
 
VAR int HCord
 
VAR int Kstd1_deg
 
VAR int Kstd1_mu =INT_MAX
 
STATIC_VAR BOOLEAN sloppy_max = FALSE
 

Macro Definition Documentation

◆ ALL_VS_JUST

#define ALL_VS_JUST   0

Definition at line 17 of file kutil.cc.

◆ ENTER_USE_MEMMOVE

#define ENTER_USE_MEMMOVE

Definition at line 47 of file kutil.cc.

◆ EXT_POLY_NEW

#define EXT_POLY_NEW   0

Definition at line 21 of file kutil.cc.

◆ KDEBUG [1/2]

#define KDEBUG   2

Definition at line 76 of file kutil.cc.

◆ KDEBUG [2/2]

#define KDEBUG   2

Definition at line 76 of file kutil.cc.

◆ kFalseReturn

#define kFalseReturn (   x)    do { if (!x) return FALSE;} while (0)

Definition at line 804 of file kutil.cc.

◆ KUTIL_CC

#define KUTIL_CC

Definition at line 10 of file kutil.cc.

◆ MYTEST

#define MYTEST   0

Definition at line 12 of file kutil.cc.

◆ pDivComp_EQUAL

#define pDivComp_EQUAL   2

Definition at line 135 of file kutil.cc.

◆ pDivComp_GREATER

#define pDivComp_GREATER   -1

Definition at line 137 of file kutil.cc.

◆ pDivComp_INCOMP

#define pDivComp_INCOMP   0

Definition at line 138 of file kutil.cc.

◆ pDivComp_LESS

#define pDivComp_LESS   1

Definition at line 136 of file kutil.cc.

Function Documentation

◆ arriRewCriterion()

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

Definition at line 6929 of file kutil.cc.

6930 {
6932  return FALSE;
6933  poly p1 = pOne();
6934  poly p2 = pOne();
6935  for (int ii=strat->sl; ii>start; ii--)
6936  {
6937  if (p_LmShortDivisibleBy(strat->sig[ii], strat->sevSig[ii], strat->P.sig, ~strat->P.sevSig, currRing))
6938  {
6939  p_ExpVectorSum(p1,strat->P.sig,strat->S[ii],currRing);
6940  p_ExpVectorSum(p2,strat->sig[ii],strat->P.p,currRing);
6941  if (!(pLmCmp(p1,p2) == 1))
6942  {
6943  pDelete(&p1);
6944  pDelete(&p2);
6945  return TRUE;
6946  }
6947  }
6948  }
6949  pDelete(&p1);
6950  pDelete(&p2);
6951  return FALSE;
6952 }
#define TRUE
Definition: auxiliary.h:100
#define FALSE
Definition: auxiliary.h:96
polyset S
Definition: kutil.h:306
unsigned long * sevSig
Definition: kutil.h:324
polyset sig
Definition: kutil.h:308
LObject P
Definition: kutil.h:302
int sl
Definition: kutil.h:348
static void p_ExpVectorSum(poly pr, poly p1, poly p2, const ring r)
Definition: p_polys.h:1427
static BOOLEAN p_LmShortDivisibleBy(poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, const ring r)
Definition: p_polys.h:1931
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
#define pDelete(p_ptr)
Definition: polys.h:186
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
Definition: polys.h:105
#define pOne()
Definition: polys.h:315
#define rField_is_Ring(R)
Definition: ring.h:486

◆ arriRewCriterionPre()

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

Definition at line 6954 of file kutil.cc.

6955 {
6956  //Over Rings, there are still some changes to do: considering coeffs
6958  return FALSE;
6959  int found = -1;
6960  for (int i=strat->Bl; i>-1; i--)
6961  {
6962  if (pLmEqual(strat->B[i].sig,sig))
6963  {
6964  found = i;
6965  break;
6966  }
6967  }
6968  if (found != -1)
6969  {
6970  if (pLmCmp(lm,strat->B[found].GetLmCurrRing()) == -1)
6971  {
6972  deleteInL(strat->B,&strat->Bl,found,strat);
6973  }
6974  else
6975  {
6976  return TRUE;
6977  }
6978  }
6979  poly p1 = pOne();
6980  poly p2 = pOne();
6981  for (int ii=strat->sl; ii>-1; ii--)
6982  {
6983  if (p_LmShortDivisibleBy(strat->sig[ii], strat->sevSig[ii], sig, not_sevSig, currRing))
6984  {
6985  p_ExpVectorSum(p1,sig,strat->S[ii],currRing);
6986  p_ExpVectorSum(p2,strat->sig[ii],lm,currRing);
6987  if (!(pLmCmp(p1,p2) == 1))
6988  {
6989  pDelete(&p1);
6990  pDelete(&p2);
6991  return TRUE;
6992  }
6993  }
6994  }
6995  pDelete(&p1);
6996  pDelete(&p2);
6997  return FALSE;
6998 }
int i
Definition: cfEzgcd.cc:132
int Bl
Definition: kutil.h:352
LSet B
Definition: kutil.h:328
bool found
Definition: facFactorize.cc:55
void deleteInL(LSet set, int *length, int j, kStrategy strat)
Definition: kutil.cc:1295
#define pLmEqual(p1, p2)
Definition: polys.h:111

◆ cancelunit()

void cancelunit ( LObject L,
BOOLEAN  inNF 
)

Definition at line 373 of file kutil.cc.

374 {
375  if(rHasGlobalOrdering (currRing)) return;
376  if(TEST_OPT_CANCELUNIT) return;
377 
378  ring r = L->tailRing;
379  poly p = L->GetLmTailRing();
380  if(p_GetComp(p, r) != 0 && !p_OneComp(p, r)) return;
381 
382  number lc=NULL; /*dummy, is always set if rField_is_Ring(r) */
383  if (rField_is_Ring(r) /*&& (rHasLocalOrMixedOrdering(r))*/)
384  lc = pGetCoeff(p);
385 
386  // Leading coef have to be a unit
387  // example 2x+4x2 should be simplified to 2x*(1+2x)
388  // and 2 is not a unit in Z
389  //if ( !(n_IsUnit(pGetCoeff(p), r->cf)) ) return;
390 
391 // for(i=r->N;i>0;i--)
392 // {
393 // if ((p_GetExp(p,i,r)>0) && (rIsPolyVar(i, r)==TRUE)) return;
394 // }
395  poly h = pNext(p);
396  int i;
397 
399  {
400  loop
401  {
402  if (h==NULL)
403  {
404  p_Delete(&pNext(p), r);
405  if (!inNF)
406  {
407  number eins= nCopy(lc);
408  if (L->p != NULL)
409  {
410  pSetCoeff(L->p,eins);
411  if (L->t_p != NULL)
412  pSetCoeff0(L->t_p,eins);
413  }
414  else
415  pSetCoeff(L->t_p,eins);
416  /* p and t_p share the same coeff, if both are !=NULL */
417  /* p==NULL==t_p cannot happen here */
418  }
419  L->ecart = 0;
420  L->length = 1;
421  //if (L->pLength > 0)
422  L->pLength = 1;
423  L->max_exp = NULL;
424 
425  if (L->t_p != NULL && pNext(L->t_p) != NULL)
426  p_Delete(&pNext(L->t_p),r);
427  if (L->p != NULL && pNext(L->p) != NULL)
428  pNext(L->p) = NULL;
429  return;
430  }
431  i = rVar(r);
432  loop
433  {
434  if (p_GetExp(p,i,r) > p_GetExp(h,i,r)) return; // does not divide
435  i--;
436  if (i == 0) break; // does divide, try next monom
437  }
438  //wrp(p); PrintS(" divide ");wrp(h); PrintLn();
439  // Note: As long as qring j forbidden if j contains integer (i.e. ground rings are
440  // domains), no zerodivisor test needed CAUTION
441  if (!n_DivBy(pGetCoeff(h),lc,r->cf))
442  {
443  return;
444  }
445  pIter(h);
446  }
447  }
448  else
449  {
450  loop
451  {
452  if (h==NULL)
453  {
454  p_Delete(&pNext(p), r);
455  if (!inNF)
456  {
457  number eins=nInit(1);
458  if (L->p != NULL)
459  {
460  pSetCoeff(L->p,eins);
461  if (L->t_p != NULL)
462  pSetCoeff0(L->t_p,eins);
463  }
464  else
465  pSetCoeff(L->t_p,eins);
466  /* p and t_p share the same coeff, if both are !=NULL */
467  /* p==NULL==t_p cannot happen here */
468  }
469  L->ecart = 0;
470  L->length = 1;
471  //if (L->pLength > 0)
472  L->pLength = 1;
473  L->max_exp = NULL;
474 
475  if (L->t_p != NULL && pNext(L->t_p) != NULL)
476  p_Delete(&pNext(L->t_p),r);
477  if (L->p != NULL && pNext(L->p) != NULL)
478  pNext(L->p) = NULL;
479 
480  return;
481  }
482  i = rVar(r);
483  loop
484  {
485  if (p_GetExp(p,i,r) > p_GetExp(h,i,r)) return; // does not divide
486  i--;
487  if (i == 0) break; // does divide, try next monom
488  }
489  //wrp(p); PrintS(" divide ");wrp(h); PrintLn();
490  pIter(h);
491  }
492  }
493 }
CanonicalForm lc(const CanonicalForm &f)
int p
Definition: cfModGcd.cc:4078
static FORCE_INLINE BOOLEAN n_DivBy(number a, number b, const coeffs r)
test whether 'a' is divisible 'b'; for r encoding a field: TRUE iff 'b' does not represent zero in Z:...
Definition: coeffs.h:753
STATIC_VAR Poly * h
Definition: janet.cc:971
#define p_GetComp(p, r)
Definition: monomials.h:64
#define pIter(p)
Definition: monomials.h:37
#define pNext(p)
Definition: monomials.h:36
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
Definition: monomials.h:44
#define pSetCoeff0(p, n)
Definition: monomials.h:59
#define nCopy(n)
Definition: numbers.h:15
#define nInit(i)
Definition: numbers.h:24
#define NULL
Definition: omList.c:12
#define TEST_OPT_CANCELUNIT
Definition: options.h:129
BOOLEAN p_OneComp(poly p, const ring r)
return TRUE if all monoms have the same component
Definition: p_polys.cc:1208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent @Note: the integer VarOffset encodes:
Definition: p_polys.h:471
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:903
#define pSetCoeff(p, n)
deletes old coeff before setting the new one
Definition: polys.h:31
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:593
BOOLEAN rHasGlobalOrdering(const ring r)
Definition: ring.h:760
#define loop
Definition: structs.h:75

◆ cancelunit1()

void cancelunit1 ( LObject p,
int *  suc,
int  index,
kStrategy  strat 
)

Definition at line 8709 of file kutil.cc.

8710 {
8711  int k;
8712  poly r,h,h1,q;
8713 
8714  if (!pIsVector((*p).p) && ((*p).ecart != 0))
8715  {
8716 #ifdef HAVE_RINGS
8717  // Leading coef have to be a unit: no
8718  // example 2x+4x2 should be simplified to 2x*(1+2x)
8719  // and 2 is not a unit in Z
8720  //if ( !(n_IsUnit(pGetCoeff((*p).p), currRing->cf)) ) return;
8721 #endif
8722  k = 0;
8723  h1 = r = pCopy((*p).p);
8724  h =pNext(r);
8725  loop
8726  {
8727  if (h==NULL)
8728  {
8729  pDelete(&r);
8730  pDelete(&(pNext((*p).p)));
8731  (*p).ecart = 0;
8732  (*p).length = 1;
8733  (*p).pLength = 1;
8734  (*suc)=0;
8735  return;
8736  }
8737  if (!pDivisibleBy(r,h))
8738  {
8739  q=redBba1(h,index ,strat);
8740  if (q != h)
8741  {
8742  k++;
8743  pDelete(&h);
8744  pNext(h1) = h = q;
8745  }
8746  else
8747  {
8748  pDelete(&r);
8749  return;
8750  }
8751  }
8752  else
8753  {
8754  h1 = h;
8755  pIter(h);
8756  }
8757  if (k > 10)
8758  {
8759  pDelete(&r);
8760  return;
8761  }
8762  }
8763  }
8764 }
int k
Definition: cfEzgcd.cc:99
static poly redBba1(poly h, int maxIndex, kStrategy strat)
Definition: kutil.cc:8692
static int index(p_Length length, p_Ord ord)
Definition: p_Procs_Impl.h:592
#define pIsVector(p)
Definition: polys.h:250
#define pDivisibleBy(a, b)
returns TRUE, if leading monom of a divides leading monom of b i.e., if there exists a expvector c > ...
Definition: polys.h:138
#define pCopy(p)
return a copy of the poly
Definition: polys.h:185

◆ chainCritNormal()

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

Definition at line 3297 of file kutil.cc.

3298 {
3299  int i,j,l;
3300 
3301  /*
3302  *pairtest[i] is TRUE if spoly(S[i],p) == 0.
3303  *In this case all elements in B such
3304  *that their lcm is divisible by the leading term of S[i] can be canceled
3305  */
3306  if (strat->pairtest!=NULL)
3307  {
3308 #ifdef HAVE_SHIFTBBA
3309  // only difference is pLPDivisibleBy instead of pDivisibleBy
3310  if (rIsLPRing(currRing))
3311  {
3312  for (j=0; j<=strat->sl; j++)
3313  {
3314  if (strat->pairtest[j])
3315  {
3316  for (i=strat->Bl; i>=0; i--)
3317  {
3318  if (pLPDivisibleBy(strat->S[j],strat->B[i].lcm))
3319  {
3320  deleteInL(strat->B,&strat->Bl,i,strat);
3321  strat->c3++;
3322  }
3323  }
3324  }
3325  }
3326  }
3327  else
3328 #endif
3329  {
3330  /*- i.e. there is an i with pairtest[i]==TRUE -*/
3331  for (j=0; j<=strat->sl; j++)
3332  {
3333  if (strat->pairtest[j])
3334  {
3335  for (i=strat->Bl; i>=0; i--)
3336  {
3337  if (pDivisibleBy(strat->S[j],strat->B[i].lcm))
3338  {
3339  deleteInL(strat->B,&strat->Bl,i,strat);
3340  strat->c3++;
3341  }
3342  }
3343  }
3344  }
3345  }
3346  omFreeSize(strat->pairtest,(strat->sl+2)*sizeof(BOOLEAN));
3347  strat->pairtest=NULL;
3348  }
3349  if (strat->Gebauer || strat->fromT)
3350  {
3351  if (strat->sugarCrit)
3352  {
3353  /*
3354  *suppose L[j] == (s,r) and p/lcm(s,r)
3355  *and lcm(s,r)#lcm(s,p) and lcm(s,r)#lcm(r,p)
3356  *and in case the sugar is o.k. then L[j] can be canceled
3357  */
3358  for (j=strat->Ll; j>=0; j--)
3359  {
3360  if (sugarDivisibleBy(ecart,strat->L[j].ecart)
3361  && ((pNext(strat->L[j].p) == strat->tail) || (rHasGlobalOrdering(currRing)))
3362  && pCompareChain(p,strat->L[j].p1,strat->L[j].p2,strat->L[j].lcm))
3363  {
3364  if (strat->L[j].p == strat->tail)
3365  {
3366  deleteInL(strat->L,&strat->Ll,j,strat);
3367  strat->c3++;
3368  }
3369  }
3370  }
3371  /*
3372  *this is GEBAUER-MOELLER:
3373  *in B all elements with the same lcm except the "best"
3374  *(i.e. the last one in B with this property) will be canceled
3375  */
3376  j = strat->Bl;
3377  loop /*cannot be changed into a for !!! */
3378  {
3379  if (j <= 0) break;
3380  i = j-1;
3381  loop
3382  {
3383  if (i < 0) break;
3384  if (pLmEqual(strat->B[j].lcm,strat->B[i].lcm))
3385  {
3386  strat->c3++;
3387  if (sugarDivisibleBy(strat->B[j].ecart,strat->B[i].ecart))
3388  {
3389  deleteInL(strat->B,&strat->Bl,i,strat);
3390  j--;
3391  }
3392  else
3393  {
3394  deleteInL(strat->B,&strat->Bl,j,strat);
3395  break;
3396  }
3397  }
3398  i--;
3399  }
3400  j--;
3401  }
3402  }
3403  else /*sugarCrit*/
3404  {
3405  /*
3406  *suppose L[j] == (s,r) and p/lcm(s,r)
3407  *and lcm(s,r)#lcm(s,p) and lcm(s,r)#lcm(r,p)
3408  *and in case the sugar is o.k. then L[j] can be canceled
3409  */
3410  for (j=strat->Ll; j>=0; j--)
3411  {
3412  if (pCompareChain(p,strat->L[j].p1,strat->L[j].p2,strat->L[j].lcm))
3413  {
3414  if ((pNext(strat->L[j].p) == strat->tail)||(rHasGlobalOrdering(currRing)))
3415  {
3416  deleteInL(strat->L,&strat->Ll,j,strat);
3417  strat->c3++;
3418  }
3419  }
3420  }
3421  /*
3422  *this is GEBAUER-MOELLER:
3423  *in B all elements with the same lcm except the "best"
3424  *(i.e. the last one in B with this property) will be canceled
3425  */
3426  j = strat->Bl;
3427  loop /*cannot be changed into a for !!! */
3428  {
3429  if (j <= 0) break;
3430  for(i=j-1; i>=0; i--)
3431  {
3432  if (pLmEqual(strat->B[j].lcm,strat->B[i].lcm))
3433  {
3434  strat->c3++;
3435  deleteInL(strat->B,&strat->Bl,i,strat);
3436  j--;
3437  }
3438  }
3439  j--;
3440  }
3441  }
3442  /*
3443  *the elements of B enter L
3444  */
3445  kMergeBintoL(strat);
3446  }
3447  else
3448  {
3449  for (j=strat->Ll; j>=0; j--)
3450  {
3451  #ifdef HAVE_SHIFTBBA
3452  if ((strat->L[j].p1!=NULL) &&
3453  pCompareChain(p,strat->L[j].p1,strat->L[j].p2,strat->L[j].lcm))
3454  #else
3455  if (pCompareChain(p,strat->L[j].p1,strat->L[j].p2,strat->L[j].lcm))
3456  #endif
3457  {
3458  if ((pNext(strat->L[j].p) == strat->tail)||(rHasGlobalOrdering(currRing)))
3459  {
3460  deleteInL(strat->L,&strat->Ll,j,strat);
3461  strat->c3++;
3462  }
3463  }
3464  }
3465  /*
3466  *this is our MODIFICATION of GEBAUER-MOELLER:
3467  *First the elements of B enter L,
3468  *then we fix a lcm and the "best" element in L
3469  *(i.e the last in L with this lcm and of type (s,p))
3470  *and cancel all the other elements of type (r,p) with this lcm
3471  *except the case the element (s,r) has also the same lcm
3472  *and is on the worst position with respect to (s,p) and (r,p)
3473  */
3474  /*
3475  *B enters to L/their order with respect to B is permutated for elements
3476  *B[i].p with the same leading term
3477  */
3478  kMergeBintoL(strat);
3479  j = strat->Ll;
3480  loop /*cannot be changed into a for !!! */
3481  {
3482  if (j <= 0)
3483  {
3484  /*now L[0] cannot be canceled any more and the tail can be removed*/
3485  if (strat->L[0].p2 == strat->tail) strat->L[0].p2 = p;
3486  break;
3487  }
3488  if (strat->L[j].p2 == p)
3489  {
3490  i = j-1;
3491  loop
3492  {
3493  if (i < 0) break;
3494  if ((strat->L[i].p2 == p) && pLmEqual(strat->L[j].lcm,strat->L[i].lcm))
3495  {
3496  /*L[i] could be canceled but we search for a better one to cancel*/
3497  strat->c3++;
3498  if (isInPairsetL(i-1,strat->L[j].p1,strat->L[i].p1,&l,strat)
3499  && (pNext(strat->L[l].p) == strat->tail)
3500  && (!pLmEqual(strat->L[i].p,strat->L[l].p))
3501  && pDivisibleBy(p,strat->L[l].lcm))
3502  {
3503  /*
3504  *"NOT equal(...)" because in case of "equal" the element L[l]
3505  *is "older" and has to be from theoretical point of view behind
3506  *L[i], but we do not want to reorder L
3507  */
3508  strat->L[i].p2 = strat->tail;
3509  /*
3510  *L[l] will be canceled, we cannot cancel L[i] later on,
3511  *so we mark it with "tail"
3512  */
3513  deleteInL(strat->L,&strat->Ll,l,strat);
3514  i--;
3515  }
3516  else
3517  {
3518  deleteInL(strat->L,&strat->Ll,i,strat);
3519  }
3520  j--;
3521  }
3522  i--;
3523  }
3524  }
3525  else if (strat->L[j].p2 == strat->tail)
3526  {
3527  /*now L[j] cannot be canceled any more and the tail can be removed*/
3528  strat->L[j].p2 = p;
3529  }
3530  j--;
3531  }
3532  }
3533 }
int BOOLEAN
Definition: auxiliary.h:87
int l
Definition: cfEzgcd.cc:100
int Ll
Definition: kutil.h:351
BOOLEAN * pairtest
Definition: kutil.h:333
poly tail
Definition: kutil.h:334
char sugarCrit
Definition: kutil.h:377
char Gebauer
Definition: kutil.h:378
char fromT
Definition: kutil.h:379
LSet L
Definition: kutil.h:327
int c3
Definition: kutil.h:347
int j
Definition: facHensel.cc:110
BOOLEAN pCompareChain(poly p, poly p1, poly p2, poly lcm, const ring R)
Returns TRUE if.
Definition: kpolys.cc:17
void kMergeBintoL(kStrategy strat)
Definition: kutil.cc:3254
static BOOLEAN sugarDivisibleBy(int ecart1, int ecart2)
Definition: kutil.cc:1417
BOOLEAN isInPairsetL(int length, poly p1, poly p2, int *k, kStrategy strat)
Definition: kutil.cc:706
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
static BOOLEAN rIsLPRing(const ring r)
Definition: ring.h:411
#define pLPDivisibleBy(a, b)
Definition: shiftop.h:57

◆ chainCritOpt_1()

void chainCritOpt_1 ( poly  ,
int  ,
kStrategy  strat 
)

Definition at line 3538 of file kutil.cc.

3539 {
3540  if (strat->pairtest!=NULL)
3541  {
3542  omFreeSize(strat->pairtest,(strat->sl+2)*sizeof(BOOLEAN));
3543  strat->pairtest=NULL;
3544  }
3545  /*
3546  *the elements of B enter L
3547  */
3548  kMergeBintoL(strat);
3549 }

◆ chainCritPart()

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

Definition at line 3613 of file kutil.cc.

3614 {
3615  int i,j,l;
3616 
3617  /*
3618  *pairtest[i] is TRUE if spoly(S[i],p) == 0.
3619  *In this case all elements in B such
3620  *that their lcm is divisible by the leading term of S[i] can be canceled
3621  */
3622  if (strat->pairtest!=NULL)
3623  {
3624  /*- i.e. there is an i with pairtest[i]==TRUE -*/
3625  for (j=0; j<=strat->sl; j++)
3626  {
3627  if (strat->pairtest[j])
3628  {
3629  for (i=strat->Bl; i>=0; i--)
3630  {
3631  if (_p_LmDivisibleByPart(strat->S[j],currRing,
3632  strat->B[i].lcm,currRing,
3633  currRing->real_var_start,currRing->real_var_end))
3634  {
3635  if(TEST_OPT_DEBUG)
3636  {
3637  Print("chain-crit-part: S[%d]=",j);
3638  p_wrp(strat->S[j],currRing);
3639  Print(" divide B[%d].lcm=",i);
3640  p_wrp(strat->B[i].lcm,currRing);
3641  PrintLn();
3642  }
3643  deleteInL(strat->B,&strat->Bl,i,strat);
3644  strat->c3++;
3645  }
3646  }
3647  }
3648  }
3649  omFreeSize(strat->pairtest,(strat->sl+2)*sizeof(BOOLEAN));
3650  strat->pairtest=NULL;
3651  }
3652  if (strat->Gebauer || strat->fromT)
3653  {
3654  if (strat->sugarCrit)
3655  {
3656  /*
3657  *suppose L[j] == (s,r) and p/lcm(s,r)
3658  *and lcm(s,r)#lcm(s,p) and lcm(s,r)#lcm(r,p)
3659  *and in case the sugar is o.k. then L[j] can be canceled
3660  */
3661  for (j=strat->Ll; j>=0; j--)
3662  {
3663  if (sugarDivisibleBy(ecart,strat->L[j].ecart)
3664  && ((pNext(strat->L[j].p) == strat->tail) || (rHasGlobalOrdering(currRing)))
3665  && pCompareChainPart(p,strat->L[j].p1,strat->L[j].p2,strat->L[j].lcm))
3666  {
3667  if (strat->L[j].p == strat->tail)
3668  {
3669  if(TEST_OPT_DEBUG)
3670  {
3671  PrintS("chain-crit-part: pCompareChainPart p=");
3672  p_wrp(p,currRing);
3673  Print(" delete L[%d]",j);
3674  p_wrp(strat->L[j].lcm,currRing);
3675  PrintLn();
3676  }
3677  deleteInL(strat->L,&strat->Ll,j,strat);
3678  strat->c3++;
3679  }
3680  }
3681  }
3682  /*
3683  *this is GEBAUER-MOELLER:
3684  *in B all elements with the same lcm except the "best"
3685  *(i.e. the last one in B with this property) will be canceled
3686  */
3687  j = strat->Bl;
3688  loop /*cannot be changed into a for !!! */
3689  {
3690  if (j <= 0) break;
3691  i = j-1;
3692  loop
3693  {
3694  if (i < 0) break;
3695  if (pLmEqual(strat->B[j].lcm,strat->B[i].lcm))
3696  {
3697  strat->c3++;
3698  if (sugarDivisibleBy(strat->B[j].ecart,strat->B[i].ecart))
3699  {
3700  if(TEST_OPT_DEBUG)
3701  {
3702  Print("chain-crit-part: sugar B[%d].lcm=",j);
3703  p_wrp(strat->B[j].lcm,currRing);
3704  Print(" delete B[%d]",i);
3705  p_wrp(strat->B[i].lcm,currRing);
3706  PrintLn();
3707  }
3708  deleteInL(strat->B,&strat->Bl,i,strat);
3709  j--;
3710  }
3711  else
3712  {
3713  if(TEST_OPT_DEBUG)
3714  {
3715  Print("chain-crit-part: sugar B[%d].lcm=",i);
3716  p_wrp(strat->B[i].lcm,currRing);
3717  Print(" delete B[%d]",j);
3718  p_wrp(strat->B[j].lcm,currRing);
3719  PrintLn();
3720  }
3721  deleteInL(strat->B,&strat->Bl,j,strat);
3722  break;
3723  }
3724  }
3725  i--;
3726  }
3727  j--;
3728  }
3729  }
3730  else /*sugarCrit*/
3731  {
3732  /*
3733  *suppose L[j] == (s,r) and p/lcm(s,r)
3734  *and lcm(s,r)#lcm(s,p) and lcm(s,r)#lcm(r,p)
3735  *and in case the sugar is o.k. then L[j] can be canceled
3736  */
3737  for (j=strat->Ll; j>=0; j--)
3738  {
3739  if (pCompareChainPart(p,strat->L[j].p1,strat->L[j].p2,strat->L[j].lcm))
3740  {
3741  if ((pNext(strat->L[j].p) == strat->tail)||(rHasGlobalOrdering(currRing)))
3742  {
3743  if(TEST_OPT_DEBUG)
3744  {
3745  PrintS("chain-crit-part: sugar:pCompareChainPart p=");
3746  p_wrp(p,currRing);
3747  Print(" delete L[%d]",j);
3748  p_wrp(strat->L[j].lcm,currRing);
3749  PrintLn();
3750  }
3751  deleteInL(strat->L,&strat->Ll,j,strat);
3752  strat->c3++;
3753  }
3754  }
3755  }
3756  /*
3757  *this is GEBAUER-MOELLER:
3758  *in B all elements with the same lcm except the "best"
3759  *(i.e. the last one in B with this property) will be canceled
3760  */
3761  j = strat->Bl;
3762  loop /*cannot be changed into a for !!! */
3763  {
3764  if (j <= 0) break;
3765  for(i=j-1; i>=0; i--)
3766  {
3767  if (pLmEqual(strat->B[j].lcm,strat->B[i].lcm))
3768  {
3769  if(TEST_OPT_DEBUG)
3770  {
3771  Print("chain-crit-part: equal lcm B[%d].lcm=",j);
3772  p_wrp(strat->B[j].lcm,currRing);
3773  Print(" delete B[%d]\n",i);
3774  }
3775  strat->c3++;
3776  deleteInL(strat->B,&strat->Bl,i,strat);
3777  j--;
3778  }
3779  }
3780  j--;
3781  }
3782  }
3783  /*
3784  *the elements of B enter L
3785  */
3786  kMergeBintoL(strat);
3787  }
3788  else
3789  {
3790  for (j=strat->Ll; j>=0; j--)
3791  {
3792  if (pCompareChainPart(p,strat->L[j].p1,strat->L[j].p2,strat->L[j].lcm))
3793  {
3794  if ((pNext(strat->L[j].p) == strat->tail)||(rHasGlobalOrdering(currRing)))
3795  {
3796  if(TEST_OPT_DEBUG)
3797  {
3798  PrintS("chain-crit-part: pCompareChainPart p=");
3799  p_wrp(p,currRing);
3800  Print(" delete L[%d]",j);
3801  p_wrp(strat->L[j].lcm,currRing);
3802  PrintLn();
3803  }
3804  deleteInL(strat->L,&strat->Ll,j,strat);
3805  strat->c3++;
3806  }
3807  }
3808  }
3809  /*
3810  *this is our MODIFICATION of GEBAUER-MOELLER:
3811  *First the elements of B enter L,
3812  *then we fix a lcm and the "best" element in L
3813  *(i.e the last in L with this lcm and of type (s,p))
3814  *and cancel all the other elements of type (r,p) with this lcm
3815  *except the case the element (s,r) has also the same lcm
3816  *and is on the worst position with respect to (s,p) and (r,p)
3817  */
3818  /*
3819  *B enters to L/their order with respect to B is permutated for elements
3820  *B[i].p with the same leading term
3821  */
3822  kMergeBintoL(strat);
3823  j = strat->Ll;
3824  loop /*cannot be changed into a for !!! */
3825  {
3826  if (j <= 0)
3827  {
3828  /*now L[0] cannot be canceled any more and the tail can be removed*/
3829  if (strat->L[0].p2 == strat->tail) strat->L[0].p2 = p;
3830  break;
3831  }
3832  if (strat->L[j].p2 == p)
3833  {
3834  i = j-1;
3835  loop
3836  {
3837  if (i < 0) break;
3838  if ((strat->L[i].p2 == p) && pLmEqual(strat->L[j].lcm,strat->L[i].lcm))
3839  {
3840  /*L[i] could be canceled but we search for a better one to cancel*/
3841  strat->c3++;
3842  if (isInPairsetL(i-1,strat->L[j].p1,strat->L[i].p1,&l,strat)
3843  && (pNext(strat->L[l].p) == strat->tail)
3844  && (!pLmEqual(strat->L[i].p,strat->L[l].p))
3846  strat->L[l].lcm,currRing,
3847  currRing->real_var_start, currRing->real_var_end))
3848 
3849  {
3850  /*
3851  *"NOT equal(...)" because in case of "equal" the element L[l]
3852  *is "older" and has to be from theoretical point of view behind
3853  *L[i], but we do not want to reorder L
3854  */
3855  strat->L[i].p2 = strat->tail;
3856  /*
3857  *L[l] will be canceled, we cannot cancel L[i] later on,
3858  *so we mark it with "tail"
3859  */
3860  if(TEST_OPT_DEBUG)
3861  {
3862  PrintS("chain-crit-part: divisible_by p=");
3863  p_wrp(p,currRing);
3864  Print(" delete L[%d]",l);
3865  p_wrp(strat->L[l].lcm,currRing);
3866  PrintLn();
3867  }
3868  deleteInL(strat->L,&strat->Ll,l,strat);
3869  i--;
3870  }
3871  else
3872  {
3873  if(TEST_OPT_DEBUG)
3874  {
3875  PrintS("chain-crit-part: divisible_by(2) p=");
3876  p_wrp(p,currRing);
3877  Print(" delete L[%d]",i);
3878  p_wrp(strat->L[i].lcm,currRing);
3879  PrintLn();
3880  }
3881  deleteInL(strat->L,&strat->Ll,i,strat);
3882  }
3883  j--;
3884  }
3885  i--;
3886  }
3887  }
3888  else if (strat->L[j].p2 == strat->tail)
3889  {
3890  /*now L[j] cannot be canceled any more and the tail can be removed*/
3891  strat->L[j].p2 = p;
3892  }
3893  j--;
3894  }
3895  }
3896 }
#define Print
Definition: emacs.cc:80
BOOLEAN pCompareChainPart(poly p, poly p1, poly p2, poly lcm, const ring R)
Definition: kpolys.cc:71
#define TEST_OPT_DEBUG
Definition: options.h:109
static BOOLEAN _p_LmDivisibleByPart(poly a, const ring r_a, poly b, const ring r_b, const int start, const int end)
Definition: p_polys.h:1856
void p_wrp(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:373
void PrintS(const char *s)
Definition: reporter.cc:284
void PrintLn()
Definition: reporter.cc:310

◆ chainCritRing()

void chainCritRing ( poly  p,
int  ,
kStrategy  strat 
)

Definition at line 4089 of file kutil.cc.

4090 {
4091  int i,j,l;
4092  /*
4093  *pairtest[i] is TRUE if spoly(S[i],p) == 0.
4094  *In this case all elements in B such
4095  *that their lcm is divisible by the leading term of S[i] can be canceled
4096  */
4097  if (strat->pairtest!=NULL)
4098  {
4099  {
4100  /*- i.e. there is an i with pairtest[i]==TRUE -*/
4101  for (j=0; j<=strat->sl; j++)
4102  {
4103  if (strat->pairtest[j])
4104  {
4105  for (i=strat->Bl; i>=0; i--)
4106  {
4107  if (pDivisibleBy(strat->S[j],strat->B[i].lcm) && n_DivBy(pGetCoeff(strat->B[i].lcm), pGetCoeff(strat->S[j]),currRing->cf))
4108  {
4109 #ifdef KDEBUG
4110  if (TEST_OPT_DEBUG)
4111  {
4112  PrintS("--- chain criterion func chainCritRing type 1\n");
4113  PrintS("strat->S[j]:");
4114  wrp(strat->S[j]);
4115  PrintS(" strat->B[i].lcm:");
4116  wrp(strat->B[i].lcm);PrintLn();
4117  pWrite(strat->B[i].p);
4118  pWrite(strat->B[i].p1);
4119  pWrite(strat->B[i].p2);
4120  wrp(strat->B[i].lcm);
4121  PrintLn();
4122  }
4123 #endif
4124  deleteInL(strat->B,&strat->Bl,i,strat);
4125  strat->c3++;
4126  }
4127  }
4128  }
4129  }
4130  }
4131  omFreeSize(strat->pairtest,(strat->sl+2)*sizeof(BOOLEAN));
4132  strat->pairtest=NULL;
4133  }
4134  assume(!(strat->Gebauer || strat->fromT));
4135  for (j=strat->Ll; j>=0; j--)
4136  {
4137  if ((strat->L[j].lcm != NULL) && n_DivBy(pGetCoeff(strat->L[j].lcm), pGetCoeff(p), currRing->cf))
4138  {
4139  if (pCompareChain(p,strat->L[j].p1,strat->L[j].p2,strat->L[j].lcm))
4140  {
4141  if ((pNext(strat->L[j].p) == strat->tail) || (rHasGlobalOrdering(currRing)))
4142  {
4143  deleteInL(strat->L,&strat->Ll,j,strat);
4144  strat->c3++;
4145 #ifdef KDEBUG
4146  if (TEST_OPT_DEBUG)
4147  {
4148  PrintS("--- chain criterion func chainCritRing type 2\n");
4149  PrintS("strat->L[j].p:");
4150  wrp(strat->L[j].p);
4151  PrintS(" p:");
4152  wrp(p);
4153  PrintLn();
4154  }
4155 #endif
4156  }
4157  }
4158  }
4159  }
4160  /*
4161  *this is our MODIFICATION of GEBAUER-MOELLER:
4162  *First the elements of B enter L,
4163  *then we fix a lcm and the "best" element in L
4164  *(i.e the last in L with this lcm and of type (s,p))
4165  *and cancel all the other elements of type (r,p) with this lcm
4166  *except the case the element (s,r) has also the same lcm
4167  *and is on the worst position with respect to (s,p) and (r,p)
4168  */
4169  /*
4170  *B enters to L/their order with respect to B is permutated for elements
4171  *B[i].p with the same leading term
4172  */
4173  kMergeBintoL(strat);
4174  j = strat->Ll;
4175  loop /*cannot be changed into a for !!! */
4176  {
4177  if (j <= 0)
4178  {
4179  /*now L[0] cannot be canceled any more and the tail can be removed*/
4180  if (strat->L[0].p2 == strat->tail) strat->L[0].p2 = p;
4181  break;
4182  }
4183  if (strat->L[j].p2 == p) // Was the element added from B?
4184  {
4185  i = j-1;
4186  loop
4187  {
4188  if (i < 0) break;
4189  // Element is from B and has the same lcm as L[j]
4190  if ((strat->L[i].p2 == p) && n_DivBy(pGetCoeff(strat->L[j].lcm), pGetCoeff(strat->L[i].lcm), currRing->cf)
4191  && pLmEqual(strat->L[j].lcm,strat->L[i].lcm))
4192  {
4193  /*L[i] could be canceled but we search for a better one to cancel*/
4194  strat->c3++;
4195 #ifdef KDEBUG
4196  if (TEST_OPT_DEBUG)
4197  {
4198  PrintS("--- chain criterion func chainCritRing type 3\n");
4199  PrintS("strat->L[j].lcm:");
4200  wrp(strat->L[j].lcm);
4201  PrintS(" strat->L[i].lcm:");
4202  wrp(strat->L[i].lcm);
4203  PrintLn();
4204  }
4205 #endif
4206  if (isInPairsetL(i-1,strat->L[j].p1,strat->L[i].p1,&l,strat)
4207  && (pNext(strat->L[l].p) == strat->tail)
4208  && (!pLmEqual(strat->L[i].p,strat->L[l].p))
4209  && pDivisibleBy(p,strat->L[l].lcm))
4210  {
4211  /*
4212  *"NOT equal(...)" because in case of "equal" the element L[l]
4213  *is "older" and has to be from theoretical point of view behind
4214  *L[i], but we do not want to reorder L
4215  */
4216  strat->L[i].p2 = strat->tail;
4217  /*
4218  *L[l] will be canceled, we cannot cancel L[i] later on,
4219  *so we mark it with "tail"
4220  */
4221  deleteInL(strat->L,&strat->Ll,l,strat);
4222  i--;
4223  }
4224  else
4225  {
4226  deleteInL(strat->L,&strat->Ll,i,strat);
4227  }
4228  j--;
4229  }
4230  i--;
4231  }
4232  }
4233  else if (strat->L[j].p2 == strat->tail)
4234  {
4235  /*now L[j] cannot be canceled any more and the tail can be removed*/
4236  strat->L[j].p2 = p;
4237  }
4238  j--;
4239  }
4240 }
#define assume(x)
Definition: mod2.h:389
void wrp(poly p)
Definition: polys.h:310
void pWrite(poly p)
Definition: polys.h:308

◆ chainCritSig()

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

Definition at line 3554 of file kutil.cc.

3555 {
3556  int i,j,l;
3557  kMergeBintoLSba(strat);
3558  j = strat->Ll;
3559  loop /*cannot be changed into a for !!! */
3560  {
3561  if (j <= 0)
3562  {
3563  /*now L[0] cannot be canceled any more and the tail can be removed*/
3564  if (strat->L[0].p2 == strat->tail) strat->L[0].p2 = p;
3565  break;
3566  }
3567  if (strat->L[j].p2 == p)
3568  {
3569  i = j-1;
3570  loop
3571  {
3572  if (i < 0) break;
3573  if ((strat->L[i].p2 == p) && pLmEqual(strat->L[j].lcm,strat->L[i].lcm))
3574  {
3575  /*L[i] could be canceled but we search for a better one to cancel*/
3576  strat->c3++;
3577  if (isInPairsetL(i-1,strat->L[j].p1,strat->L[i].p1,&l,strat)
3578  && (pNext(strat->L[l].p) == strat->tail)
3579  && (!pLmEqual(strat->L[i].p,strat->L[l].p))
3580  && pDivisibleBy(p,strat->L[l].lcm))
3581  {
3582  /*
3583  *"NOT equal(...)" because in case of "equal" the element L[l]
3584  *is "older" and has to be from theoretical point of view behind
3585  *L[i], but we do not want to reorder L
3586  */
3587  strat->L[i].p2 = strat->tail;
3588  /*
3589  *L[l] will be canceled, we cannot cancel L[i] later on,
3590  *so we mark it with "tail"
3591  */
3592  deleteInL(strat->L,&strat->Ll,l,strat);
3593  i--;
3594  }
3595  else
3596  {
3597  deleteInL(strat->L,&strat->Ll,i,strat);
3598  }
3599  j--;
3600  }
3601  i--;
3602  }
3603  }
3604  else if (strat->L[j].p2 == strat->tail)
3605  {
3606  /*now L[j] cannot be canceled any more and the tail can be removed*/
3607  strat->L[j].p2 = p;
3608  }
3609  j--;
3610  }
3611 }
void kMergeBintoLSba(kStrategy strat)
Definition: kutil.cc:3275

◆ cleanT()

void cleanT ( kStrategy  strat)

Definition at line 569 of file kutil.cc.

570 {
571  int i,j;
572  poly p;
573  assume(currRing == strat->tailRing || strat->tailRing != NULL);
574 
575  pShallowCopyDeleteProc p_shallow_copy_delete =
576  (strat->tailRing != currRing ?
578  NULL);
579  for (j=0; j<=strat->tl; j++)
580  {
581  p = strat->T[j].p;
582  strat->T[j].p=NULL;
583  if (strat->T[j].max_exp != NULL)
584  {
585  p_LmFree(strat->T[j].max_exp, strat->tailRing);
586  }
587  i = -1;
588  loop
589  {
590  i++;
591  if (i>strat->sl)
592  {
593  if (strat->T[j].t_p != NULL)
594  {
595  p_Delete(&(strat->T[j].t_p), strat->tailRing);
596  p_LmFree(p, currRing);
597  }
598  else
599  {
600 #ifdef HAVE_SHIFTBBA
601  if (currRing->isLPring && strat->T[j].shift > 0)
602  {
603  pNext(p) = NULL; // pNext(p) points to the unshifted tail, don't try to delete it here
604  }
605 #endif
606  pDelete(&p);
607  }
608  break;
609  }
610  if (p == strat->S[i])
611  {
612  if (strat->T[j].t_p != NULL)
613  {
614  if (p_shallow_copy_delete!=NULL)
615  {
616  pNext(p) = p_shallow_copy_delete(pNext(p),strat->tailRing,currRing,
617  currRing->PolyBin);
618  }
619  p_LmFree(strat->T[j].t_p, strat->tailRing);
620  }
621  break;
622  }
623  }
624  }
625  strat->tl=-1;
626 }
ring tailRing
Definition: kutil.h:343
TSet T
Definition: kutil.h:326
int tl
Definition: kutil.h:350
pShallowCopyDeleteProc pGetShallowCopyDeleteProc(ring, ring)
static void p_LmFree(poly p, ring)
Definition: p_polys.h:685
poly(* pShallowCopyDeleteProc)(poly s_p, ring source_r, ring dest_r, omBin dest_bin)
returns a poly from dest_r which is a ShallowCopy of s_p from source_r assumes that source_r->N == de...
Definition: ring.h:44

◆ cleanTSbaRing()

void cleanTSbaRing ( kStrategy  strat)

Definition at line 628 of file kutil.cc.

629 {
630  int i,j;
631  poly p;
632  assume(currRing == strat->tailRing || strat->tailRing != NULL);
633 
634  pShallowCopyDeleteProc p_shallow_copy_delete =
635  (strat->tailRing != currRing ?
637  NULL);
638  for (j=0; j<=strat->tl; j++)
639  {
640  p = strat->T[j].p;
641  strat->T[j].p=NULL;
642  if (strat->T[j].max_exp != NULL)
643  {
644  p_LmFree(strat->T[j].max_exp, strat->tailRing);
645  }
646  i = -1;
647  loop
648  {
649  i++;
650  if (i>strat->sl)
651  {
652  if (strat->T[j].t_p != NULL)
653  {
654  p_Delete(&(strat->T[j].t_p), strat->tailRing);
655  p_LmFree(p, currRing);
656  }
657  else
658  {
659  //pDelete(&p);
660  p = NULL;
661  }
662  break;
663  }
664  if (p == strat->S[i])
665  {
666  if (strat->T[j].t_p != NULL)
667  {
668  assume(p_shallow_copy_delete != NULL);
669  pNext(p) = p_shallow_copy_delete(pNext(p),strat->tailRing,currRing,
670  currRing->PolyBin);
671  p_LmFree(strat->T[j].t_p, strat->tailRing);
672  }
673  break;
674  }
675  }
676  }
677  strat->tl=-1;
678 }

◆ clearSbatch()

void clearSbatch ( poly  h,
int  k,
int  pos,
kStrategy  strat 
)

Definition at line 4530 of file kutil.cc.

4531 {
4532  int j = pos;
4533  if ( (!strat->fromT)
4534  && ((strat->syzComp==0)
4535  ||(pGetComp(h)<=strat->syzComp)
4536  ))
4537  {
4538  // Print("start clearS k=%d, pos=%d, sl=%d\n",k,pos,strat->sl);
4539  unsigned long h_sev = pGetShortExpVector(h);
4540  loop
4541  {
4542  if (j > k) break;
4543  clearS(h,h_sev, &j,&k,strat);
4544  j++;
4545  }
4546  // Print("end clearS sl=%d\n",strat->sl);
4547  }
4548 }
int syzComp
Definition: kutil.h:354
KINLINE void clearS(poly p, unsigned long p_sev, int *at, int *k, kStrategy strat)
Definition: kInline.h:1248
#define pGetComp(p)
Component.
Definition: polys.h:37
#define pGetShortExpVector(a)
returns the "Short Exponent Vector" – used to speed up divisibility tests (see polys-impl....
Definition: polys.h:152

◆ completeReduce()

void completeReduce ( kStrategy  strat,
BOOLEAN  withT 
)

Definition at line 10613 of file kutil.cc.

10614 {
10615  int i;
10616  int low = (((rHasGlobalOrdering(currRing)) && (strat->ak==0)) ? 1 : 0);
10617  LObject L;
10618 
10619 #ifdef KDEBUG
10620  // need to set this: during tailreductions of T[i], T[i].max is out of
10621  // sync
10622  sloppy_max = TRUE;
10623 #endif
10624 
10625  strat->noTailReduction = FALSE;
10626  //if(rHasMixedOrdering(currRing)) strat->noTailReduction = TRUE;
10627  if (TEST_OPT_PROT)
10628  {
10629  PrintLn();
10630 // if (timerv) writeTime("standard base computed:");
10631  }
10632  if (TEST_OPT_PROT)
10633  {
10634  Print("(S:%d)",strat->sl);mflush();
10635  }
10636  for (i=strat->sl; i>=low; i--)
10637  {
10638  int end_pos=strat->sl;
10639  if ((strat->fromQ!=NULL) && (strat->fromQ[i])) continue; // do not reduce Q_i
10640  if (strat->ak==0) end_pos=i-1;
10641  TObject* T_j = strat->s_2_t(i);
10642  if ((T_j != NULL)&&(T_j->p==strat->S[i]))
10643  {
10644  L = *T_j;
10645  #ifdef KDEBUG
10646  if (TEST_OPT_DEBUG)
10647  {
10648  Print("test S[%d]:",i);
10649  p_wrp(L.p,currRing,strat->tailRing);
10650  PrintLn();
10651  }
10652  #endif
10654  strat->S[i] = redtailBba(&L, end_pos, strat, withT);
10655  else
10656  strat->S[i] = redtail(&L, strat->sl, strat);
10657  #ifdef KDEBUG
10658  if (TEST_OPT_DEBUG)
10659  {
10660  Print("to (tailR) S[%d]:",i);
10661  p_wrp(strat->S[i],currRing,strat->tailRing);
10662  PrintLn();
10663  }
10664  #endif
10665 
10666  if (strat->redTailChange)
10667  {
10668  if (T_j->max_exp != NULL) p_LmFree(T_j->max_exp, strat->tailRing);
10669  if (pNext(T_j->p) != NULL)
10670  T_j->max_exp = p_GetMaxExpP(pNext(T_j->p), strat->tailRing);
10671  else
10672  T_j->max_exp = NULL;
10673  }
10675  T_j->pCleardenom();
10676  }
10677  else
10678  {
10679  assume(currRing == strat->tailRing);
10680  #ifdef KDEBUG
10681  if (TEST_OPT_DEBUG)
10682  {
10683  Print("test S[%d]:",i);
10684  p_wrp(strat->S[i],currRing,strat->tailRing);
10685  PrintLn();
10686  }
10687  #endif
10689  strat->S[i] = redtailBba(strat->S[i], end_pos, strat, withT);
10690  else
10691  strat->S[i] = redtail(strat->S[i], strat->sl, strat);
10693  {
10694  if (TEST_OPT_CONTENTSB)
10695  {
10696  number n;
10697  p_Cleardenom_n(strat->S[i], currRing, n);// also does remove Content
10698  if (!nIsOne(n))
10699  {
10701  denom->n=nInvers(n);
10702  denom->next=DENOMINATOR_LIST;
10703  DENOMINATOR_LIST=denom;
10704  }
10705  nDelete(&n);
10706  }
10707  else
10708  {
10709  strat->S[i]=p_Cleardenom(strat->S[i], currRing);// also does remove Content
10710  }
10711  }
10712  #ifdef KDEBUG
10713  if (TEST_OPT_DEBUG)
10714  {
10715  Print("to (-tailR) S[%d]:",i);
10716  p_wrp(strat->S[i],currRing,strat->tailRing);
10717  PrintLn();
10718  }
10719  #endif
10720  }
10721  if (TEST_OPT_PROT)
10722  PrintS("-");
10723  }
10724  if (TEST_OPT_PROT) PrintLn();
10725 #ifdef KDEBUG
10726  sloppy_max = FALSE;
10727 #endif
10728 }
char noTailReduction
Definition: kutil.h:378
int ak
Definition: kutil.h:353
KINLINE TObject * s_2_t(int i)
Definition: kInline.h:47
intset fromQ
Definition: kutil.h:321
char redTailChange
Definition: kutil.h:399
poly redtail(LObject *L, int end_pos, kStrategy strat)
Definition: kutil.cc:7147
poly redtailBba(LObject *L, int end_pos, kStrategy strat, BOOLEAN withT, BOOLEAN normalize)
Definition: kutil.cc:7223
STATIC_VAR BOOLEAN sloppy_max
Definition: kutil.cc:824
VAR denominator_list DENOMINATOR_LIST
Definition: kutil.cc:84
denominator_list_s * denominator_list
Definition: kutil.h:63
denominator_list next
Definition: kutil.h:65
class sTObject TObject
Definition: kutil.h:57
class sLObject LObject
Definition: kutil.h:58
#define nDelete(n)
Definition: numbers.h:16
#define nInvers(a)
Definition: numbers.h:33
#define nIsOne(n)
Definition: numbers.h:25
#define omAlloc(size)
Definition: omAllocDecl.h:210
#define TEST_OPT_INTSTRATEGY
Definition: options.h:111
#define TEST_OPT_PROT
Definition: options.h:104
#define TEST_OPT_CONTENTSB
Definition: options.h:128
poly p_GetMaxExpP(poly p, const ring r)
return monomial r such that GetExp(r,i) is maximum of all monomials in p; coeff == 0,...
Definition: p_polys.cc:1138
void p_Cleardenom_n(poly ph, const ring r, number &c)
Definition: p_polys.cc:3019
poly p_Cleardenom(poly p, const ring r)
Definition: p_polys.cc:2910
#define mflush()
Definition: reporter.h:58

◆ deleteHC() [1/2]

void deleteHC ( LObject L,
kStrategy  strat,
BOOLEAN  fromNext 
)

Definition at line 294 of file kutil.cc.

295 {
296  if (strat->kNoether!=NULL)
297  {
298  kTest_L(L,strat);
299  poly p1;
300  poly p = L->GetLmTailRing();
301  int l = 1;
302 
303  if (!fromNext && p_Cmp(p,strat->kNoetherTail(), L->tailRing) == -1)
304  {
305  if (L->bucket != NULL) kBucketDestroy(&L->bucket);
306  L->Delete();
307  L->Clear();
308  L->ecart = -1;
309  return;
310  }
311  if (L->bucket != NULL)
312  {
313  deleteHCBucket(L,strat);
314  return;
315  }
316  BOOLEAN cut=FALSE;
317  p1 = p;
318  while (pNext(p1)!=NULL)
319  {
320  if (p_LmCmp(pNext(p1), strat->kNoetherTail(), L->tailRing) == -1)
321  {
322  cut=(pNext(p1)!=NULL);
323  if (cut)
324  {
325  p_Delete(&pNext(p1), L->tailRing);
326 
327  if (p1 == p)
328  {
329  if (L->t_p != NULL)
330  {
331  assume(L->p != NULL && p == L->t_p);
332  pNext(L->p) = NULL;
333  }
334  L->max_exp = NULL;
335  }
336  else if (fromNext)
337  L->max_exp = p_GetMaxExpP(pNext(L->p), L->tailRing ); // p1;
338  //if (L->pLength != 0)
339  L->pLength = l;
340  // Hmmm when called from updateT, then only
341  // reset ecart when cut
342  if (fromNext)
343  L->ecart = L->pLDeg() - L->GetpFDeg();
344  }
345  break;
346  }
347  l++;
348  pIter(p1);
349  }
350  if ((!fromNext) && cut)
351  {
352  L->SetpFDeg();
353  L->ecart = L->pLDeg(strat->LDegLast) - L->GetpFDeg();
354  }
355  kTest_L(L,strat);
356  }
357 }
KINLINE poly kNoetherTail()
Definition: kInline.h:66
poly kNoether
Definition: kutil.h:329
char LDegLast
Definition: kutil.h:385
void kBucketDestroy(kBucket_pt *bucket_pt)
Definition: kbuckets.cc:216
static void deleteHCBucket(LObject *L, kStrategy strat)
Definition: kutil.cc:250
BOOLEAN kTest_L(LObject *L, kStrategy strat, BOOLEAN testp, int lpos, TSet T, int tlength)
Definition: kutil.cc:950
static int p_Cmp(poly p1, poly p2, ring r)
Definition: p_polys.h:1729
static int p_LmCmp(poly p, poly q, const ring r)
Definition: p_polys.h:1582

◆ deleteHC() [2/2]

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

Definition at line 359 of file kutil.cc.

360 {
361  LObject L(*p, currRing, strat->tailRing);
362 
363  deleteHC(&L, strat);
364  *p = L.p;
365  *e = L.ecart;
366  *l = L.length;
367  if (L.t_p != NULL) p_LmFree(L.t_p, strat->tailRing);
368 }
void deleteHC(LObject *L, kStrategy strat, BOOLEAN fromNext)
Definition: kutil.cc:294

◆ deleteHCBucket()

static void deleteHCBucket ( LObject L,
kStrategy  strat 
)
static

Definition at line 250 of file kutil.cc.

251 {
252  if ((strat->kNoether!=NULL)
253  && (L->bucket != NULL))
254  {
255  poly p1;
256  for (int i=1; i<= (int) L->bucket->buckets_used; i++)
257  {
258  poly p=L->bucket->buckets[i];
259  if(p!=NULL)
260  {
261  if (p_Cmp(p,strat->kNoetherTail(), L->tailRing) == -1)
262  {
263  L->bucket->buckets[i]=NULL;
264  L->bucket->buckets_length[i]=0;
265  }
266  else
267  {
268  do
269  {
270  if (p_Cmp(pNext(p),strat->kNoetherTail(), L->tailRing) == -1)
271  {
272  p_Delete(&pNext(p), L->tailRing);
273  L->bucket->buckets_length[i]=pLength(L->bucket->buckets[i]);
274  break;
275  }
276  pIter(p);
277  } while(p!=NULL);
278  }
279  }
280  }
281  int i=L->bucket->buckets_used;
282  while ((i>0)&&(L->bucket->buckets[i]==NULL))
283  {
284  i--;
285  L->bucket->buckets_used=i;
286  }
287  }
288 }
static unsigned pLength(poly a)
Definition: p_polys.h:191

◆ deleteInL()

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

Definition at line 1295 of file kutil.cc.

1296 {
1297  if (set[j].lcm!=NULL)
1298  {
1299  kDeleteLcm(&set[j]);
1300  }
1301  if (set[j].sig!=NULL)
1302  {
1303 #ifdef HAVE_RINGS
1304  if (pGetCoeff(set[j].sig) != NULL)
1305  pLmDelete(set[j].sig);
1306  else
1307 #endif
1308  pLmFree(set[j].sig);
1309  }
1310  if (set[j].p!=NULL)
1311  {
1312  if (pNext(set[j].p) == strat->tail)
1313  {
1314 #ifdef HAVE_RINGS
1315  if (pGetCoeff(set[j].p) != NULL)
1316  pLmDelete(set[j].p);
1317  else
1318 #endif
1319  pLmFree(set[j].p);
1320  /*- tail belongs to several int spolys -*/
1321  }
1322  else
1323  {
1324  // search p in T, if it is there, do not delete it
1325  if (rHasGlobalOrdering(currRing) || (kFindInT(set[j].p, strat) < 0))
1326  {
1327  // assure that for global orderings kFindInT fails
1328  //assume((rHasLocalOrMixedOrdering(currRing)) && (kFindInT(set[j].p, strat) >= 0));
1329  set[j].Delete();
1330  }
1331  }
1332  }
1333  #ifdef HAVE_SHIFTBBA
1334  if (is_shifted_p1(strat->P.p1,strat))
1335  {
1336  // clean up strat->P.p1: may be shifted
1337  pLmDelete(strat->P.p1);
1338  strat->P.p1=NULL;
1339  }
1340  #endif
1341  if (*length > 0 && j < *length)
1342  {
1343 #ifdef ENTER_USE_MEMMOVE
1344  memmove(&(set[j]), &(set[j+1]), (*length - j)*sizeof(LObject));
1345 #else
1346  int i;
1347  for (i=j; i < (*length); i++)
1348  set[i] = set[i+1];
1349 #endif
1350  }
1351 #ifdef KDEBUG
1352  memset(&(set[*length]),0,sizeof(LObject));
1353 #endif
1354  (*length)--;
1355 }
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:257
int kFindInT(poly p, TSet T, int tlength)
returns index of p in TSet, or -1 if not found
Definition: kutil.cc:742
static BOOLEAN is_shifted_p1(const poly p, const kStrategy strat)
Definition: kutil.cc:1268
static void kDeleteLcm(LObject *P)
Definition: kutil.h:886
int lcm(unsigned long *l, unsigned long *a, unsigned long *b, unsigned long p, int dega, int degb)
Definition: minpoly.cc:709
#define pLmDelete(p)
assume p != NULL, deletes Lm(p)->coef and Lm(p)
Definition: polys.h:76
static void pLmFree(poly p)
frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced
Definition: polys.h:70

◆ deleteInS()

void deleteInS ( int  i,
kStrategy  strat 
)

Definition at line 1163 of file kutil.cc.

1164 {
1165 #ifdef ENTER_USE_MEMMOVE
1166  memmove(&(strat->S[i]), &(strat->S[i+1]), (strat->sl - i)*sizeof(poly));
1167  memmove(&(strat->ecartS[i]),&(strat->ecartS[i+1]),(strat->sl - i)*sizeof(int));
1168  memmove(&(strat->sevS[i]),&(strat->sevS[i+1]),(strat->sl - i)*sizeof(unsigned long));
1169  memmove(&(strat->S_2_R[i]),&(strat->S_2_R[i+1]),(strat->sl - i)*sizeof(int));
1170 #else
1171  int j;
1172  for (j=i; j<strat->sl; j++)
1173  {
1174  strat->S[j] = strat->S[j+1];
1175  strat->ecartS[j] = strat->ecartS[j+1];
1176  strat->sevS[j] = strat->sevS[j+1];
1177  strat->S_2_R[j] = strat->S_2_R[j+1];
1178  }
1179 #endif
1180  if (strat->lenS!=NULL)
1181  {
1182 #ifdef ENTER_USE_MEMMOVE
1183  memmove(&(strat->lenS[i]),&(strat->lenS[i+1]),(strat->sl - i)*sizeof(int));
1184 #else
1185  for (j=i; j<strat->sl; j++) strat->lenS[j] = strat->lenS[j+1];
1186 #endif
1187  }
1188  if (strat->lenSw!=NULL)
1189  {
1190 #ifdef ENTER_USE_MEMMOVE
1191  memmove(&(strat->lenSw[i]),&(strat->lenSw[i+1]),(strat->sl - i)*sizeof(wlen_type));
1192 #else
1193  for (j=i; j<strat->sl; j++) strat->lenSw[j] = strat->lenSw[j+1];
1194 #endif
1195  }
1196  if (strat->fromQ!=NULL)
1197  {
1198 #ifdef ENTER_USE_MEMMOVE
1199  memmove(&(strat->fromQ[i]),&(strat->fromQ[i+1]),(strat->sl - i)*sizeof(int));
1200 #else
1201  for (j=i; j<strat->sl; j++)
1202  {
1203  strat->fromQ[j] = strat->fromQ[j+1];
1204  }
1205 #endif
1206  }
1207  strat->S[strat->sl] = NULL;
1208  strat->sl--;
1209 }
int * S_2_R
Definition: kutil.h:342
intset lenS
Definition: kutil.h:319
intset ecartS
Definition: kutil.h:309
wlen_set lenSw
Definition: kutil.h:320
unsigned long * sevS
Definition: kutil.h:322
int64 wlen_type
Definition: kutil.h:54

◆ deleteInSSba()

void deleteInSSba ( int  i,
kStrategy  strat 
)

Definition at line 1215 of file kutil.cc.

1216 {
1217 #ifdef ENTER_USE_MEMMOVE
1218  memmove(&(strat->S[i]), &(strat->S[i+1]), (strat->sl - i)*sizeof(poly));
1219  memmove(&(strat->sig[i]), &(strat->sig[i+1]), (strat->sl - i)*sizeof(poly));
1220  memmove(&(strat->ecartS[i]),&(strat->ecartS[i+1]),(strat->sl - i)*sizeof(int));
1221  memmove(&(strat->sevS[i]),&(strat->sevS[i+1]),(strat->sl - i)*sizeof(unsigned long));
1222  memmove(&(strat->sevSig[i]),&(strat->sevSig[i+1]),(strat->sl - i)*sizeof(unsigned long));
1223  memmove(&(strat->S_2_R[i]),&(strat->S_2_R[i+1]),(strat->sl - i)*sizeof(int));
1224 #else
1225  int j;
1226  for (j=i; j<strat->sl; j++)
1227  {
1228  strat->S[j] = strat->S[j+1];
1229  strat->sig[j] = strat->sig[j+1];
1230  strat->ecartS[j] = strat->ecartS[j+1];
1231  strat->sevS[j] = strat->sevS[j+1];
1232  strat->sevSig[j] = strat->sevSig[j+1];
1233  strat->S_2_R[j] = strat->S_2_R[j+1];
1234  }
1235 #endif
1236  if (strat->lenS!=NULL)
1237  {
1238 #ifdef ENTER_USE_MEMMOVE
1239  memmove(&(strat->lenS[i]),&(strat->lenS[i+1]),(strat->sl - i)*sizeof(int));
1240 #else
1241  for (j=i; j<strat->sl; j++) strat->lenS[j] = strat->lenS[j+1];
1242 #endif
1243  }
1244  if (strat->lenSw!=NULL)
1245  {
1246 #ifdef ENTER_USE_MEMMOVE
1247  memmove(&(strat->lenSw[i]),&(strat->lenSw[i+1]),(strat->sl - i)*sizeof(wlen_type));
1248 #else
1249  for (j=i; j<strat->sl; j++) strat->lenSw[j] = strat->lenSw[j+1];
1250 #endif
1251  }
1252  if (strat->fromQ!=NULL)
1253  {
1254 #ifdef ENTER_USE_MEMMOVE
1255  memmove(&(strat->fromQ[i]),&(strat->fromQ[i+1]),(strat->sl - i)*sizeof(int));
1256 #else
1257  for (j=i; j<strat->sl; j++)
1258  {
1259  strat->fromQ[j] = strat->fromQ[j+1];
1260  }
1261 #endif
1262  }
1263  strat->S[strat->sl] = NULL;
1264  strat->sl--;
1265 }

◆ enlargeL()

static void enlargeL ( LSet L,
int *  length,
const int  incr 
)
inlinestatic

Definition at line 687 of file kutil.cc.

688 {
689  assume((*L)!=NULL);
690  assume(((*length)+incr)>0);
691 
692  *L = (LSet)omReallocSize((*L),(*length)*sizeof(LObject),
693  ((*length)+incr)*sizeof(LObject));
694  (*length) += incr;
695 }
LObject * LSet
Definition: kutil.h:60
#define omReallocSize(addr, o_size, size)
Definition: omAllocDecl.h:220

◆ enlargeT()

static void enlargeT ( TSet T,
TObject **&  R,
unsigned long *&  sevT,
int &  length,
const int  incr 
)
inlinestatic

Definition at line 548 of file kutil.cc.

550 {
551  assume(T!=NULL);
552  assume(sevT!=NULL);
553  assume(R!=NULL);
554  assume((length+incr) > 0);
555 
556  int i;
557  T = (TSet)omRealloc0Size(T, length*sizeof(TObject),
558  (length+incr)*sizeof(TObject));
559 
560  sevT = (unsigned long*) omReallocSize(sevT, length*sizeof(long*),
561  (length+incr)*sizeof(long*));
562 
563  R = (TObject**)omRealloc0Size(R,length*sizeof(TObject*),
564  (length+incr)*sizeof(TObject*));
565  for (i=length-1;i>=0;i--) R[T[i].i_r] = &(T[i]);
566  length += incr;
567 }
STATIC_VAR jList * T
Definition: janet.cc:30
TObject * TSet
Definition: kutil.h:59
#define omRealloc0Size(addr, o_size, size)
Definition: omAllocDecl.h:221
#define R
Definition: sirandom.c:27

◆ enterExtendedSpoly()

void enterExtendedSpoly ( poly  h,
kStrategy  strat 
)

Definition at line 4329 of file kutil.cc.

4330 {
4331  if (nIsOne(pGetCoeff(h))) return;
4332  number gcd;
4333  bool go = false;
4334  if (n_DivBy((number) 0, pGetCoeff(h), currRing->cf))
4335  {
4336  gcd = n_Ann(pGetCoeff(h),currRing->cf);
4337  go = true;
4338  }
4339  else
4340  gcd = n_Gcd((number) 0, pGetCoeff(h), strat->tailRing->cf);
4341  if (go || !nIsOne(gcd))
4342  {
4343  poly p = h->next;
4344  if (!go)
4345  {
4346  number tmp = gcd;
4347  gcd = n_Ann(gcd,currRing->cf);
4348  nDelete(&tmp);
4349  }
4350  p_Test(p,strat->tailRing);
4351  p = __pp_Mult_nn(p, gcd, strat->tailRing);
4352  nDelete(&gcd);
4353 
4354  if (p != NULL)
4355  {
4356  if (TEST_OPT_PROT)
4357  {
4358  PrintS("Z");
4359  }
4360 #ifdef KDEBUG
4361  if (TEST_OPT_DEBUG)
4362  {
4363  PrintS("--- create zero spoly: ");
4364  p_wrp(h,currRing,strat->tailRing);
4365  PrintS(" ---> ");
4366  }
4367 #endif
4368  poly tmp = pInit();
4369  pSetCoeff0(tmp, pGetCoeff(p));
4370  for (int i = 1; i <= rVar(currRing); i++)
4371  {
4372  pSetExp(tmp, i, p_GetExp(p, i, strat->tailRing));
4373  }
4375  {
4376  p_SetComp(tmp, __p_GetComp(p, strat->tailRing), currRing);
4377  }
4378  p_Setm(tmp, currRing);
4379  p = p_LmFreeAndNext(p, strat->tailRing);
4380  pNext(tmp) = p;
4381  LObject Lp;
4382  Lp.Init();
4383  Lp.p = tmp;
4384  Lp.tailRing = strat->tailRing;
4385  int posx;
4386  if (Lp.p!=NULL)
4387  {
4388  strat->initEcart(&Lp);
4389  if (strat->Ll==-1)
4390  posx =0;
4391  else
4392  posx = strat->posInL(strat->L,strat->Ll,&Lp,strat);
4393  Lp.sev = pGetShortExpVector(Lp.p);
4394  if (strat->tailRing != currRing)
4395  {
4396  Lp.t_p = k_LmInit_currRing_2_tailRing(Lp.p, strat->tailRing);
4397  }
4398 #ifdef KDEBUG
4399  if (TEST_OPT_DEBUG)
4400  {
4401  p_wrp(tmp,currRing,strat->tailRing);
4402  PrintLn();
4403  }
4404 #endif
4405  enterL(&strat->L,&strat->Ll,&strat->Lmax,Lp,posx);
4406  }
4407  }
4408  }
4409  nDelete(&gcd);
4410 }
int(* posInL)(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.h:284
void(* initEcart)(TObject *L)
Definition: kutil.h:280
int Lmax
Definition: kutil.h:351
static FORCE_INLINE number n_Gcd(number a, number b, const coeffs r)
in Z: return the gcd of 'a' and 'b' in Z/nZ, Z/2^kZ: computed as in the case Z in Z/pZ,...
Definition: coeffs.h:664
static FORCE_INLINE number n_Ann(number a, const coeffs r)
if r is a ring with zero divisors, return an annihilator!=0 of b otherwise return NULL
Definition: coeffs.h:679
KINLINE poly k_LmInit_currRing_2_tailRing(poly p, ring tailRing, omBin tailBin)
Definition: kInline.h:970
void enterL(LSet *set, int *length, int *LSetmax, LObject p, int at)
Definition: kutil.cc:1360
#define __p_GetComp(p, r)
Definition: monomials.h:63
#define rRing_has_Comp(r)
Definition: monomials.h:266
#define __pp_Mult_nn(p, n, r)
Definition: p_polys.h:1004
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition: p_polys.h:249
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:235
static poly p_LmFreeAndNext(poly p, ring)
Definition: p_polys.h:713
#define p_Test(p, r)
Definition: p_polys.h:162
#define pInit()
allocates a new monomial and initializes everything to 0
Definition: polys.h:61
#define pSetExp(p, i, v)
Definition: polys.h:42
int gcd(int a, int b)
Definition: walkSupport.cc:836

◆ enterExtendedSpolySig()

void enterExtendedSpolySig ( poly  h,
poly  hSig,
kStrategy  strat 
)

Definition at line 4412 of file kutil.cc.

4413 {
4414  if (nIsOne(pGetCoeff(h))) return;
4415  number gcd;
4416  bool go = false;
4417  if (n_DivBy((number) 0, pGetCoeff(h), currRing->cf))
4418  {
4419  gcd = n_Ann(pGetCoeff(h),currRing->cf);
4420  go = true;
4421  }
4422  else
4423  gcd = n_Gcd((number) 0, pGetCoeff(h), strat->tailRing->cf);
4424  if (go || !nIsOne(gcd))
4425  {
4426  poly p = h->next;
4427  if (!go)
4428  {
4429  number tmp = gcd;
4430  gcd = n_Ann(gcd,currRing->cf);
4431  nDelete(&tmp);
4432  }
4433  p_Test(p,strat->tailRing);
4434  p = __pp_Mult_nn(p, gcd, strat->tailRing);
4435 
4436  if (p != NULL)
4437  {
4438  if (TEST_OPT_PROT)
4439  {
4440  PrintS("Z");
4441  }
4442 #ifdef KDEBUG
4443  if (TEST_OPT_DEBUG)
4444  {
4445  PrintS("--- create zero spoly: ");
4446  p_wrp(h,currRing,strat->tailRing);
4447  PrintS(" ---> ");
4448  }
4449 #endif
4450  poly tmp = pInit();
4451  pSetCoeff0(tmp, pGetCoeff(p));
4452  for (int i = 1; i <= rVar(currRing); i++)
4453  {
4454  pSetExp(tmp, i, p_GetExp(p, i, strat->tailRing));
4455  }
4457  {
4458  p_SetComp(tmp, __p_GetComp(p, strat->tailRing), currRing);
4459  }
4460  p_Setm(tmp, currRing);
4461  p = p_LmFreeAndNext(p, strat->tailRing);
4462  pNext(tmp) = p;
4463  LObject Lp;
4464  Lp.Init();
4465  Lp.p = tmp;
4466  //printf("\nOld\n");pWrite(h);pWrite(hSig);
4467  #if EXT_POLY_NEW
4468  Lp.sig = __pp_Mult_nn(hSig, gcd, currRing);
4469  if(Lp.sig == NULL || nIsZero(pGetCoeff(Lp.sig)))
4470  {
4471  strat->sigdrop = TRUE;
4472  //Try to reduce it as far as we can via redRing
4473  int red_result = redRing(&Lp,strat);
4474  if(red_result == 0)
4475  {
4476  // Cancel the sigdrop
4477  p_Delete(&Lp.sig,currRing);Lp.sig = NULL;
4478  strat->sigdrop = FALSE;
4479  return;
4480  }
4481  else
4482  {
4483  strat->enterS(strat->P,strat->sl+1,strat, strat->tl+1);
4484  #if 1
4485  strat->enterS(Lp,0,strat,strat->tl);
4486  #endif
4487  return;
4488  }
4489 
4490  }
4491  #else
4492  Lp.sig = pOne();
4493  if(strat->Ll >= 0)
4494  p_SetComp(Lp.sig,pGetComp(strat->L[0].sig)+1,currRing);
4495  else
4496  p_SetComp(Lp.sig,pGetComp(hSig)+1,currRing);
4497  #endif
4498  Lp.tailRing = strat->tailRing;
4499  int posx;
4500  if (Lp.p!=NULL)
4501  {
4502  strat->initEcart(&Lp);
4503  if (strat->Ll==-1)
4504  posx =0;
4505  else
4506  posx = strat->posInLSba(strat->L,strat->Ll,&Lp,strat);
4507  Lp.sev = pGetShortExpVector(Lp.p);
4508  if (strat->tailRing != currRing)
4509  {
4510  Lp.t_p = k_LmInit_currRing_2_tailRing(Lp.p, strat->tailRing);
4511  }
4512 #ifdef KDEBUG
4513  if (TEST_OPT_DEBUG)
4514  {
4515  p_wrp(tmp,currRing,strat->tailRing);
4516  PrintLn();
4517  }
4518 #endif
4519  //pWrite(h);pWrite(hSig);pWrite(Lp.p);pWrite(Lp.sig);printf("\n------------------\n");getchar();
4520  enterL(&strat->L,&strat->Ll,&strat->Lmax,Lp,posx);
4521  }
4522  }
4523  nDelete(&gcd);
4524  }
4525  nDelete(&gcd);
4526 }
bool sigdrop
Definition: kutil.h:359
void(* enterS)(LObject &h, int pos, kStrategy strat, int atR)
Definition: kutil.h:286
int(* posInLSba)(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.h:282
int redRing(LObject *h, kStrategy strat)
Definition: kstd2.cc:831
#define nIsZero(n)
Definition: numbers.h:19

◆ enterL()

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

Definition at line 1360 of file kutil.cc.

1361 {
1362  // this should be corrected
1363  assume(p.FDeg == p.pFDeg());
1364 
1365  if ((*length)>=0)
1366  {
1367  if ((*length) == (*LSetmax)-1) enlargeL(set,LSetmax,setmaxLinc);
1368  if (at <= (*length))
1369 #ifdef ENTER_USE_MEMMOVE
1370  memmove(&((*set)[at+1]), &((*set)[at]), ((*length)-at+1)*sizeof(LObject));
1371 #else
1372  for (i=(*length)+1; i>=at+1; i--) (*set)[i] = (*set)[i-1];
1373 #endif
1374  }
1375  else at = 0;
1376  (*set)[at] = p;
1377  (*length)++;
1378 }
static void enlargeL(LSet *L, int *length, const int incr)
Definition: kutil.cc:687
#define setmaxLinc
Definition: kutil.h:31

◆ enterOnePairLift()

static void enterOnePairLift ( int  i,
poly  p,
int  ecart,
int  isFromQ,
kStrategy  strat,
int  atR = -1 
)
static

Definition at line 2314 of file kutil.cc.

2315 {
2316  assume(ALLOW_PROD_CRIT(strat));
2318  assume(i<=strat->sl);
2319  assume(strat->syzComp==1);
2320 
2321  if ((strat->S[i]==NULL) || (p==NULL))
2322  return;
2323 
2324  int l,j,compare;
2325  LObject Lp;
2326  Lp.i_r = -1;
2327 
2328 #ifdef KDEBUG
2329  Lp.ecart=0; Lp.length=0;
2330 #endif
2331  /*- computes the lcm(s[i],p) -*/
2332  Lp.lcm = p_Lcm(p,strat->S[i],currRing);
2333 
2334  if (strat->sugarCrit)
2335  {
2336  if((!((strat->ecartS[i]>0)&&(ecart>0)))
2337  && p_HasNotCF_Lift(p,strat->S[i],currRing))
2338  {
2339  /*
2340  *the product criterion has applied for (s,p),
2341  *i.e. lcm(s,p)=product of the leading terms of s and p.
2342  *Suppose (s,r) is in L and the leading term
2343  *of p divides lcm(s,r)
2344  *(==> the leading term of p divides the leading term of r)
2345  *but the leading term of s does not divide the leading term of r
2346  *(notice that tis condition is automatically satisfied if r is still
2347  *in S), then (s,r) can be cancelled.
2348  *This should be done here because the
2349  *case lcm(s,r)=lcm(s,p) is not covered by chainCrit.
2350  *
2351  *Moreover, skipping (s,r) holds also for the noncommutative case.
2352  */
2353  strat->cp++;
2354  pLmFree(Lp.lcm);
2355  return;
2356  }
2357  else
2358  Lp.ecart = si_max(ecart,strat->ecartS[i]);
2359  if (strat->fromT && (strat->ecartS[i]>ecart))
2360  {
2361  pLmFree(Lp.lcm);
2362  return;
2363  /*the pair is (s[i],t[.]), discard it if the ecart is too big*/
2364  }
2365  /*
2366  *the set B collects the pairs of type (S[j],p)
2367  *suppose (r,p) is in B and (s,p) is the new pair and lcm(s,p)#lcm(r,p)
2368  *if the leading term of s divides lcm(r,p) then (r,p) will be canceled
2369  *if the leading term of r divides lcm(s,p) then (s,p) will not enter B
2370  */
2371  {
2372  j = strat->Bl;
2373  loop
2374  {
2375  if (j < 0) break;
2376  compare=pDivComp(strat->B[j].lcm,Lp.lcm);
2377  if ((compare==1)
2378  &&(sugarDivisibleBy(strat->B[j].ecart,Lp.ecart)))
2379  {
2380  strat->c3++;
2381  if ((strat->fromQ==NULL) || (isFromQ==0) || (strat->fromQ[i]==0))
2382  {
2383  pLmFree(Lp.lcm);
2384  return;
2385  }
2386  break;
2387  }
2388  else
2389  if ((compare ==-1)
2390  && sugarDivisibleBy(Lp.ecart,strat->B[j].ecart))
2391  {
2392  deleteInL(strat->B,&strat->Bl,j,strat);
2393  strat->c3++;
2394  }
2395  j--;
2396  }
2397  }
2398  }
2399  else /*sugarcrit*/
2400  {
2401  if(/*(strat->ak==0) && productCrit(p,strat->S[i])*/
2402  p_HasNotCF_Lift(p,strat->S[i],currRing))
2403  {
2404  /*
2405  *the product criterion has applied for (s,p),
2406  *i.e. lcm(s,p)=product of the leading terms of s and p.
2407  *Suppose (s,r) is in L and the leading term
2408  *of p divides lcm(s,r)
2409  *(==> the leading term of p divides the leading term of r)
2410  *but the leading term of s does not divide the leading term of r
2411  *(notice that tis condition is automatically satisfied if r is still
2412  *in S), then (s,r) can be canceled.
2413  *This should be done here because the
2414  *case lcm(s,r)=lcm(s,p) is not covered by chainCrit.
2415  */
2416  strat->cp++;
2417  pLmFree(Lp.lcm);
2418  return;
2419  }
2420  if (strat->fromT && (strat->ecartS[i]>ecart))
2421  {
2422  pLmFree(Lp.lcm);
2423  return;
2424  /*the pair is (s[i],t[.]), discard it if the ecart is too big*/
2425  }
2426  /*
2427  *the set B collects the pairs of type (S[j],p)
2428  *suppose (r,p) is in B and (s,p) is the new pair and lcm(s,p)#lcm(r,p)
2429  *if the leading term of s divides lcm(r,p) then (r,p) will be canceled
2430  *if the leading term of r divides lcm(s,p) then (s,p) will not enter B
2431  */
2432  for(j = strat->Bl;j>=0;j--)
2433  {
2434  compare=pDivComp(strat->B[j].lcm,Lp.lcm);
2435  if (compare==1)
2436  {
2437  strat->c3++;
2438  if ((strat->fromQ==NULL) || (isFromQ==0) || (strat->fromQ[i]==0))
2439  {
2440  pLmFree(Lp.lcm);
2441  return;
2442  }
2443  break;
2444  }
2445  else
2446  if (compare ==-1)
2447  {
2448  deleteInL(strat->B,&strat->Bl,j,strat);
2449  strat->c3++;
2450  }
2451  }
2452  }
2453  /*
2454  *the pair (S[i],p) enters B if the spoly != 0
2455  */
2456  /*- compute the short s-polynomial -*/
2457  if (strat->fromT && !TEST_OPT_INTSTRATEGY)
2458  pNorm(p);
2459 
2460  if ((strat->fromQ!=NULL) && (isFromQ!=0) && (strat->fromQ[i]!=0))
2461  Lp.p=NULL;
2462  else
2463  {
2465  Lp.p = ksCreateShortSpoly(strat->S[i], p, strat->tailRing);
2466  }
2467  if (Lp.p == NULL)
2468  {
2469  /*- the case that the s-poly is 0 -*/
2470  if (strat->pairtest==NULL) initPairtest(strat);
2471  strat->pairtest[i] = TRUE;/*- hint for spoly(S^[i],p)=0 -*/
2472  strat->pairtest[strat->sl+1] = TRUE;
2473  /*hint for spoly(S[i],p) == 0 for some i,0 <= i <= sl*/
2474  /*
2475  *suppose we have (s,r),(r,p),(s,p) and spoly(s,p) == 0 and (r,p) is
2476  *still in B (i.e. lcm(r,p) == lcm(s,p) or the leading term of s does not
2477  *divide lcm(r,p)). In the last case (s,r) can be canceled if the leading
2478  *term of p divides the lcm(s,r)
2479  *(this canceling should be done here because
2480  *the case lcm(s,p) == lcm(s,r) is not covered in chainCrit)
2481  *the first case is handeled in chainCrit
2482  */
2483  if (Lp.lcm!=NULL) pLmFree(Lp.lcm);
2484  }
2485  else
2486  {
2487  /*- the pair (S[i],p) enters B -*/
2488  Lp.p1 = strat->S[i];
2489  Lp.p2 = p;
2490 
2491  pNext(Lp.p) = strat->tail; // !!!
2492 
2493  if (atR >= 0)
2494  {
2495  Lp.i_r1 = strat->S_2_R[i];
2496  Lp.i_r2 = atR;
2497  }
2498  else
2499  {
2500  Lp.i_r1 = -1;
2501  Lp.i_r2 = -1;
2502  }
2503  strat->initEcartPair(&Lp,strat->S[i],p,strat->ecartS[i],ecart);
2504 
2506  {
2507  if (!rIsPluralRing(currRing)
2509  && (Lp.p->coef!=NULL))
2510  nDelete(&(Lp.p->coef));
2511  }
2512 
2513  l = strat->posInL(strat->B,strat->Bl,&Lp,strat);
2514  enterL(&strat->B,&strat->Bl,&strat->Bmax,Lp,l);
2515  }
2516 }
static int si_max(const int a, const int b)
Definition: auxiliary.h:124
int cp
Definition: kutil.h:347
void(* initEcartPair)(LObject *h, poly f, poly g, int ecartF, int ecartG)
Definition: kutil.h:287
int Bmax
Definition: kutil.h:352
poly ksCreateShortSpoly(poly p1, poly p2, ring tailRing)
Definition: kspoly.cc:1430
void initPairtest(kStrategy strat)
Definition: kutil.cc:697
static BOOLEAN p_HasNotCF_Lift(poly p1, poly p2, const ring r)
p_HasNotCF for the IDLIFT case and syzComp==1: ignore component
Definition: kutil.cc:2295
static int pDivComp(poly p, poly q)
Definition: kutil.cc:183
#define ALLOW_PROD_CRIT(A)
Definition: kutil.h:395
void p_Lcm(const poly a, const poly b, poly m, const ring r)
Definition: p_polys.cc:1651
void pNorm(poly p)
Definition: polys.h:363
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition: ring.h:400

◆ enterOnePairNormal()

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

Definition at line 2032 of file kutil.cc.

2033 {
2034  assume(i<=strat->sl);
2035 
2036  int l,j,compare;
2037  LObject Lp;
2038  Lp.i_r = -1;
2039 
2040 #ifdef KDEBUG
2041  Lp.ecart=0; Lp.length=0;
2042 #endif
2043  /*- computes the lcm(s[i],p) -*/
2044  Lp.lcm = pInit();
2045 
2046 #ifndef HAVE_RATGRING
2047  pLcm(p,strat->S[i],Lp.lcm);
2048 #elif defined(HAVE_RATGRING)
2049  if (rIsRatGRing(currRing))
2050  pLcmRat(p,strat->S[i],Lp.lcm, currRing->real_var_start); // int rat_shift
2051  else
2052  pLcm(p,strat->S[i],Lp.lcm);
2053 #endif
2054  pSetm(Lp.lcm);
2055 
2056 
2057  if (strat->sugarCrit && ALLOW_PROD_CRIT(strat))
2058  {
2059  if (strat->fromT && (strat->ecartS[i]>ecart))
2060  {
2061  pLmFree(Lp.lcm);
2062  return;
2063  /*the pair is (s[i],t[.]), discard it if the ecart is too big*/
2064  }
2065  if((!((strat->ecartS[i]>0)&&(ecart>0)))
2066  && pHasNotCF(p,strat->S[i]))
2067  {
2068  /*
2069  *the product criterion has applied for (s,p),
2070  *i.e. lcm(s,p)=product of the leading terms of s and p.
2071  *Suppose (s,r) is in L and the leading term
2072  *of p divides lcm(s,r)
2073  *(==> the leading term of p divides the leading term of r)
2074  *but the leading term of s does not divide the leading term of r
2075  *(notice that tis condition is automatically satisfied if r is still
2076  *in S), then (s,r) can be cancelled.
2077  *This should be done here because the
2078  *case lcm(s,r)=lcm(s,p) is not covered by chainCrit.
2079  *
2080  *Moreover, skipping (s,r) holds also for the noncommutative case.
2081  */
2082  strat->cp++;
2083  pLmFree(Lp.lcm);
2084  return;
2085  }
2086  Lp.ecart = si_max(ecart,strat->ecartS[i]);
2087  /*
2088  *the set B collects the pairs of type (S[j],p)
2089  *suppose (r,p) is in B and (s,p) is the new pair and lcm(s,p)#lcm(r,p)
2090  *if the leading term of s divides lcm(r,p) then (r,p) will be canceled
2091  *if the leading term of r divides lcm(s,p) then (s,p) will not enter B
2092  */
2093  {
2094  j = strat->Bl;
2095  loop
2096  {
2097  if (j < 0) break;
2098  compare=pDivComp(strat->B[j].lcm,Lp.lcm);
2099  if ((compare==1)
2100  &&(sugarDivisibleBy(strat->B[j].ecart,Lp.ecart)))
2101  {
2102  strat->c3++;
2103  if ((strat->fromQ==NULL) || (isFromQ==0) || (strat->fromQ[i]==0))
2104  {
2105  pLmFree(Lp.lcm);
2106  return;
2107  }
2108  break;
2109  }
2110  else
2111  if ((compare ==-1)
2112  && sugarDivisibleBy(Lp.ecart,strat->B[j].ecart))
2113  {
2114  deleteInL(strat->B,&strat->Bl,j,strat);
2115  strat->c3++;
2116  }
2117  j--;
2118  }
2119  }
2120  }
2121  else /*sugarcrit*/
2122  {
2123  if (ALLOW_PROD_CRIT(strat))
2124  {
2125  if (strat->fromT && (strat->ecartS[i]>ecart))
2126  {
2127  pLmFree(Lp.lcm);
2128  return;
2129  /*the pair is (s[i],t[.]), discard it if the ecart is too big*/
2130  }
2131  // if currRing->nc_type!=quasi (or skew)
2132  // TODO: enable productCrit for super commutative algebras...
2133  if(/*(strat->ak==0) && productCrit(p,strat->S[i])*/
2134  pHasNotCF(p,strat->S[i]))
2135  {
2136  /*
2137  *the product criterion has applied for (s,p),
2138  *i.e. lcm(s,p)=product of the leading terms of s and p.
2139  *Suppose (s,r) is in L and the leading term
2140  *of p divides lcm(s,r)
2141  *(==> the leading term of p divides the leading term of r)
2142  *but the leading term of s does not divide the leading term of r
2143  *(notice that tis condition is automatically satisfied if r is still
2144  *in S), then (s,r) can be canceled.
2145  *This should be done here because the
2146  *case lcm(s,r)=lcm(s,p) is not covered by chainCrit.
2147  */
2148  strat->cp++;
2149  pLmFree(Lp.lcm);
2150  return;
2151  }
2152  /*
2153  *the set B collects the pairs of type (S[j],p)
2154  *suppose (r,p) is in B and (s,p) is the new pair and lcm(s,p)#lcm(r,p)
2155  *if the leading term of s divides lcm(r,p) then (r,p) will be canceled
2156  *if the leading term of r divides lcm(s,p) then (s,p) will not enter B
2157  */
2158  for(j = strat->Bl;j>=0;j--)
2159  {
2160  compare=pDivComp(strat->B[j].lcm,Lp.lcm);
2161  if (compare==1)
2162  {
2163  strat->c3++;
2164  if ((strat->fromQ==NULL) || (isFromQ==0) || (strat->fromQ[i]==0))
2165  {
2166  pLmFree(Lp.lcm);
2167  return;
2168  }
2169  break;
2170  }
2171  else
2172  if (compare ==-1)
2173  {
2174  deleteInL(strat->B,&strat->Bl,j,strat);
2175  strat->c3++;
2176  }
2177  }
2178  }
2179  }
2180  /*
2181  *the pair (S[i],p) enters B if the spoly != 0
2182  */
2183  /*- compute the short s-polynomial -*/
2184  if (strat->fromT && !TEST_OPT_INTSTRATEGY)
2185  pNorm(p);
2186 
2187  if ((strat->S[i]==NULL) || (p==NULL))
2188  return;
2189 
2190  if ((strat->fromQ!=NULL) && (isFromQ!=0) && (strat->fromQ[i]!=0))
2191  Lp.p=NULL;
2192  else
2193  {
2194  #ifdef HAVE_PLURAL
2195  if ( rIsPluralRing(currRing) )
2196  {
2197  if(pHasNotCF(p, strat->S[i]))
2198  {
2199  if(ncRingType(currRing) == nc_lie)
2200  {
2201  // generalized prod-crit for lie-type
2202  strat->cp++;
2203  Lp.p = nc_p_Bracket_qq(pCopy(p),strat->S[i], currRing);
2204  }
2205  else
2206  if( ALLOW_PROD_CRIT(strat) )
2207  {
2208  // product criterion for homogeneous case in SCA
2209  strat->cp++;
2210  Lp.p = NULL;
2211  }
2212  else
2213  {
2214  Lp.p = // nc_CreateSpoly(strat->S[i],p,currRing);
2215  nc_CreateShortSpoly(strat->S[i], p, currRing);
2216  assume(pNext(Lp.p)==NULL); // TODO: this may be violated whenever ext.prod.crit. for Lie alg. is used
2217  pNext(Lp.p) = strat->tail; // !!!
2218  }
2219  }
2220  else
2221  {
2222  Lp.p = // nc_CreateSpoly(strat->S[i],p,currRing);
2223  nc_CreateShortSpoly(strat->S[i], p, currRing);
2224 
2225  assume(pNext(Lp.p)==NULL); // TODO: this may be violated whenever ext.prod.crit. for Lie alg. is used
2226  pNext(Lp.p) = strat->tail; // !!!
2227  }
2228  }
2229  else
2230  #endif
2231  {
2233  Lp.p = ksCreateShortSpoly(strat->S[i], p, strat->tailRing);
2234  }
2235  }
2236  if (Lp.p == NULL)
2237  {
2238  /*- the case that the s-poly is 0 -*/
2239  if (strat->pairtest==NULL) initPairtest(strat);
2240  strat->pairtest[i] = TRUE;/*- hint for spoly(S^[i],p)=0 -*/
2241  strat->pairtest[strat->sl+1] = TRUE;
2242  /*hint for spoly(S[i],p) == 0 for some i,0 <= i <= sl*/
2243  /*
2244  *suppose we have (s,r),(r,p),(s,p) and spoly(s,p) == 0 and (r,p) is
2245  *still in B (i.e. lcm(r,p) == lcm(s,p) or the leading term of s does not
2246  *divide lcm(r,p)). In the last case (s,r) can be canceled if the leading
2247  *term of p divides the lcm(s,r)
2248  *(this canceling should be done here because
2249  *the case lcm(s,p) == lcm(s,r) is not covered in chainCrit)
2250  *the first case is handeled in chainCrit
2251  */
2252  if (Lp.lcm!=NULL) pLmFree(Lp.lcm);
2253  }
2254  else
2255  {
2256  /*- the pair (S[i],p) enters B -*/
2257  Lp.p1 = strat->S[i];
2258  Lp.p2 = p;
2259 
2260  if (
2262 // || (rIsPluralRing(currRing) && (ncRingType(currRing) != nc_lie))
2263  )
2264  {
2265  assume(pNext(Lp.p)==NULL); // TODO: this may be violated whenever ext.prod.crit. for Lie alg. is used
2266  pNext(Lp.p) = strat->tail; // !!!
2267  }
2268 
2269  if (atR >= 0)
2270  {
2271  Lp.i_r1 = strat->S_2_R[i];
2272  Lp.i_r2 = atR;
2273  }
2274  else
2275  {
2276  Lp.i_r1 = -1;
2277  Lp.i_r2 = -1;
2278  }
2279  strat->initEcartPair(&Lp,strat->S[i],p,strat->ecartS[i],ecart);
2280 
2282  {
2283  if (!rIsPluralRing(currRing)
2285  && (Lp.p->coef!=NULL))
2286  nDelete(&(Lp.p->coef));
2287  }
2288 
2289  l = strat->posInL(strat->B,strat->Bl,&Lp,strat);
2290  enterL(&strat->B,&strat->Bl,&strat->Bmax,Lp,l);
2291  }
2292 }
poly nc_CreateShortSpoly(poly p1, poly p2, const ring r)
Definition: old.gring.cc:1879
@ nc_lie
Definition: nc.h:18
poly nc_p_Bracket_qq(poly p, const poly q, const ring r)
returns [p,q], destroys p
Definition: old.gring.cc:2243
static nc_type & ncRingType(nc_struct *p)
Definition: nc.h:159
#define pSetm(p)
Definition: polys.h:271
#define pHasNotCF(p1, p2)
Definition: polys.h:263
#define pLcm(a, b, m)
Definition: polys.h:295
void pLcmRat(poly a, poly b, poly m, int rat_shift)
Definition: ratgring.cc:30
static BOOLEAN rIsRatGRing(const ring r)
Definition: ring.h:427

◆ enterOnePairRing()

static void enterOnePairRing ( int  i,
poly  p,
int  ,
int  isFromQ,
kStrategy  strat,
int  atR 
)
static

Definition at line 1426 of file kutil.cc.

1427 {
1428  assume(atR >= 0);
1429  assume(i<=strat->sl);
1430  assume(p!=NULL);
1432  #if ALL_VS_JUST
1433  //Over rings, if we construct the strong pair, do not add the spair
1435  {
1436  number s,t,d;
1437  d = n_ExtGcd(pGetCoeff(p), pGetCoeff(strat->S[i]), &s, &t, currRing->cf);
1438 
1439  if (!nIsZero(s) && !nIsZero(t)) // evtl. durch divBy tests ersetzen
1440  {
1441  nDelete(&d);
1442  nDelete(&s);
1443  nDelete(&t);
1444  return;
1445  }
1446  nDelete(&d);
1447  nDelete(&s);
1448  nDelete(&t);
1449  }
1450  #endif
1451  int j,compare,compareCoeff;
1452  LObject h;
1453 
1454 #ifdef KDEBUG
1455  h.ecart=0; h.length=0;
1456 #endif
1457  /*- computes the lcm(s[i],p) -*/
1458  if(pHasNotCFRing(p,strat->S[i]))
1459  {
1460  strat->cp++;
1461  return;
1462  }
1463  h.lcm = p_Lcm(p,strat->S[i],currRing);
1464  pSetCoeff0(h.lcm, n_Lcm(pGetCoeff(p), pGetCoeff(strat->S[i]), currRing->cf));
1465  if (nIsZero(pGetCoeff(h.lcm)))
1466  {
1467  strat->cp++;
1468  pLmDelete(h.lcm);
1469  return;
1470  }
1471  // basic chain criterion
1472  /*
1473  *the set B collects the pairs of type (S[j],p)
1474  *suppose (r,p) is in B and (s,p) is the new pair and lcm(s,p) != lcm(r,p)
1475  *if the leading term of s divides lcm(r,p) then (r,p) will be canceled
1476  *if the leading term of r divides lcm(s,p) then (s,p) will not enter B
1477  */
1478 
1479  for(j = strat->Bl;j>=0;j--)
1480  {
1481  compare=pDivCompRing(strat->B[j].lcm,h.lcm);
1482  compareCoeff = n_DivComp(pGetCoeff(strat->B[j].lcm), pGetCoeff(h.lcm), currRing->cf);
1483  if(compare == pDivComp_EQUAL)
1484  {
1485  //They have the same LM
1486  if(compareCoeff == pDivComp_LESS)
1487  {
1488  if ((strat->fromQ==NULL) || (isFromQ==0) || (strat->fromQ[i]==0))
1489  {
1490  strat->c3++;
1491  pLmDelete(h.lcm);
1492  return;
1493  }
1494  break;
1495  }
1496  if(compareCoeff == pDivComp_GREATER)
1497  {
1498  deleteInL(strat->B,&strat->Bl,j,strat);
1499  strat->c3++;
1500  }
1501  if(compareCoeff == pDivComp_EQUAL)
1502  {
1503  if ((strat->fromQ==NULL) || (isFromQ==0) || (strat->fromQ[i]==0))
1504  {
1505  strat->c3++;
1506  pLmDelete(h.lcm);
1507  return;
1508  }
1509  break;
1510  }
1511  }
1512  if(compareCoeff == compare || compareCoeff == pDivComp_EQUAL)
1513  {
1514  if(compare == pDivComp_LESS)
1515  {
1516  if ((strat->fromQ==NULL) || (isFromQ==0) || (strat->fromQ[i]==0))
1517  {
1518  strat->c3++;
1519  pLmDelete(h.lcm);
1520  return;
1521  }
1522  break;
1523  }
1524  if(compare == pDivComp_GREATER)
1525  {
1526  deleteInL(strat->B,&strat->Bl,j,strat);
1527  strat->c3++;
1528  }
1529  }
1530  }
1531  number s, t;
1532  poly m1, m2, gcd = NULL;
1533  s = pGetCoeff(strat->S[i]);
1534  t = pGetCoeff(p);
1535  k_GetLeadTerms(p,strat->S[i],currRing,m1,m2,currRing);
1536  ksCheckCoeff(&s, &t, currRing->cf);
1537  pSetCoeff0(m1, s);
1538  pSetCoeff0(m2, t);
1539  m2 = pNeg(m2);
1540  p_Test(m1,strat->tailRing);
1541  p_Test(m2,strat->tailRing);
1542  poly si = pCopy(strat->S[i]);
1543  poly pm1 = pp_Mult_mm(pNext(p), m1, strat->tailRing);
1544  poly sim2 = pp_Mult_mm(pNext(si), m2, strat->tailRing);
1545  pDelete(&si);
1546  p_LmDelete(m1, currRing);
1547  p_LmDelete(m2, currRing);
1548  if(sim2 == NULL)
1549  {
1550  if(pm1 == NULL)
1551  {
1552  if(h.lcm != NULL)
1553  {
1554  pLmDelete(h.lcm);
1555  h.lcm=NULL;
1556  }
1557  h.Clear();
1558  if (strat->pairtest==NULL) initPairtest(strat);
1559  strat->pairtest[i] = TRUE;
1560  strat->pairtest[strat->sl+1] = TRUE;
1561  return;
1562  }
1563  else
1564  {
1565  gcd = pm1;
1566  pm1 = NULL;
1567  }
1568  }
1569  else
1570  {
1571  if((pGetComp(strat->S[i]) == 0) && (0 != pGetComp(p)))
1572  {
1573  p_SetCompP(sim2, pGetComp(p), strat->tailRing);
1574  pSetmComp(sim2);
1575  }
1576  //p_Write(pm1,strat->tailRing);p_Write(sim2,strat->tailRing);
1577  gcd = p_Add_q(pm1, sim2, strat->tailRing);
1578  }
1579  p_Test(gcd, strat->tailRing);
1580 #ifdef KDEBUG
1581  if (TEST_OPT_DEBUG)
1582  {
1583  wrp(gcd);
1584  PrintLn();
1585  }
1586 #endif
1587  h.p = gcd;
1588  h.i_r = -1;
1589  if(h.p == NULL)
1590  {
1591  if (strat->pairtest==NULL) initPairtest(strat);
1592  strat->pairtest[i] = TRUE;
1593  strat->pairtest[strat->sl+1] = TRUE;
1594  return;
1595  }
1596  h.tailRing = strat->tailRing;
1597  int posx;
1598  //h.pCleardenom();
1599  //pSetm(h.p);
1600  h.i_r1 = -1;h.i_r2 = -1;
1601  strat->initEcart(&h);
1602  #if 1
1603  h.p2 = strat->S[i];
1604  h.p1 = p;
1605  #endif
1606  #if 1
1607  if (atR >= 0)
1608  {
1609  h.i_r1 = atR;
1610  h.i_r2 = strat->S_2_R[i];
1611  }
1612  #endif
1613  if (strat->Bl==-1)
1614  posx =0;
1615  else
1616  posx = strat->posInL(strat->B,strat->Bl,&h,strat);
1617  h.sev = pGetShortExpVector(h.p);
1618  if (currRing!=strat->tailRing)
1619  h.t_p = k_LmInit_currRing_2_tailRing(h.p, strat->tailRing);
1620  if (strat->P.p!=NULL) strat->P.sev = pGetShortExpVector(strat->P.p);
1621  else strat->P.sev=0L;
1622  enterL(&strat->B,&strat->Bl,&strat->Bmax,h,posx);
1623  kTest_TS(strat);
1624 }
static FORCE_INLINE number n_Lcm(number a, number b, const coeffs r)
in Z: return the lcm of 'a' and 'b' in Z/nZ, Z/2^kZ: computed as in the case Z in Z/pZ,...
Definition: coeffs.h:690
static FORCE_INLINE number n_ExtGcd(number a, number b, number *s, number *t, const coeffs r)
beware that ExtGCD is only relevant for a few chosen coeff. domains and may perform something unexpec...
Definition: coeffs.h:671
static FORCE_INLINE int n_DivComp(number a, number b, const coeffs r)
Definition: coeffs.h:522
const CanonicalForm int s
Definition: facAbsFact.cc:51
KINLINE BOOLEAN k_GetLeadTerms(const poly p1, const poly p2, const ring p_r, poly &m1, poly &m2, const ring m_r)
Definition: kInline.h:1029
int ksCheckCoeff(number *a, number *b)
#define pDivComp_LESS
Definition: kutil.cc:136
BOOLEAN kTest_TS(kStrategy strat)
Definition: kutil.cc:1097
static int pDivCompRing(poly p, poly q)
Definition: kutil.cc:144
#define pDivComp_GREATER
Definition: kutil.cc:137
#define pDivComp_EQUAL
Definition: kutil.cc:135
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:938
static void p_LmDelete(poly p, const ring r)
Definition: p_polys.h:725
static poly pp_Mult_mm(poly p, poly m, const ring r)
Definition: p_polys.h:1033
static void p_SetCompP(poly p, int i, ring r)
Definition: p_polys.h:256
#define pNeg(p)
Definition: polys.h:198
#define pSetmComp(p)
TODO:
Definition: polys.h:273
#define pHasNotCFRing(p1, p2)
Definition: polys.h:262

◆ enterOnePairRingShift()

static void enterOnePairRingShift ( poly  q,
poly  p,
int  ,
int  isFromQ,
kStrategy  strat,
int  atR,
int  ,
int  qisFromQ,
int  shiftcount,
int  ifromS 
)
static

Definition at line 12266 of file kutil.cc.

12267 {
12268  /* assume(atR >= 0); */
12269  /* assume(i<=strat->sl); */
12270  assume(p!=NULL);
12272  assume(pIsInV(p));
12273  #if ALL_VS_JUST
12274  //Over rings, if we construct the strong pair, do not add the spair
12276  {
12277  number s,t,d;
12278  d = n_ExtGcd(pGetCoeff(p), pGetCoeff(q, &s, &t, currRing->cf);
12279 
12280  if (!nIsZero(s) && !nIsZero(t)) // evtl. durch divBy tests ersetzen
12281  {
12282  nDelete(&d);
12283  nDelete(&s);
12284  nDelete(&t);
12285  return;
12286  }
12287  nDelete(&d);
12288  nDelete(&s);
12289  nDelete(&t);
12290  }
12291  #endif
12292  int j,compare,compareCoeff;
12293  LObject h;
12294 
12295 #ifdef KDEBUG
12296  h.ecart=0; h.length=0;
12297 #endif
12298  /*- computes the lcm(s[i],p) -*/
12299  if(pHasNotCFRing(p,q))
12300  {
12301  strat->cp++;
12302  return;
12303  }
12304  h.lcm = p_Lcm(p,q,currRing);
12305  pSetCoeff0(h.lcm, n_Lcm(pGetCoeff(p), pGetCoeff(q), currRing->cf));
12306  if (nIsZero(pGetCoeff(h.lcm)))
12307  {
12308  strat->cp++;
12309  pLmDelete(h.lcm);
12310  return;
12311  }
12312 
12313  /* the V criterion */
12314  if (!pmIsInV(h.lcm))
12315  {
12316  strat->cv++;
12317  pLmDelete(h.lcm);
12318  return;
12319  }
12320  // basic chain criterion
12321  /*
12322  *the set B collects the pairs of type (S[j],p)
12323  *suppose (r,p) is in B and (s,p) is the new pair and lcm(s,p) != lcm(r,p)
12324  *if the leading term of s divides lcm(r,p) then (r,p) will be canceled
12325  *if the leading term of r divides lcm(s,p) then (s,p) will not enter B
12326  */
12327 
12328  for(j = strat->Bl;j>=0;j--)
12329  {
12330  compare=pDivCompRing(strat->B[j].lcm,h.lcm);
12331  compareCoeff = n_DivComp(pGetCoeff(strat->B[j].lcm), pGetCoeff(h.lcm), currRing->cf);
12332  if(compare == pDivComp_EQUAL)
12333  {
12334  //They have the same LM
12335  if(compareCoeff == pDivComp_LESS)
12336  {
12337  if ((strat->fromQ==NULL) || (isFromQ==0) || (qisFromQ==0))
12338  {
12339  strat->c3++;
12340  pLmDelete(h.lcm);
12341  return;
12342  }
12343  break;
12344  }
12345  if(compareCoeff == pDivComp_GREATER)
12346  {
12347  deleteInL(strat->B,&strat->Bl,j,strat);
12348  strat->c3++;
12349  }
12350  if(compareCoeff == pDivComp_EQUAL)
12351  {
12352  if ((strat->fromQ==NULL) || (isFromQ==0) || (qisFromQ==0))
12353  {
12354  strat->c3++;
12355  pLmDelete(h.lcm);
12356  return;
12357  }
12358  break;
12359  }
12360  }
12361  if(compareCoeff == compare || compareCoeff == pDivComp_EQUAL)
12362  {
12363  if(compare == pDivComp_LESS)
12364  {
12365  if ((strat->fromQ==NULL) || (isFromQ==0) || (qisFromQ==0))
12366  {
12367  strat->c3++;
12368  pLmDelete(h.lcm);
12369  return;
12370  }
12371  break;
12372  }
12373  if(compare == pDivComp_GREATER)
12374  {
12375  deleteInL(strat->B,&strat->Bl,j,strat);
12376  strat->c3++;
12377  }
12378  }
12379  }
12380  number s, t;
12381  poly m1, m2, gcd = NULL;
12382  s = pGetCoeff(q);
12383  t = pGetCoeff(p);
12384  k_GetLeadTerms(p,q,currRing,m1,m2,currRing);
12385 
12386  poly m12, m22;
12387  assume(p_mFirstVblock(p, currRing) <= 1 || p_mFirstVblock(q, currRing) <= 1);
12389  k_SplitFrame(m2, m22, si_max(p_mFirstVblock(q, currRing), 1), currRing);
12390  // manually free the coeffs, because pSetCoeff0 is used in the next step
12391  n_Delete(&(m1->coef), currRing->cf);
12392  n_Delete(&(m2->coef), currRing->cf);
12393 
12394  ksCheckCoeff(&s, &t, currRing->cf);
12395  pSetCoeff0(m1, s);
12396  pSetCoeff0(m2, t);
12397  m2 = pNeg(m2);
12398  p_Test(m1,strat->tailRing);
12399  p_Test(m2,strat->tailRing);
12400  p_Test(m12,strat->tailRing);
12401  p_Test(m22,strat->tailRing);
12402  assume(pmIsInV(m1));
12403  assume(pmIsInV(m2));
12404  assume(pmIsInV(m12));
12405  assume(pmIsInV(m22));
12406  poly pm1 = pp_Mult_mm(pp_mm_Mult(pNext(p), m1, strat->tailRing), m12, strat->tailRing);
12407  poly sim2 = pp_Mult_mm(pp_mm_Mult(pNext(q), m2, strat->tailRing), m22, strat->tailRing);
12408  assume(pIsInV(pm1));
12409  assume(pIsInV(sim2));
12410  p_LmDelete(m1, currRing);
12411  p_LmDelete(m2, currRing);
12412  p_LmDelete(m12, currRing);
12413  p_LmDelete(m22, currRing);
12414  if(sim2 == NULL)
12415  {
12416  if(pm1 == NULL)
12417  {
12418  if(h.lcm != NULL)
12419  {
12420  pLmDelete(h.lcm);
12421  h.lcm=NULL;
12422  }
12423  h.Clear();
12424  /* TEMPORARILY DISABLED FOR SHIFTS because there is no i*/
12425  /* if (strat->pairtest==NULL) initPairtest(strat); */
12426  /* strat->pairtest[i] = TRUE; */
12427  /* strat->pairtest[strat->sl+1] = TRUE; */
12428  return;
12429  }
12430  else
12431  {
12432  gcd = pm1;
12433  pm1 = NULL;
12434  }
12435  }
12436  else
12437  {
12438  if((pGetComp(q) == 0) && (0 != pGetComp(p)))
12439  {
12440  p_SetCompP(sim2, pGetComp(p), strat->tailRing);
12441  pSetmComp(sim2);
12442  }
12443  //p_Write(pm1,strat->tailRing);p_Write(sim2,strat->tailRing);
12444  gcd = p_Add_q(pm1, sim2, strat->tailRing);
12445  }
12446  p_Test(gcd, strat->tailRing);
12447  assume(pIsInV(gcd));
12448 #ifdef KDEBUG
12449  if (TEST_OPT_DEBUG)
12450  {
12451  wrp(gcd);
12452  PrintLn();
12453  }
12454 #endif
12455  h.p = gcd;
12456  h.i_r = -1;
12457  if(h.p == NULL)
12458  {
12459  /* TEMPORARILY DISABLED FOR SHIFTS because there is no i*/
12460  /* if (strat->pairtest==NULL) initPairtest(strat); */
12461  /* strat->pairtest[i] = TRUE; */
12462  /* strat->pairtest[strat->sl+1] = TRUE; */
12463  return;
12464  }
12465  h.tailRing = strat->tailRing;
12466  int posx;
12467  //h.pCleardenom();
12468  //pSetm(h.p);
12469  h.i_r1 = -1;h.i_r2 = -1;
12470  strat->initEcart(&h);
12471  #if 1
12472  h.p1 = p;
12473  h.p2 = q;
12474  #endif
12475  #if 1
12476  /* TEMPORARILY DISABLED FOR SHIFTS because there's no i*/
12477  /* at the beginning we DO NOT set atR = -1 ANYMORE*/
12478  if (atR >= 0 && shiftcount == 0 && ifromS >= 0)
12479  {
12480  h.i_r2 = kFindInT(h.p1, strat); //strat->S_2_R[i];
12481  h.i_r1 = atR;
12482  }
12483  else
12484  {
12485  /* END _ TEMPORARILY DISABLED FOR SHIFTS */
12486  h.i_r1 = -1;
12487  h.i_r2 = -1;
12488  }
12489  #endif
12490  if (strat->Bl==-1)
12491  posx =0;
12492  else
12493  posx = strat->posInL(strat->B,strat->Bl,&h,strat);
12494  h.sev = pGetShortExpVector(h.p);
12495  if (currRing!=strat->tailRing)
12496  h.t_p = k_LmInit_currRing_2_tailRing(h.p, strat->tailRing);
12497 
12498  assume(pIsInV(h.p));
12499  assume(pIsInV(h.p1));
12500  assume(h.lcm != NULL);
12501  assume(pIsInV(h.lcm));
12502 
12503  enterL(&strat->B,&strat->Bl,&strat->Bmax,h,posx);
12504  kTest_TS(strat);
12505 }
int cv
Definition: kutil.h:368
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition: coeffs.h:455
if(!FE_OPT_NO_SHELL_FLAG)(void) system(sys)
static poly pp_mm_Mult(poly p, poly m, const ring r)
Definition: p_polys.h:1043
int p_mFirstVblock(poly p, const ring ri)
Definition: shiftop.cc:478
void k_SplitFrame(poly &m1, poly &m2, int at, const ring r)
Definition: shiftop.cc:600
#define pIsInV(p)
Definition: shiftop.h:50
#define pmIsInV(p)
Definition: shiftop.h:51

◆ enterOnePairShift()

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

Definition at line 12625 of file kutil.cc.

12626 {
12627 #ifdef CRITERION_DEBUG
12628  if (TEST_OPT_DEBUG)
12629  {
12630  PrintS("Consider pair ("); wrp(q); PrintS(", "); wrp(p); PrintS(")"); PrintLn();
12631  // also write the LMs in separate lines:
12632  poly lmq = pHead(q);
12633  poly lmp = pHead(p);
12634  pSetCoeff(lmq, n_Init(1, currRing->cf));
12635  pSetCoeff(lmp, n_Init(1, currRing->cf));
12636  Print(" %s\n", pString(lmq));
12637  Print(" %s\n", pString(lmp));
12638  pLmDelete(lmq);
12639  pLmDelete(lmp);
12640  }
12641 #endif
12642 
12643  /* Format: q and p are like strat->P.p, so lm in CR, tail in TR */
12644 
12645  /* check this Formats: */
12647  assume(p_CheckIsFromRing(pNext(q),strat->tailRing));
12650 
12651  /* poly q stays for s[i], ecartq = ecart(q), qisFromQ = applies to q */
12652 
12653  int qfromQ = qisFromQ;
12654 
12655  /* need additionally: int up_to_degree, poly V0 with the variables in (0) or just the number lV = the length of the first block */
12656 
12657  int l,j,compare;
12658  LObject Lp;
12659  Lp.i_r = -1;
12660 
12661 #ifdef KDEBUG
12662  Lp.ecart=0; Lp.length=0;
12663 #endif
12664  /*- computes the lcm(s[i],p) -*/
12665  Lp.lcm = p_Lcm(p,q, currRing); // q is what was strat->S[i], so a poly in LM/TR presentation
12666 
12667  /* the V criterion */
12668  if (!pmIsInV(Lp.lcm))
12669  {
12670  strat->cv++; // counter for applying the V criterion
12671  pLmFree(Lp.lcm);
12672 #ifdef CRITERION_DEBUG
12673  if (TEST_OPT_DEBUG) PrintS("--- V crit\n");
12674 #endif
12675  return TRUE;
12676  }
12677 
12678  if (strat->sugarCrit && ALLOW_PROD_CRIT(strat))
12679  {
12680  if((!((ecartq>0)&&(ecart>0)))
12681  && pHasNotCF(p,q))
12682  {
12683  /*
12684  *the product criterion has applied for (s,p),
12685  *i.e. lcm(s,p)=product of the leading terms of s and p.
12686  *Suppose (s,r) is in L and the leading term
12687  *of p divides lcm(s,r)
12688  *(==> the leading term of p divides the leading term of r)
12689  *but the leading term of s does not divide the leading term of r
12690  *(notice that this condition is automatically satisfied if r is still
12691  *in S), then (s,r) can be cancelled.
12692  *This should be done here because the
12693  *case lcm(s,r)=lcm(s,p) is not covered by chainCrit.
12694  *
12695  *Moreover, skipping (s,r) holds also for the noncommutative case.
12696  */
12697  strat->cp++;
12698  pLmFree(Lp.lcm);
12699 #ifdef CRITERION_DEBUG
12700  if (TEST_OPT_DEBUG) PrintS("--- prod crit\n");
12701 #endif
12702  return TRUE;
12703  }
12704  else
12705  Lp.ecart = si_max(ecart,ecartq);
12706  if (strat->fromT && (ecartq>ecart))
12707  {
12708  pLmFree(Lp.lcm);
12709 #ifdef CRITERION_DEBUG
12710  if (TEST_OPT_DEBUG) PrintS("--- ecartq > ecart\n");
12711 #endif
12712  return TRUE;
12713  /*the pair is (s[i],t[.]), discard it if the ecart is too big*/
12714  }
12715  /*
12716  *the set B collects the pairs of type (S[j],p)
12717  *suppose (r,p) is in B and (s,p) is the new pair and lcm(s,p)#lcm(r,p)
12718  *if the leading term of s divides lcm(r,p) then (r,p) will be canceled
12719  *if the leading term of r divides lcm(s,p) then (s,p) will not enter B
12720  */
12721  {
12722  j = strat->Bl;
12723  loop
12724  {
12725  if (j < 0) break;
12726  compare=pLPDivComp(strat->B[j].lcm,Lp.lcm);
12727  if ((compare==1)
12728  &&(sugarDivisibleBy(strat->B[j].ecart,Lp.ecart)))
12729  {
12730  strat->c3++;
12731  if ((strat->fromQ==NULL) || (isFromQ==0) || (qfromQ==0))
12732  {
12733  pLmFree(Lp.lcm);
12734 #ifdef CRITERION_DEBUG
12735  if (TEST_OPT_DEBUG)
12736  {
12737  Print("--- chain crit using B[%d].lcm=%s\n", j, pString(strat->B[j].lcm));
12738  }
12739 #endif
12740  return TRUE;
12741  }
12742  break;
12743  }
12744  else
12745  if ((compare ==-1)
12746  && sugarDivisibleBy(Lp.ecart,strat->B[j].ecart))
12747  {
12748 #ifdef CRITERION_DEBUG
12749  if (TEST_OPT_DEBUG)
12750  {
12751  Print("--- chain crit using pair to remove B[%d].lcm=%s\n", j, pString(strat->B[j].lcm));
12752  }
12753 #endif
12754  deleteInL(strat->B,&strat->Bl,j,strat);
12755  strat->c3++;
12756  }
12757  j--;
12758  }
12759  }
12760  }
12761  else /*sugarcrit*/
12762  {
12763  if (ALLOW_PROD_CRIT(strat))
12764  {
12765  // if currRing->nc_type!=quasi (or skew)
12766  // TODO: enable productCrit for super commutative algebras...
12767  if(/*(strat->ak==0) && productCrit(p,strat->S[i])*/
12768  pHasNotCF(p,q))
12769  {
12770  /*
12771  *the product criterion has applied for (s,p),
12772  *i.e. lcm(s,p)=product of the leading terms of s and p.
12773  *Suppose (s,r) is in L and the leading term
12774  *of p divides lcm(s,r)
12775  *(==> the leading term of p divides the leading term of r)
12776  *but the leading term of s does not divide the leading term of r
12777  *(notice that tis condition is automatically satisfied if r is still
12778  *in S), then (s,r) can be canceled.
12779  *This should be done here because the
12780  *case lcm(s,r)=lcm(s,p) is not covered by chainCrit.
12781  */
12782  strat->cp++;
12783  pLmFree(Lp.lcm);
12784 #ifdef CRITERION_DEBUG
12785  if (TEST_OPT_DEBUG) PrintS("--- prod crit\n");
12786 #endif
12787  return TRUE;
12788  }
12789  if (strat->fromT && (ecartq>ecart))
12790  {
12791  pLmFree(Lp.lcm);
12792 #ifdef CRITERION_DEBUG
12793  if (TEST_OPT_DEBUG) PrintS("--- ecartq > ecart\n");
12794 #endif
12795  return TRUE;
12796  /*the pair is (s[i],t[.]), discard it if the ecart is too big*/
12797  }
12798  /*
12799  *the set B collects the pairs of type (S[j],p)
12800  *suppose (r,p) is in B and (s,p) is the new pair and lcm(s,p)#lcm(r,p)
12801  *if the leading term of s divides lcm(r,p) then (r,p) will be canceled
12802  *if the leading term of r divides lcm(s,p) then (s,p) will not enter B
12803  */
12804  for(j = strat->Bl;j>=0;j--)
12805  {
12806  compare=pLPDivComp(strat->B[j].lcm,Lp.lcm);
12807  if (compare==1)
12808  {
12809  strat->c3++;
12810  if ((strat->fromQ==NULL) || (isFromQ==0) || (qfromQ==0))
12811  {
12812  pLmFree(Lp.lcm);
12813 #ifdef CRITERION_DEBUG
12814  if (TEST_OPT_DEBUG)
12815  {
12816  Print("--- chain crit using B[%d].lcm=%s\n", j, pString(strat->B[j].lcm));
12817  }
12818 #endif
12819  return TRUE;
12820  }
12821  break;
12822  }
12823  else
12824  if (compare ==-1)
12825  {
12826 #ifdef CRITERION_DEBUG
12827  if (TEST_OPT_DEBUG)
12828  {
12829  Print("--- chain crit using pair to remove B[%d].lcm=%s\n", j, pString(strat->B[j].lcm));
12830  }
12831 #endif
12832  deleteInL(strat->B,&strat->Bl,j,strat);
12833  strat->c3++;
12834  }
12835  }
12836  }
12837  }
12838  /*
12839  *the pair (S[i],p) enters B if the spoly != 0
12840  */
12841  /*- compute the short s-polynomial -*/
12842  if (strat->fromT && !TEST_OPT_INTSTRATEGY)
12843  pNorm(p);
12844  if ((q==NULL) || (p==NULL))
12845  {
12846 #ifdef CRITERION_DEBUG
12847  if (TEST_OPT_DEBUG) PrintS("--- q == NULL || p == NULL\n");
12848 #endif
12849  return FALSE;
12850  }
12851  if ((strat->fromQ!=NULL) && (isFromQ!=0) && (qfromQ!=0))
12852  {
12853  Lp.p=NULL;
12854 #ifdef CRITERION_DEBUG
12855  if (TEST_OPT_DEBUG) PrintS("--- pair is from Q\n");
12856 #endif
12857  }
12858  else
12859  {
12860 // if ( rIsPluralRing(currRing) )
12861 // {
12862 // if(pHasNotCF(p, q))
12863 // {
12864 // if(ncRingType(currRing) == nc_lie)
12865 // {
12866 // // generalized prod-crit for lie-type
12867 // strat->cp++;
12868 // Lp.p = nc_p_Bracket_qq(pCopy(p),q, currRing);
12869 // }
12870 // else
12871 // if( ALLOW_PROD_CRIT(strat) )
12872 // {
12873 // // product criterion for homogeneous case in SCA
12874 // strat->cp++;
12875 // Lp.p = NULL;
12876 // }
12877 // else
12878 // Lp.p = nc_CreateSpoly(q,p,currRing); // ?
12879 // }
12880 // else Lp.p = nc_CreateSpoly(q,p,currRing);
12881 // }
12882 // else
12883 // {
12884 
12885  /* ksCreateShortSpoly needs two Lobject-kind presentations */
12886  /* p is already in this form, so convert q */
12887  // q = pMove2CurrTail(q, strat);
12888  Lp.p = ksCreateShortSpoly(q, p, strat->tailRing);
12889  // }
12890  }
12891  if (Lp.p == NULL)
12892  {
12893  /*- the case that the s-poly is 0 -*/
12894  // TODO: currently ifromS is only > 0 if called from enterOnePairWithShifts
12895  if (ifromS > 0)
12896  {
12897  if (strat->pairtest==NULL) initPairtest(strat);
12898  strat->pairtest[ifromS] = TRUE;/*- hint for spoly(S^[i],p)=0 -*/
12899  strat->pairtest[strat->sl+1] = TRUE;
12900  }
12901  //if (TEST_OPT_DEBUG){Print("!");} // option teach
12902  /* END _ TEMPORARILY DISABLED FOR SHIFTS */
12903  /*hint for spoly(S[i],p) == 0 for some i,0 <= i <= sl*/
12904  /*
12905  *suppose we have (s,r),(r,p),(s,p) and spoly(s,p) == 0 and (r,p) is
12906  *still in B (i.e. lcm(r,p) == lcm(s,p) or the leading term of s does not
12907  *divide lcm(r,p)). In the last case (s,r) can be canceled if the leading
12908  *term of p divides the lcm(s,r)
12909  *(this canceling should be done here because
12910  *the case lcm(s,p) == lcm(s,r) is not covered in chainCrit)
12911  *the first case is handeled in chainCrit
12912  */
12913  if (Lp.lcm!=NULL) pLmFree(Lp.lcm);
12914 #ifdef CRITERION_DEBUG
12915  if (TEST_OPT_DEBUG) PrintS("--- S-poly = 0\n");
12916 #endif
12917  return TRUE;
12918  }
12919  else
12920  {
12921  /*- the pair (S[i],p) enters B -*/
12922  /* both of them should have their LM in currRing and TAIL in tailring */
12923  Lp.p1 = q; // already in the needed form
12924  Lp.p2 = p; // already in the needed form
12925 
12926  if ( !rIsPluralRing(currRing) )
12927  pNext(Lp.p) = strat->tail;
12928 
12929  /* TEMPORARILY DISABLED FOR SHIFTS because there's no i*/
12930  /* at the beginning we DO NOT set atR = -1 ANYMORE*/
12931  if ( (atR >= 0) && (shiftcount==0) && (ifromS >=0) )
12932  {
12933  Lp.i_r1 = kFindInT(Lp.p1,strat); //strat->S_2_R[ifromS];
12934  Lp.i_r2 = atR;
12935  }
12936  else
12937  {
12938  /* END _ TEMPORARILY DISABLED FOR SHIFTS */
12939  Lp.i_r1 = -1;
12940  Lp.i_r2 = -1;
12941  }
12942  strat->initEcartPair(&Lp,q,p,ecartq,ecart);
12943 
12945  {
12946  if (!rIsPluralRing(currRing)
12948  && (Lp.p->coef!=NULL))
12949  nDelete(&(Lp.p->coef));
12950  }
12951 
12952  l = strat->posInL(strat->B,strat->Bl,&Lp,strat);
12953  enterL(&strat->B,&strat->Bl,&strat->Bmax,Lp,l);
12954 #ifdef CRITERION_DEBUG
12955  if (TEST_OPT_DEBUG) PrintS("+++ Entered pair\n");
12956 #endif
12957  }
12958  return FALSE;
12959 }
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
Definition: coeffs.h:538
static int pLPDivComp(poly p, poly q)
Definition: kutil.cc:232
BOOLEAN p_CheckIsFromRing(poly p, ring r)
Definition: pDebug.cc:102
BOOLEAN p_LmCheckIsFromRing(poly p, ring r)
Definition: pDebug.cc:71
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL
Definition: polys.h:67
char * pString(poly p)
Definition: polys.h:306

◆ enterOnePairSig()

static void enterOnePairSig ( int  i,
poly  p,
poly  pSig,
int  ,
int  ecart,
int  isFromQ,
kStrategy  strat,
int  atR = -1 
)
static

Definition at line 2526 of file kutil.cc.

2528 {
2529  assume(i<=strat->sl);
2530 
2531  int l;
2532  poly m1 = NULL,m2 = NULL; // we need the multipliers for the s-polynomial to compute
2533  // the corresponding signatures for criteria checks
2534  LObject Lp;
2535  poly pSigMult = p_Copy(pSig,currRing);
2536  poly sSigMult = p_Copy(strat->sig[i],currRing);
2537  unsigned long pSigMultNegSev,sSigMultNegSev;
2538  Lp.i_r = -1;
2539 
2540 #ifdef KDEBUG
2541  Lp.ecart=0; Lp.length=0;
2542 #endif
2543  /*- computes the lcm(s[i],p) -*/
2544  Lp.lcm = pInit();
2545  k_GetLeadTerms(p,strat->S[i],currRing,m1,m2,currRing);
2546 #ifndef HAVE_RATGRING
2547  pLcm(p,strat->S[i],Lp.lcm);
2548 #elif defined(HAVE_RATGRING)
2549  if (rIsRatGRing(currRing))
2550  pLcmRat(p,strat->S[i],Lp.lcm, currRing->real_var_start); // int rat_shift
2551  else
2552  pLcm(p,strat->S[i],Lp.lcm);
2553 #endif
2554  pSetm(Lp.lcm);
2555 
2556  // set coeffs of multipliers m1 and m2
2557  pSetCoeff0(m1, nInit(1));
2558  pSetCoeff0(m2, nInit(1));
2559 //#if 1
2560 #ifdef DEBUGF5
2561  PrintS("P1 ");
2562  pWrite(pHead(p));
2563  PrintS("P2 ");
2564  pWrite(pHead(strat->S[i]));
2565  PrintS("M1 ");
2566  pWrite(m1);
2567  PrintS("M2 ");
2568  pWrite(m2);
2569 #endif
2570  // get multiplied signatures for testing
2571  pSigMult = currRing->p_Procs->pp_Mult_mm(pSigMult,m1,currRing);
2572  pSigMultNegSev = ~p_GetShortExpVector(pSigMult,currRing);
2573  sSigMult = currRing->p_Procs->pp_Mult_mm(sSigMult,m2,currRing);
2574  sSigMultNegSev = ~p_GetShortExpVector(sSigMult,currRing);
2575 
2576 //#if 1
2577 #ifdef DEBUGF5
2578  PrintS("----------------\n");
2579  pWrite(pSigMult);
2580  pWrite(sSigMult);
2581  PrintS("----------------\n");
2582  Lp.checked = 0;
2583 #endif
2584  int sigCmp = p_LmCmp(pSigMult,sSigMult,currRing);
2585 //#if 1
2586 #if DEBUGF5
2587  Print("IN PAIR GENERATION - COMPARING SIGS: %d\n",sigCmp);
2588  pWrite(pSigMult);
2589  pWrite(sSigMult);
2590 #endif
2591  if(sigCmp==0)
2592  {
2593  // printf("!!!! EQUAL SIGS !!!!\n");
2594  // pSig = sSig, delete element due to Rewritten Criterion
2595  pDelete(&pSigMult);
2596  pDelete(&sSigMult);
2597  if (rField_is_Ring(currRing))
2598  pLmDelete(Lp.lcm);
2599  else
2600  pLmFree(Lp.lcm);
2601  pDelete (&m1);
2602  pDelete (&m2);
2603  return;
2604  }
2605  // testing by syzCrit = F5 Criterion
2606  // testing by rewCrit1 = Rewritten Criterion
2607  // NOTE: Arri's Rewritten Criterion is tested below, we need Lp.p for it!
2608  if ( strat->syzCrit(pSigMult,pSigMultNegSev,strat) ||
2609  strat->syzCrit(sSigMult,sSigMultNegSev,strat)
2610  || strat->rewCrit1(sSigMult,sSigMultNegSev,Lp.lcm,strat,i+1)
2611  )
2612  {
2613  pDelete(&pSigMult);
2614  pDelete(&sSigMult);
2615  if (rField_is_Ring(currRing))
2616  pLmDelete(Lp.lcm);
2617  else
2618  pLmFree(Lp.lcm);
2619  pDelete (&m1);
2620  pDelete (&m2);
2621  return;
2622  }
2623  /*
2624  *the pair (S[i],p) enters B if the spoly != 0
2625  */
2626  /*- compute the short s-polynomial -*/
2627  if (strat->fromT && !TEST_OPT_INTSTRATEGY)
2628  pNorm(p);
2629 
2630  if ((strat->S[i]==NULL) || (p==NULL))
2631  return;
2632 
2633  if ((strat->fromQ!=NULL) && (isFromQ!=0) && (strat->fromQ[i]!=0))
2634  Lp.p=NULL;
2635  else
2636  {
2637  #ifdef HAVE_PLURAL
2638  if ( rIsPluralRing(currRing) )
2639  {
2640  if(pHasNotCF(p, strat->S[i]))
2641  {
2642  if(ncRingType(currRing) == nc_lie)
2643  {
2644  // generalized prod-crit for lie-type
2645  strat->cp++;
2646  Lp.p = nc_p_Bracket_qq(pCopy(p),strat->S[i], currRing);
2647  }
2648  else
2649  if( ALLOW_PROD_CRIT(strat) )
2650  {
2651  // product criterion for homogeneous case in SCA
2652  strat->cp++;
2653  Lp.p = NULL;
2654  }
2655  else
2656  {
2657  Lp.p = // nc_CreateSpoly(strat->S[i],p,currRing);
2658  nc_CreateShortSpoly(strat->S[i], p, currRing);
2659 
2660  assume(pNext(Lp.p)==NULL); // TODO: this may be violated whenever ext.prod.crit. for Lie alg. is used
2661  pNext(Lp.p) = strat->tail; // !!!
2662  }
2663  }
2664  else
2665  {
2666  Lp.p = // nc_CreateSpoly(strat->S[i],p,currRing);
2667  nc_CreateShortSpoly(strat->S[i], p, currRing);
2668 
2669  assume(pNext(Lp.p)==NULL); // TODO: this may be violated whenever ext.prod.crit. for Lie alg. is used
2670  pNext(Lp.p) = strat->tail; // !!!
2671  }
2672  }
2673  else
2674  #endif
2675  {
2677  Lp.p = ksCreateShortSpoly(strat->S[i], p, strat->tailRing);
2678  }
2679  }
2680  // store from which element this pair comes from for further tests
2681  //Lp.from = strat->sl+1;
2682  if(sigCmp==currRing->OrdSgn)
2683  {
2684  // pSig > sSig
2685  pDelete (&sSigMult);
2686  Lp.sig = pSigMult;
2687  Lp.sevSig = ~pSigMultNegSev;
2688  }
2689  else
2690  {
2691  // pSig < sSig
2692  pDelete (&pSigMult);
2693  Lp.sig = sSigMult;
2694  Lp.sevSig = ~sSigMultNegSev;
2695  }
2696  if (Lp.p == NULL)
2697  {
2698  if (Lp.lcm!=NULL) pLmFree(Lp.lcm);
2699  int pos = posInSyz(strat, Lp.sig);
2700  enterSyz(Lp, strat, pos);
2701  }
2702  else
2703  {
2704  // testing by rewCrit3 = Arris Rewritten Criterion (for F5 nothing happens!)
2705  if (strat->rewCrit3(Lp.sig,~Lp.sevSig,Lp.p,strat,strat->sl+1))
2706  {
2707  pLmFree(Lp.lcm);
2708  pDelete(&Lp.sig);
2709  pDelete (&m1);
2710  pDelete (&m2);
2711  return;
2712  }
2713  // in any case Lp is checked up to the next strat->P which is added
2714  // to S right after this critical pair creation.
2715  // NOTE: this even holds if the 2nd generator gives the bigger signature
2716  // moreover, this improves rewCriterion,
2717  // i.e. strat->checked > strat->from if and only if the 2nd generator
2718  // gives the bigger signature.
2719  Lp.checked = strat->sl+1;
2720  // at this point it is clear that the pair will be added to L, since it has
2721  // passed all tests up to now
2722 
2723  // adds buchberger's first criterion
2724  if (pLmCmp(m2,pHead(p)) == 0)
2725  {
2726  Lp.prod_crit = TRUE; // Product Criterion
2727 #if 0
2728  int pos = posInSyz(strat, Lp.sig);
2729  enterSyz(Lp, strat, pos);
2730  pDelete (&m1);
2731  pDelete (&m2);
2732  return;
2733 #endif
2734  }
2735  pDelete (&m1);
2736  pDelete (&m2);
2737 #if DEBUGF5
2738  PrintS("SIGNATURE OF PAIR: ");
2739  pWrite(Lp.sig);
2740 #endif
2741  /*- the pair (S[i],p) enters B -*/
2742  Lp.p1 = strat->S[i];
2743  Lp.p2 = p;
2744 
2745  if (
2747 // || (rIsPluralRing(currRing) && (ncRingType(currRing) != nc_lie))
2748  )
2749  {
2750  assume(pNext(Lp.p)==NULL); // TODO: this may be violated whenever ext.prod.crit. for Lie alg. is used
2751  pNext(Lp.p) = strat->tail; // !!!
2752  }
2753 
2754  if (atR >= 0)
2755  {
2756  Lp.i_r1 = strat->S_2_R[i];
2757  Lp.i_r2 = atR;
2758  }
2759  else
2760  {
2761  Lp.i_r1 = -1;
2762  Lp.i_r2 = -1;
2763  }
2764  strat->initEcartPair(&Lp,strat->S[i],p,strat->ecartS[i],ecart);
2765 
2767  {
2768  if (!rIsPluralRing(currRing)
2770  && (Lp.p->coef!=NULL))
2771  nDelete(&(Lp.p->coef));
2772  }
2773 
2774  l = strat->posInLSba(strat->B,strat->Bl,&Lp,strat);
2775  enterL(&strat->B,&strat->Bl,&strat->Bmax,Lp,l);
2776  }
2777 }
BOOLEAN(* rewCrit1)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.h:293
BOOLEAN(* rewCrit3)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.h:295
BOOLEAN(* syzCrit)(poly sig, unsigned long not_sevSig, kStrategy strat)
Definition: kutil.h:292
void enterSyz(LObject &p, kStrategy strat, int atT)
Definition: kutil.cc:9652
int posInSyz(const kStrategy strat, poly sig)
Definition: kutil.cc:6018
unsigned long p_GetShortExpVector(const poly p, const ring r)
Definition: p_polys.cc:4897
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition: p_polys.h:848

◆ enterOnePairSigRing()

static void enterOnePairSigRing ( int  i,
poly  p,
poly  pSig,
int  ,
int  ecart,
int  isFromQ,
kStrategy  strat,
int  atR = -1 
)
static

Definition at line 2783 of file kutil.cc.

2785 {
2786  #if ALL_VS_JUST
2787  //Over rings, if we construct the strong pair, do not add the spair
2789  {
2790  number s,t,d;
2791  d = n_ExtGcd(pGetCoeff(p), pGetCoeff(strat->S[i]), &s, &t, currRing->cf);
2792 
2793  if (!nIsZero(s) && !nIsZero(t)) // evtl. durch divBy tests ersetzen
2794  {
2795  nDelete(&d);
2796  nDelete(&s);
2797  nDelete(&t);
2798  return;
2799  }
2800  nDelete(&d);
2801  nDelete(&s);
2802  nDelete(&t);
2803  }
2804  #endif
2805  assume(i<=strat->sl);
2806  int l;
2807  poly m1 = NULL,m2 = NULL; // we need the multipliers for the s-polynomial to compute
2808  // the corresponding signatures for criteria checks
2809  LObject Lp;
2810  poly pSigMult = p_Copy(pSig,currRing);
2811  poly sSigMult = p_Copy(strat->sig[i],currRing);
2812  unsigned long pSigMultNegSev,sSigMultNegSev;
2813  Lp.i_r = -1;
2814 
2815 #ifdef KDEBUG
2816  Lp.ecart=0; Lp.length=0;
2817 #endif
2818  /*- computes the lcm(s[i],p) -*/
2819  Lp.lcm = pInit();
2820  k_GetLeadTerms(p,strat->S[i],currRing,m1,m2,currRing);
2821 #ifndef HAVE_RATGRING
2822  pLcm(p,strat->S[i],Lp.lcm);
2823 #elif defined(HAVE_RATGRING)
2824  if (rIsRatGRing(currRing))
2825  pLcmRat(p,strat->S[i],Lp.lcm, currRing->real_var_start); // int rat_shift
2826  else
2827  pLcm(p,strat->S[i],Lp.lcm);
2828 #endif
2829  pSetm(Lp.lcm);
2830 
2831  // set coeffs of multipliers m1 and m2
2833  {
2834  number s = nCopy(pGetCoeff(strat->S[i]));
2835  number t = nCopy(pGetCoeff(p));
2836  pSetCoeff0(Lp.lcm, n_Lcm(s, t, currRing->cf));
2837  ksCheckCoeff(&s, &t, currRing->cf);
2838  pSetCoeff0(m1,s);
2839  pSetCoeff0(m2,t);
2840  }
2841  else
2842  {
2843  pSetCoeff0(m1, nInit(1));
2844  pSetCoeff0(m2, nInit(1));
2845  }
2846 #ifdef DEBUGF5
2847  Print("P1 ");
2848  pWrite(pHead(p));
2849  Print("P2 ");
2850  pWrite(pHead(strat->S[i]));
2851  Print("M1 ");
2852  pWrite(m1);
2853  Print("M2 ");
2854  pWrite(m2);
2855 #endif
2856 
2857  // get multiplied signatures for testing
2858  pSigMult = pp_Mult_mm(pSigMult,m1,currRing);
2859  if(pSigMult != NULL)
2860  pSigMultNegSev = ~p_GetShortExpVector(pSigMult,currRing);
2861  sSigMult = pp_Mult_mm(sSigMult,m2,currRing);
2862  if(sSigMult != NULL)
2863  sSigMultNegSev = ~p_GetShortExpVector(sSigMult,currRing);
2864 //#if 1
2865 #ifdef DEBUGF5
2866  Print("----------------\n");
2867  pWrite(pSigMult);
2868  pWrite(sSigMult);
2869  Print("----------------\n");
2870  Lp.checked = 0;
2871 #endif
2872  int sigCmp;
2873  if(pSigMult != NULL && sSigMult != NULL)
2874  {
2876  sigCmp = p_LtCmpNoAbs(pSigMult,sSigMult,currRing);
2877  else
2878  sigCmp = p_LmCmp(pSigMult,sSigMult,currRing);
2879  }
2880  else
2881  {
2882  if(pSigMult == NULL)
2883  {
2884  if(sSigMult == NULL)
2885  sigCmp = 0;
2886  else
2887  sigCmp = -1;
2888  }
2889  else
2890  sigCmp = 1;
2891  }
2892 //#if 1
2893 #if DEBUGF5
2894  Print("IN PAIR GENERATION - COMPARING SIGS: %d\n",sigCmp);
2895  pWrite(pSigMult);
2896  pWrite(sSigMult);
2897 #endif
2898  //In the ring case we already build the sig
2900  {
2901  if(sigCmp == 0)
2902  {
2903  //sigdrop since we loose the signature
2904  strat->sigdrop = TRUE;
2905  //Try to reduce it as far as we can via redRing
2907  {
2908  poly p1 = p_Copy(p,currRing);
2909  poly p2 = p_Copy(strat->S[i],currRing);
2910  p1 = p_Mult_mm(p1,m1,currRing);
2911  p2 = p_Mult_mm(p2,m2,currRing);
2912  Lp.p = p_Sub(p1,p2,currRing);
2913  if(Lp.p != NULL)
2914  Lp.sev = p_GetShortExpVector(Lp.p,currRing);
2915  }
2916  int red_result = redRing(&Lp,strat);
2917  if(red_result == 0)
2918  {
2919  // Cancel the sigdrop
2920  p_Delete(&Lp.sig,currRing);Lp.sig = NULL;
2921  strat->sigdrop = FALSE;
2922  return;
2923  }
2924  else
2925  {
2926  strat->enterS(strat->P,strat->sl+1,strat, strat->tl+1);
2927  #if 1
2928  strat->enterS(Lp,0,strat,strat->tl);
2929  #endif
2930  return;
2931  }
2932  }
2933  if(pSigMult != NULL && sSigMult != NULL && p_LmCmp(pSigMult,sSigMult,currRing) == 0)
2934  {
2935  //Same lm, have to substract
2936  Lp.sig = p_Sub(pCopy(pSigMult),pCopy(sSigMult),currRing);
2937  }
2938  else
2939  {
2940  if(sigCmp == 1)
2941  {
2942  Lp.sig = pCopy(pSigMult);
2943  }
2944  if(sigCmp == -1)
2945  {
2946  Lp.sig = pNeg(pCopy(sSigMult));
2947  }
2948  }
2949  Lp.sevSig = p_GetShortExpVector(Lp.sig,currRing);
2950  }
2951 
2952  #if 0
2953  if(sigCmp==0)
2954  {
2955  // printf("!!!! EQUAL SIGS !!!!\n");
2956  // pSig = sSig, delete element due to Rewritten Criterion
2957  pDelete(&pSigMult);
2958  pDelete(&sSigMult);
2959  if (rField_is_Ring(currRing))
2960  pLmDelete(Lp.lcm);
2961  else
2962  pLmFree(Lp.lcm);
2963  pDelete (&m1);
2964  pDelete (&m2);
2965  return;
2966  }
2967  #endif
2968  // testing by syzCrit = F5 Criterion
2969  // testing by rewCrit1 = Rewritten Criterion
2970  // NOTE: Arri's Rewritten Criterion is tested below, we need Lp.p for it!
2971  if ( strat->syzCrit(pSigMult,pSigMultNegSev,strat) ||
2972  strat->syzCrit(sSigMult,sSigMultNegSev,strat)
2973  // With this rewCrit activated i get a wrong deletion in sba_int_56.tst
2974  //|| strat->rewCrit1(sSigMult,sSigMultNegSev,Lp.lcm,strat,i+1)
2975  )
2976  {
2977  pDelete(&pSigMult);
2978  pDelete(&sSigMult);
2979  if (rField_is_Ring(currRing))
2980  pLmDelete(Lp.lcm);
2981  else
2982  pLmFree(Lp.lcm);
2983  pDelete (&m1);
2984  pDelete (&m2);
2985  return;
2986  }
2987  /*
2988  *the pair (S[i],p) enters B if the spoly != 0
2989  */
2990  /*- compute the short s-polynomial -*/
2991  if (strat->fromT && !TEST_OPT_INTSTRATEGY)
2992  pNorm(p);
2993 
2994  if ((strat->S[i]==NULL) || (p==NULL))
2995  return;
2996 
2997  if ((strat->fromQ!=NULL) && (isFromQ!=0) && (strat->fromQ[i]!=0))
2998  Lp.p=NULL;
2999  else
3000  {
3001  //Build p
3003  {
3004  poly p1 = p_Copy(p,currRing);
3005  poly p2 = p_Copy(strat->S[i],currRing);
3006  p1 = p_Mult_mm(p1,m1,currRing);
3007  p2 = p_Mult_mm(p2,m2,currRing);
3008  Lp.p = p_Sub(p1,p2,currRing);
3009  if(Lp.p != NULL)
3010  Lp.sev = p_GetShortExpVector(Lp.p,currRing);
3011  }
3012  else
3013  {
3014  #ifdef HAVE_PLURAL
3015  if ( rIsPluralRing(currRing) )
3016  {
3017  if(ncRingType(currRing) == nc_lie)
3018  {
3019  // generalized prod-crit for lie-type
3020  strat->cp++;
3021  Lp.p = nc_p_Bracket_qq(pCopy(p),strat->S[i], currRing);
3022  }
3023  else
3024  if( ALLOW_PROD_CRIT(strat) )
3025  {
3026  // product criterion for homogeneous case in SCA
3027  strat->cp++;
3028  Lp.p = NULL;
3029  }
3030  else
3031  {
3032  Lp.p = // nc_CreateSpoly(strat->S[i],p,currRing);
3033  nc_CreateShortSpoly(strat->S[i], p, currRing);
3034 
3035  assume(pNext(Lp.p)==NULL); // TODO: this may be violated whenever ext.prod.crit. for Lie alg. is used
3036  pNext(Lp.p) = strat->tail; // !!!
3037  }
3038  }
3039  else
3040  #endif
3041  {
3043  Lp.p = ksCreateShortSpoly(strat->S[i], p, strat->tailRing);
3044  }
3045  }
3046  }
3047  // store from which element this pair comes from for further tests
3048  //Lp.from = strat->sl+1;
3050  {
3051  //Put the sig to be > 0
3052  if(!nGreaterZero(pGetCoeff(Lp.sig)))
3053  {
3054  Lp.sig = pNeg(Lp.sig);
3055  Lp.p = pNeg(Lp.p);
3056  }
3057  }
3058  else
3059  {
3060  if(sigCmp==currRing->OrdSgn)
3061  {
3062  // pSig > sSig
3063  pDelete (&sSigMult);
3064  Lp.sig = pSigMult;
3065  Lp.sevSig = ~pSigMultNegSev;
3066  }
3067  else
3068  {
3069  // pSig < sSig
3070  pDelete (&pSigMult);
3071  Lp.sig = sSigMult;
3072  Lp.sevSig = ~sSigMultNegSev;
3073  }
3074  }
3075  if (Lp.p == NULL)
3076  {
3077  if (Lp.lcm!=NULL) pLmFree(Lp.lcm);
3078  int pos = posInSyz(strat, Lp.sig);
3079  enterSyz(Lp, strat, pos);
3080  }
3081  else
3082  {
3083  // testing by rewCrit3 = Arris Rewritten Criterion (for F5 nothing happens!)
3084  if (strat->rewCrit3(Lp.sig,~Lp.sevSig,Lp.p,strat,strat->sl+1))
3085  {
3086  pLmFree(Lp.lcm);
3087  pDelete(&Lp.sig);
3088  pDelete (&m1);
3089  pDelete (&m2);
3090  return;
3091  }
3092  // in any case Lp is checked up to the next strat->P which is added
3093  // to S right after this critical pair creation.
3094  // NOTE: this even holds if the 2nd generator gives the bigger signature
3095  // moreover, this improves rewCriterion,
3096  // i.e. strat->checked > strat->from if and only if the 2nd generator
3097  // gives the bigger signature.
3098  Lp.checked = strat->sl+1;
3099  // at this point it is clear that the pair will be added to L, since it has
3100  // passed all tests up to now
3101 
3102  // adds buchberger's first criterion
3103  if (pLmCmp(m2,pHead(p)) == 0)
3104  {
3105  Lp.prod_crit = TRUE; // Product Criterion
3106 #if 0
3107  int pos = posInSyz(strat, Lp.sig);
3108  enterSyz(Lp, strat, pos);
3109  pDelete (&m1);
3110  pDelete (&m2);
3111  return;
3112 #endif
3113  }
3114  pDelete (&m1);
3115  pDelete (&m2);
3116 #if DEBUGF5
3117  PrintS("SIGNATURE OF PAIR: ");
3118  pWrite(Lp.sig);
3119 #endif
3120  /*- the pair (S[i],p) enters B -*/
3121  Lp.p1 = strat->S[i];
3122  Lp.p2 = p;
3123 
3124  if (
3126 // || (rIsPluralRing(currRing) && (ncRingType(currRing) != nc_lie))
3128  )
3129  {
3130  assume(pNext(Lp.p)==NULL); // TODO: this may be violated whenever ext.prod.crit. for Lie alg. is used
3131  pNext(Lp.p) = strat->tail; // !!!
3132  }
3133 
3134  if (atR >= 0)
3135  {
3136  Lp.i_r1 = strat->S_2_R[i];
3137  Lp.i_r2 = atR;
3138  }
3139  else
3140  {
3141  Lp.i_r1 = -1;
3142  Lp.i_r2 = -1;
3143  }
3144  strat->initEcartPair(&Lp,strat->S[i],p,strat->ecartS[i],ecart);
3145 
3147  {
3148  if (!rIsPluralRing(currRing)
3150  && (Lp.p->coef!=NULL))
3151  nDelete(&(Lp.p->coef));
3152  }
3153  // Check for sigdrop
3154  if(rField_is_Ring(currRing) && pLtCmp(Lp.sig,pSig) == -1)
3155  {
3156  strat->sigdrop = TRUE;
3157  // Completely reduce it
3158  int red_result = redRing(&Lp,strat);
3159  if(red_result == 0)
3160  {
3161  // Reduced to 0
3162  strat->sigdrop = FALSE;
3163  p_Delete(&Lp.sig,currRing);Lp.sig = NULL;
3164  return;
3165  }
3166  else
3167  {
3168  strat->enterS(strat->P,strat->sl+1,strat, strat->tl+1);
3169  // 0 - add just the original poly causing the sigdrop, 1 - add also this
3170  #if 1
3171  strat->enterS(Lp,0,strat, strat->tl+1);
3172  #endif
3173  return;
3174  }
3175  }
3176  l = strat->posInLSba(strat->L,strat->Ll,&Lp,strat);
3177  enterL(&strat->L,&strat->Ll,&strat->Lmax,Lp,l);
3178  }
3179 }
#define nGreaterZero(n)
Definition: numbers.h:27
poly p_Sub(poly p1, poly p2, const ring r)
Definition: p_polys.cc:1986
static int p_LtCmpNoAbs(poly p, poly q, const ring r)
Definition: p_polys.h:1649
static poly p_Mult_mm(poly p, poly m, const ring r)
Definition: p_polys.h:1053
#define pLtCmp(p, q)
Definition: polys.h:123

◆ enterOnePairSpecial()

void enterOnePairSpecial ( int  i,
poly  p,
int  ecart,
kStrategy  strat,
int  atR = -1 
)

Definition at line 3185 of file kutil.cc.

3186 {
3187  //PrintS("try ");wrp(strat->S[i]);PrintS(" and ");wrp(p);PrintLn();
3188  if(pHasNotCF(p,strat->S[i]))
3189  {
3190  //PrintS("prod-crit\n");
3191  if(ALLOW_PROD_CRIT(strat))
3192  {
3193  //PrintS("prod-crit\n");
3194  strat->cp++;
3195  return;
3196  }
3197  }
3198 
3199  int l;
3200  LObject Lp;
3201  Lp.i_r = -1;
3202 
3203  Lp.lcm = p_Lcm(p,strat->S[i],currRing);
3204  /*- compute the short s-polynomial -*/
3205 
3206  #ifdef HAVE_PLURAL
3207  if (rIsPluralRing(currRing))
3208  {
3209  Lp.p = nc_CreateShortSpoly(strat->S[i],p, currRing); // ??? strat->tailRing?
3210  }
3211  else
3212  #endif
3213  Lp.p = ksCreateShortSpoly(strat->S[i],p,strat->tailRing);
3214 
3215  if (Lp.p == NULL)
3216  {
3217  //PrintS("short spoly==NULL\n");
3218  pLmFree(Lp.lcm);
3219  }
3220  else
3221  {
3222  /*- the pair (S[i],p) enters L -*/
3223  Lp.p1 = strat->S[i];
3224  Lp.p2 = p;
3225  if (atR >= 0)
3226  {
3227  Lp.i_r1 = strat->S_2_R[i];
3228  Lp.i_r2 = atR;
3229  }
3230  else
3231  {
3232  Lp.i_r1 = -1;
3233  Lp.i_r2 = -1;
3234  }
3235  assume(pNext(Lp.p) == NULL);
3236  pNext(Lp.p) = strat->tail;
3237  strat->initEcartPair(&Lp,strat->S[i],p,strat->ecartS[i],ecart);
3239  {
3240  if (!rIsPluralRing(currRing)
3242  && (Lp.p->coef!=NULL))
3243  nDelete(&(Lp.p->coef));
3244  }
3245  l = strat->posInL(strat->L,strat->Ll,&Lp,strat);
3246  //Print("-> L[%d]\n",l);
3247  enterL(&strat->L,&strat->Ll,&strat->Lmax,Lp,l);
3248  }
3249 }

◆ enterOnePairWithoutShifts()

static BOOLEAN enterOnePairWithoutShifts ( int  p_inS,
poly  q,
poly  p,
int  ecartq,
int  q_isFromQ,
kStrategy  strat,
int  ,
int  p_lastVblock,
int  q_shift 
)
static

Definition at line 12585 of file kutil.cc.

12586 {
12587  // note: ecart and isFromQ is for p
12588  assume(p_inS < 0 || strat->S[p_inS] == p); // if p is from S, p_inS should be the index of p in S
12589  assume(pmFirstVblock(p) == 1);
12590  assume(p_lastVblock == pmLastVblock(p));
12591  assume(q_shift == pmFirstVblock(q) - 1);
12592 
12593  // TODO: is ecartp = 0 still ok?
12594  int ecartp = 0; //Hans says it's ok; we're in the homog e:, no ecart
12595 
12596  int p_isFromQ = 0;
12597  if (strat->fromQ != NULL && p_inS >= 0)
12598  p_isFromQ = strat->fromQ[p_inS];
12599 
12600 #ifdef HAVE_RINGS
12601  if (rField_is_Ring(currRing))
12602  {
12603  assume(q_shift <= p_lastVblock); // we allow the special case where there is no overlap
12604  return enterOneStrongPolyAndEnterOnePairRingShift(q, p, ecartp, p_isFromQ, strat, -1, ecartq, q_isFromQ, q_shift, -1);
12605  }
12606  else
12607 #endif
12608  {
12609  assume(q_shift <= p_lastVblock - ((pGetComp(q) > 0 || pGetComp(p) > 0) ? 0 : 1)); // there should be an overlap (in the module case epsilon overlap is also allowed)
12610  return enterOnePairShift(q, p, ecartp, p_isFromQ, strat, -1, ecartq, q_isFromQ, q_shift, -1);
12611  }
12612 }
static BOOLEAN enterOneStrongPolyAndEnterOnePairRingShift(poly q, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int ecartq, int qisFromQ, int shiftcount, int ifromS)
Definition: kutil.cc:12510
BOOLEAN enterOnePairShift(poly q, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int ecartq, int qisFromQ, int shiftcount, int ifromS)
Definition: kutil.cc:12625
#define pmFirstVblock(p)
Definition: shiftop.h:35
#define pmLastVblock(p)
Definition: shiftop.h:33

◆ enterOnePairWithShifts()

static BOOLEAN enterOnePairWithShifts ( int  q_inS,
poly  q,
poly  p,
int  ecartp,
int  p_isFromQ,
kStrategy  strat,
int  ,
int  p_lastVblock,
int  q_lastVblock 
)
static

Definition at line 12520 of file kutil.cc.

12521 {
12522  // note: ecart and isFromQ is for p
12523  assume(q_inS < 0 || strat->S[q_inS] == q); // if q is from S, q_inS should be the index of q in S
12524  assume(pmFirstVblock(p) == 1);
12525  assume(pmFirstVblock(q) == 1);
12526  assume(p_lastVblock == pmLastVblock(p));
12527  assume(q_lastVblock == pmLastVblock(q));
12528 
12529  // TODO: is ecartq = 0 still ok?
12530  int ecartq = 0; //Hans says it's ok; we're in the homog case, no ecart
12531 
12532  int q_isFromQ = 0;
12533  if (strat->fromQ != NULL && q_inS >= 0)
12534  q_isFromQ = strat->fromQ[q_inS];
12535 
12536  BOOLEAN (*enterPair)(poly, poly, int, int, kStrategy, int, int, int, int, int);
12537 #ifdef HAVE_RINGS
12538  if (rField_is_Ring(currRing))
12540  else
12541 #endif
12542  enterPair = enterOnePairShift;
12543 
12544  int degbound = currRing->N/currRing->isLPring;
12545  int neededShift = p_lastVblock - ((pGetComp(p) > 0 || pGetComp(q) > 0) ? 0 : 1); // in the module case, product criterion does not hold
12546  int maxPossibleShift = degbound - q_lastVblock;
12547  int maxShift = si_min(neededShift, maxPossibleShift);
12548  int firstShift = (q == p ? 1 : 0); // do not add (q,p) if q=p
12549  BOOLEAN delete_pair=TRUE;
12550  for (int j = firstShift; j <= maxShift; j++)
12551  {
12552  poly qq = pLPCopyAndShiftLM(q, j);
12553  if (enterPair(qq, p, ecartp, p_isFromQ, strat, -1, ecartq, q_isFromQ, j, q_inS))
12554  {
12555  if (j>0) pLmDelete(qq);
12556  // delete qq, if not it does not enter the pair set
12557  }
12558  else
12559  delete_pair=FALSE;
12560  }
12561 
12562 #ifdef HAVE_RINGS
12563  if (rField_is_Ring(currRing) && p_lastVblock >= firstShift && p_lastVblock <= maxPossibleShift)
12564  {
12565  // add pairs (m*shifts(q), p) where m is a monomial and the pair has no overlap
12566  for (int j = p_lastVblock; j <= maxPossibleShift; j++)
12567  {
12568  ideal fillers = id_MaxIdeal(j - p_lastVblock, currRing);
12569  for (int k = 0; k < IDELEMS(fillers); k++)
12570  {
12571  poly qq = pLPCopyAndShiftLM(pp_mm_Mult(q, fillers->m[k], currRing), p_lastVblock);
12572  enterPair(qq, p, ecartp, p_isFromQ, strat, -1, ecartq, q_isFromQ, p_lastVblock, q_inS);
12573  }
12574  idDelete(&fillers);
12575  }
12576  }
12577 #endif
12578  return delete_pair;
12579 }
static int si_min(const int a, const int b)
Definition: auxiliary.h:125
#define idDelete(H)
delete an ideal
Definition: ideals.h:29
#define pLPCopyAndShiftLM(p, sh)
Definition: shiftgb.h:15
ideal id_MaxIdeal(const ring r)
initialise the maximal ideal (at 0)
Definition: simpleideals.cc:98
#define IDELEMS(i)
Definition: simpleideals.h:23
skStrategy * kStrategy
Definition: structs.h:58
#define degbound(p)
Definition: tgb.cc:153

◆ enterOneStrongPoly()

static BOOLEAN enterOneStrongPoly ( int  i,
poly  p,
int  ,
int  ,
kStrategy  strat,
int  atR,
bool  enterTstrong 
)
static

Definition at line 1630 of file kutil.cc.

1631 {
1632  number d, s, t;
1633  assume(atR >= 0);
1635  poly m1, m2, gcd,si;
1636  if(!enterTstrong)
1637  {
1638  assume(i<=strat->sl);
1639  si = strat->S[i];
1640  }
1641  else
1642  {
1643  assume(i<=strat->tl);
1644  si = strat->T[i].p;
1645  }
1646  //printf("\n--------------------------------\n");
1647  //pWrite(p);pWrite(si);
1648  d = n_ExtGcd(pGetCoeff(p), pGetCoeff(si), &s, &t, currRing->cf);
1649 
1650  if (nIsZero(s) || nIsZero(t)) // evtl. durch divBy tests ersetzen
1651  {
1652  nDelete(&d);
1653  nDelete(&s);
1654  nDelete(&t);
1655  return FALSE;
1656  }
1657 
1658  k_GetStrongLeadTerms(p, si, currRing, m1, m2, gcd, strat->tailRing);
1659 
1661  {
1662  unsigned long sev = pGetShortExpVector(gcd);
1663 
1664  for (int j = 0; j < strat->sl; j++)
1665  {
1666  if (j == i)
1667  continue;
1668 
1669  if (n_DivBy(d, pGetCoeff(strat->S[j]), currRing->cf)
1670  && !(strat->sevS[j] & ~sev)
1671  && p_LmDivisibleBy(strat->S[j], gcd, currRing))
1672  {
1673  nDelete(&d);
1674  nDelete(&s);
1675  nDelete(&t);
1676  return FALSE;
1677  }
1678  }
1679  }
1680 
1681  //p_Test(m1,strat->tailRing);
1682  //p_Test(m2,strat->tailRing);
1683  /*if(!enterTstrong)
1684  {
1685  while (! kCheckStrongCreation(atR, m1, i, m2, strat) )
1686  {
1687  memset(&(strat->P), 0, sizeof(strat->P));
1688  kStratChangeTailRing(strat);
1689  strat->P = *(strat->R[atR]);
1690  p_LmFree(m1, strat->tailRing);
1691  p_LmFree(m2, strat->tailRing);
1692  p_LmFree(gcd, currRing);
1693  k_GetStrongLeadTerms(p, si, currRing, m1, m2, gcd, strat->tailRing);
1694  }
1695  }*/
1696  pSetCoeff0(m1, s);
1697  pSetCoeff0(m2, t);
1698  pSetCoeff0(gcd, d);
1699  p_Test(m1,strat->tailRing);
1700  p_Test(m2,strat->tailRing);
1701  //printf("\n===================================\n");
1702  //pWrite(m1);pWrite(m2);pWrite(gcd);
1703 #ifdef KDEBUG
1704  if (TEST_OPT_DEBUG)
1705  {
1706  // Print("t = %d; s = %d; d = %d\n", nInt(t), nInt(s), nInt(d));
1707  PrintS("m1 = ");
1708  p_wrp(m1, strat->tailRing);
1709  PrintS(" ; m2 = ");
1710  p_wrp(m2, strat->tailRing);
1711  PrintS(" ; gcd = ");
1712  wrp(gcd);
1713  PrintS("\n--- create strong gcd poly: ");
1714  Print("\n p: %d", i);
1715  wrp(p);
1716  Print("\n strat->S[%d]: ", i);
1717  wrp(si);
1718  PrintS(" ---> ");
1719  }
1720 #endif
1721 
1722  pNext(gcd) = p_Add_q(pp_Mult_mm(pNext(p), m1, strat->tailRing), pp_Mult_mm(pNext(si), m2, strat->tailRing), strat->tailRing);
1723  p_LmDelete(m1, strat->tailRing);
1724  p_LmDelete(m2, strat->tailRing);
1725 #ifdef KDEBUG
1726  if (TEST_OPT_DEBUG)
1727  {
1728  wrp(gcd);
1729  PrintLn();
1730  }
1731 #endif
1732 
1733  LObject h;
1734  h.p = gcd;
1735  h.tailRing = strat->tailRing;
1736  int posx;
1737  strat->initEcart(&h);
1738  h.sev = pGetShortExpVector(h.p);
1739  h.i_r1 = -1;h.i_r2 = -1;
1740  if (currRing!=strat->tailRing)
1741  h.t_p = k_LmInit_currRing_2_tailRing(h.p, strat->tailRing);
1742  if(!enterTstrong)
1743  {
1744  #if 1
1745  h.p1 = p;h.p2 = strat->S[i];
1746  #endif
1747  if (atR >= 0)
1748  {
1749  h.i_r2 = strat->S_2_R[i];
1750  h.i_r1 = atR;
1751  }
1752  else
1753  {
1754  h.i_r1 = -1;
1755  h.i_r2 = -1;
1756  }
1757  if (strat->Ll==-1)
1758  posx =0;
1759  else
1760  posx = strat->posInL(strat->L,strat->Ll,&h,strat);
1761  enterL(&strat->L,&strat->Ll,&strat->Lmax,h,posx);
1762  }
1763  else
1764  {
1765  if(h.IsNull()) return FALSE;
1766  //int red_result;
1767  //reduzieren ist teur!!!
1768  //if(strat->L != NULL)
1769  //red_result = strat->red(&h,strat);
1770  if(!h.IsNull())
1771  {
1772  enterT(h, strat,-1);
1773  //int pos = posInS(strat,strat->sl,h.p,h.ecart);
1774  //strat->enterS(h,pos,strat,-1);
1775  }
1776  }
1777  return TRUE;
1778 }
KINLINE void k_GetStrongLeadTerms(const poly p1, const poly p2, const ring leadRing, poly &m1, poly &m2, poly &lcm, const ring tailRing)
Definition: kInline.h:1072
void enterT(LObject &p, kStrategy strat, int atT)
Definition: kutil.cc:9450
static BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
Definition: p_polys.h:1897
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
Definition: ring.h:761

◆ enterOneStrongPolyAndEnterOnePairRingShift()

static BOOLEAN enterOneStrongPolyAndEnterOnePairRingShift ( poly  q,
poly  p,
int  ecart,
int  isFromQ,
kStrategy  strat,
int  atR,
int  ecartq,
int  qisFromQ,
int  shiftcount,
int  ifromS 
)
static

Definition at line 12510 of file kutil.cc.

12511 {
12512  enterOneStrongPolyShift(q, p, ecart, isFromQ, strat, atR, ecartq, qisFromQ, shiftcount, ifromS); // "gpoly"
12513  enterOnePairRingShift(q, p, ecart, isFromQ, strat, atR, ecartq, qisFromQ, shiftcount, ifromS); // "spoly"
12514  return FALSE; // TODO: delete q?
12515 }
static void enterOnePairRingShift(poly q, poly p, int, int isFromQ, kStrategy strat, int atR, int, int qisFromQ, int shiftcount, int ifromS)
Definition: kutil.cc:12266
static BOOLEAN enterOneStrongPolyShift(poly q, poly p, int, int, kStrategy strat, int atR, int, int, int shiftcount, int ifromS)
Definition: kutil.cc:12097

◆ enterOneStrongPolyShift()

static BOOLEAN enterOneStrongPolyShift ( poly  q,
poly  p,
int  ,
int  ,
kStrategy  strat,
int  atR,
int  ,
int  ,
int  shiftcount,
int  ifromS 
)
static

Definition at line 12097 of file kutil.cc.

12098 {
12099  number d, s, t;
12100  /* assume(atR >= 0); */
12101  assume(ifromS <= strat->sl);
12103  poly m1, m2, gcd;
12104  //printf("\n--------------------------------\n");
12105  //pWrite(p);pWrite(si);
12106  d = n_ExtGcd(pGetCoeff(p), pGetCoeff(q), &s, &t, currRing->cf);
12107 
12108  if (nIsZero(s) || nIsZero(t)) // evtl. durch divBy tests ersetzen
12109  {
12110  nDelete(&d);
12111  nDelete(&s);
12112  nDelete(&t);
12113  return FALSE;
12114  }
12115 
12116  assume(pIsInV(p));
12117 
12118  k_GetStrongLeadTerms(p, q, currRing, m1, m2, gcd, strat->tailRing);
12119 
12120  /* the V criterion */
12121  if (!pmIsInV(gcd))
12122  {
12123  strat->cv++;
12124  nDelete(&d);
12125  nDelete(&s);
12126  nDelete(&t);
12127  pLmFree(gcd);
12128  return FALSE;
12129  }
12130 
12131  // disabled for Letterplace because it is not so easy to check
12132  /* if (!rHasLocalOrMixedOrdering(currRing)) { */
12133  /* unsigned long sev = pGetShortExpVector(gcd); */
12134 
12135  /* for (int j = 0; j < strat->sl; j++) { */
12136  /* if (j == i) */
12137  /* continue; */
12138 
12139  /* if (n_DivBy(d, pGetCoeff(strat->S[j]), currRing->cf) && */
12140  /* !(strat->sevS[j] & ~sev) && */
12141  /* p_LmDivisibleBy(strat->S[j], gcd, currRing)) { */
12142  /* nDelete(&d); */
12143  /* nDelete(&s); */
12144  /* nDelete(&t); */
12145  /* return FALSE; */
12146  /* } */
12147  /* } */
12148  /* } */
12149 
12150  poly m12, m22;
12151  assume(p_mFirstVblock(p, currRing) <= 1 || p_mFirstVblock(q, currRing) <= 1);
12153  k_SplitFrame(m2, m22, si_max(p_mFirstVblock(q, currRing), 1), currRing);
12154  // manually free the coeffs, because pSetCoeff0 is used in the next step
12155  n_Delete(&(m1->coef), currRing->cf);
12156  n_Delete(&(m2->coef), currRing->cf);
12157 
12158  //p_Test(m1,strat->tailRing);
12159  //p_Test(m2,strat->tailRing);
12160  /*if(!enterTstrong)
12161  {
12162  while (! kCheckStrongCreation(atR, m1, i, m2, strat) )
12163  {
12164  memset(&(strat->P), 0, sizeof(strat->P));
12165  kStratChangeTailRing(strat);
12166  strat->P = *(strat->R[atR]);
12167  p_LmFree(m1, strat->tailRing);
12168  p_LmFree(m2, strat->tailRing);
12169  p_LmFree(gcd, currRing);
12170  k_GetStrongLeadTerms(p, si, currRing, m1, m2, gcd, strat->tailRing);
12171  }
12172  }*/
12173  pSetCoeff0(m1, s);
12174  pSetCoeff0(m2, t);
12175  pSetCoeff0(gcd, d);
12176  p_Test(m1,strat->tailRing);
12177  p_Test(m2,strat->tailRing);
12178  p_Test(m12,strat->tailRing);
12179  p_Test(m22,strat->tailRing);
12180  assume(pmIsInV(m1));
12181  assume(pmIsInV(m2));
12182  assume(pmIsInV(m12));
12183  assume(pmIsInV(m22));
12184  //printf("\n===================================\n");
12185  //pWrite(m1);pWrite(m2);pWrite(gcd);
12186 #ifdef KDEBUG
12187  if (TEST_OPT_DEBUG)
12188  {
12189  // Print("t = %d; s = %d; d = %d\n", nInt(t), nInt(s), nInt(d));
12190  PrintS("m1 = ");
12191  p_wrp(m1, strat->tailRing);
12192  PrintS("m12 = ");
12193  p_wrp(m12, strat->tailRing);
12194  PrintS(" ; m2 = ");
12195  p_wrp(m2, strat->tailRing);
12196  PrintS(" ; m22 = ");
12197  p_wrp(m22, strat->tailRing);
12198  PrintS(" ; gcd = ");
12199  wrp(gcd);
12200  PrintS("\n--- create strong gcd poly: ");
12201  PrintS("\n p: ");
12202  wrp(p);
12203  Print("\n q (strat->S[%d]): ", ifromS);
12204  wrp(q);
12205  PrintS(" ---> ");
12206  }
12207 #endif
12208 
12209  pNext(gcd) = p_Add_q(pp_Mult_mm(pp_mm_Mult(pNext(p), m1, strat->tailRing), m12, strat->tailRing), pp_Mult_mm(pp_mm_Mult(pNext(q), m2, strat->tailRing), m22, strat->tailRing), strat->tailRing);
12210  p_LmDelete(m1, strat->tailRing);
12211  p_LmDelete(m2, strat->tailRing);
12212  p_LmDelete(m12, strat->tailRing);
12213  p_LmDelete(m22, strat->tailRing);
12214 
12215  assume(pIsInV(gcd));
12216 
12217 #ifdef KDEBUG
12218  if (TEST_OPT_DEBUG)
12219  {
12220  wrp(gcd);
12221  PrintLn();
12222  }
12223 #endif
12224 
12225  LObject h;
12226  h.p = gcd;
12227  h.tailRing = strat->tailRing;
12228  int posx;
12229  strat->initEcart(&h);
12230  h.sev = pGetShortExpVector(h.p);
12231  h.i_r1 = -1;h.i_r2 = -1;
12232  if (currRing!=strat->tailRing)
12233  h.t_p = k_LmInit_currRing_2_tailRing(h.p, strat->tailRing);
12234 #if 1
12235  h.p1 = p;
12236  h.p2 = q;
12237 #endif
12238  if (atR >= 0 && shiftcount == 0 && ifromS >= 0)
12239  {
12240  h.i_r2 = kFindInT(h.p1, strat);
12241  h.i_r1 = atR;
12242  }
12243  else
12244  {
12245  h.i_r1 = -1;
12246  h.i_r2 = -1;
12247  }
12248  if (strat->Ll==-1)
12249  posx =0;
12250  else
12251  posx = strat->posInL(strat->L,strat->Ll,&h,strat);
12252 
12253  assume(pIsInV(h.p));
12254  assume(pIsInV(h.p1));
12255 
12256  enterL(&strat->L,&strat->Ll,&strat->Lmax,h,posx);
12257  return TRUE;
12258 }

◆ enterOneStrongPolySig()

static BOOLEAN enterOneStrongPolySig ( int  i,
poly  p,
poly  sig,
int  ,
int  ,
kStrategy  strat,
int  atR 
)
static

Definition at line 1838 of file kutil.cc.

1839 {
1840  number d, s, t;
1841  assume(atR >= 0);
1842  poly m1, m2, gcd,si;
1843  assume(i<=strat->sl);
1844  si = strat->S[i];
1845  //printf("\n--------------------------------\n");
1846  //pWrite(p);pWrite(si);
1847  d = n_ExtGcd(pGetCoeff(p), pGetCoeff(si), &s, &t, currRing->cf);
1848 
1849  if (nIsZero(s) || nIsZero(t)) // evtl. durch divBy tests ersetzen
1850  {
1851  nDelete(&d);
1852  nDelete(&s);
1853  nDelete(&t);
1854  return FALSE;
1855  }
1856 
1857  k_GetStrongLeadTerms(p, si, currRing, m1, m2, gcd, strat->tailRing);
1858  //p_Test(m1,strat->tailRing);
1859  //p_Test(m2,strat->tailRing);
1860  /*if(!enterTstrong)
1861  {
1862  while (! kCheckStrongCreation(atR, m1, i, m2, strat) )
1863  {
1864  memset(&(strat->P), 0, sizeof(strat->P));
1865  kStratChangeTailRing(strat);
1866  strat->P = *(strat->R[atR]);
1867  p_LmFree(m1, strat->tailRing);
1868  p_LmFree(m2, strat->tailRing);
1869  p_LmFree(gcd, currRing);
1870  k_GetStrongLeadTerms(p, si, currRing, m1, m2, gcd, strat->tailRing);
1871  }
1872  }*/
1873  pSetCoeff0(m1, s);
1874  pSetCoeff0(m2, t);
1875  pSetCoeff0(gcd, d);
1876  p_Test(m1,strat->tailRing);
1877  p_Test(m2,strat->tailRing);
1878  //printf("\n===================================\n");
1879  //pWrite(m1);pWrite(m2);pWrite(gcd);
1880 #ifdef KDEBUG
1881  if (TEST_OPT_DEBUG)
1882  {
1883  // Print("t = %d; s = %d; d = %d\n", nInt(t), nInt(s), nInt(d));
1884  PrintS("m1 = ");
1885  p_wrp(m1, strat->tailRing);
1886  PrintS(" ; m2 = ");
1887  p_wrp(m2, strat->tailRing);
1888  PrintS(" ; gcd = ");
1889  wrp(gcd);
1890  PrintS("\n--- create strong gcd poly: ");
1891  Print("\n p: %d", i);
1892  wrp(p);
1893  Print("\n strat->S[%d]: ", i);
1894  wrp(si);
1895  PrintS(" ---> ");
1896  }
1897 #endif
1898 
1899  pNext(gcd) = p_Add_q(pp_Mult_mm(pNext(p), m1, strat->tailRing), pp_Mult_mm(pNext(si), m2, strat->tailRing), strat->tailRing);
1900 
1901 #ifdef KDEBUG
1902  if (TEST_OPT_DEBUG)
1903  {
1904  wrp(gcd);
1905  PrintLn();
1906  }
1907 #endif
1908 
1909  //Check and set the signatures
1910  poly pSigMult = p_Copy(sig,currRing);
1911  poly sSigMult = p_Copy(strat->sig[i],currRing);
1912  pSigMult = p_Mult_mm(pSigMult,m1,currRing);
1913  sSigMult = p_Mult_mm(sSigMult,m2,currRing);
1914  p_LmDelete(m1, strat->tailRing);
1915  p_LmDelete(m2, strat->tailRing);
1916  poly pairsig;
1917  if(pLmCmp(pSigMult,sSigMult) == 0)
1918  {
1919  //Same lm, have to add them
1920  pairsig = p_Add_q(pSigMult,sSigMult,currRing);
1921  //This might be zero
1922  }
1923  else
1924  {
1925  //Set the sig to either pSigMult or sSigMult
1926  if(pLtCmp(pSigMult,sSigMult)==1)
1927  {
1928  pairsig = pSigMult;
1929  pDelete(&sSigMult);
1930  }
1931  else
1932  {
1933  pairsig = sSigMult;
1934  pDelete(&pSigMult);
1935  }
1936  }
1937 
1938  LObject h;
1939  h.p = gcd;
1940  h.tailRing = strat->tailRing;
1941  h.sig = pairsig;
1942  int posx;
1943  strat->initEcart(&h);
1944  h.sev = pGetShortExpVector(h.p);
1945  h.i_r1 = -1;h.i_r2 = -1;
1946  if (currRing!=strat->tailRing)
1947  h.t_p = k_LmInit_currRing_2_tailRing(h.p, strat->tailRing);
1948  if(h.sig == NULL)
1949  {
1950  //sigdrop since we loose the signature
1951  strat->sigdrop = TRUE;
1952  //Try to reduce it as far as we can via redRing
1953  int red_result = redRing(&h,strat);
1954  if(red_result == 0)
1955  {
1956  // Cancel the sigdrop
1957  p_Delete(&h.sig,currRing);h.sig = NULL;
1958  strat->sigdrop = FALSE;
1959  return FALSE;
1960  }
1961  else
1962  {
1963  strat->enterS(strat->P,strat->sl+1,strat, strat->tl+1);
1964  #if 1
1965  strat->enterS(h,0,strat,strat->tl);
1966  #endif
1967  return FALSE;
1968  }
1969  }
1970  if(!nGreaterZero(pGetCoeff(h.sig)))
1971  {
1972  h.sig = pNeg(h.sig);
1973  h.p = pNeg(h.p);
1974  }
1975 
1976  if(rField_is_Ring(currRing) && pLtCmp(h.sig,sig) == -1)
1977  {
1978  strat->sigdrop = TRUE;
1979  // Completely reduce it
1980  int red_result = redRing(&h,strat);
1981  if(red_result == 0)
1982  {
1983  // Reduced to 0
1984  strat->sigdrop = FALSE;
1985  p_Delete(&h.sig,currRing);h.sig = NULL;
1986  return FALSE;
1987  }
1988  else
1989  {
1990  strat->enterS(strat->P,strat->sl+1,strat, strat->tl+1);
1991  // 0 - add just the original poly causing the sigdrop, 1 - add also this
1992  #if 1
1993  strat->enterS(h,0,strat, strat->tl+1);
1994  #endif
1995  return FALSE;
1996  }
1997  }
1998  //Check for sigdrop
1999  if(gcd != NULL && pLtCmp(sig,pairsig) > 0 && pLtCmp(strat->sig[i],pairsig) > 0)
2000  {
2001  strat->sigdrop = TRUE;
2002  //Enter this element to S
2003  strat->enterS(strat->P,strat->sl+1,strat, strat->tl+1);
2004  strat->enterS(h,strat->sl+1,strat,strat->tl+1);
2005  }
2006  #if 1
2007  h.p1 = p;h.p2 = strat->S[i];
2008  #endif
2009  if (atR >= 0)
2010  {
2011  h.i_r2 = strat->S_2_R[i];
2012  h.i_r1 = atR;
2013  }
2014  else
2015  {
2016  h.i_r1 = -1;
2017  h.i_r2 = -1;
2018  }
2019  if (strat->Ll==-1)
2020  posx =0;
2021  else
2022  posx = strat->posInLSba(strat->L,strat->Ll,&h,strat);
2023  enterL(&strat->L,&strat->Ll,&strat->Lmax,h,posx);
2024  return TRUE;
2025 }

◆ enterpairs()

void enterpairs ( poly  h,
int  k,
int  ecart,
int  pos,
kStrategy  strat,
int  atR 
)

Definition at line 4587 of file kutil.cc.

4588 {
4589  int j=pos;
4590 
4592  initenterpairs(h,k,ecart,0,strat, atR);
4593  if ( (!strat->fromT)
4594  && ((strat->syzComp==0)
4595  ||(pGetComp(h)<=strat->syzComp)))
4596  {
4597  unsigned long h_sev = pGetShortExpVector(h);
4598  loop
4599  {
4600  if (j > k) break;
4601  clearS(h,h_sev, &j,&k,strat);
4602  j++;
4603  }
4604  }
4605 }
void initenterpairs(poly h, int k, int ecart, int isFromQ, kStrategy strat, int atR)
Definition: kutil.cc:3902

◆ enterpairsShift()

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

Definition at line 13420 of file kutil.cc.

13421 {
13422  /* h is strat->P.p, that is LObject with LM in currRing and Tail in tailRing */
13423  /* Q: what is exactly the strat->fromT ? A: a local case trick; don't need it yet*/
13424  int j=pos;
13425 
13426  /* if (!(rField_is_Domain(currRing))) enterExtendedSpoly(h, strat); */ // TODO: enterExtendedSpoly not for LP yet
13427  initenterpairsShift(h,k,ecart,0,strat, atR);
13428  if ( (!strat->fromT)
13429  && ((strat->syzComp==0)
13430  ||(pGetComp(h)<=strat->syzComp)))
13431  {
13432  unsigned long h_sev = pGetShortExpVector(h);
13433  loop
13434  {
13435  if (j > k) break;
13436  // TODO this currently doesn't clear all possible elements because of commutative division
13437  if (!(strat->rightGB && strat->fromQ != NULL && strat->fromQ[j]))
13438  clearS(h,h_sev, &j,&k,strat);
13439  j++;
13440  }
13441  }
13442 }
char rightGB
Definition: kutil.h:369
void initenterpairsShift(poly h, int k, int ecart, int isFromQ, kStrategy strat, int atR)
Definition: kutil.cc:12968

◆ enterpairsSig()

void enterpairsSig ( poly  h,
poly  hSig,
int  hFrom,
int  k,
int  ecart,
int  pos,
kStrategy  strat,
int  atR 
)

Definition at line 4613 of file kutil.cc.

4614 {
4615  int j=pos;
4617  initenterpairsSig(h,hSig,hFrom,k,ecart,0,strat, atR);
4618  if ( (!strat->fromT)
4619  && ((strat->syzComp==0)
4620  ||(pGetComp(h)<=strat->syzComp)))
4621  {
4622  unsigned long h_sev = pGetShortExpVector(h);
4623  loop
4624  {
4625  if (j > k) break;
4626  clearS(h,h_sev, &j,&k,strat);
4627  j++;
4628  }
4629  }
4630 }
void initenterpairsSig(poly h, poly hSig, int hFrom, int k, int ecart, int isFromQ, kStrategy strat, int atR=-1)
Definition: kutil.cc:3967

◆ enterpairsSpecial()

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

Definition at line 4636 of file kutil.cc.

4637 {
4638  int j;
4639  const int iCompH = pGetComp(h);
4640 
4641  if (rField_is_Ring(currRing))
4642  {
4643  for (j=0; j<=k; j++)
4644  {
4645  const int iCompSj = pGetComp(strat->S[j]);
4646  if ((iCompH==iCompSj)
4647  //|| (0==iCompH) // can only happen,if iCompSj==0
4648  || (0==iCompSj))
4649  {
4650  enterOnePairRing(j,h,ecart,FALSE,strat, atR);
4651  }
4652  }
4653  kMergeBintoL(strat);
4654  }
4655  else
4656  {
4657  for (j=0; j<=k; j++)
4658  {
4659  const int iCompSj = pGetComp(strat->S[j]);
4660  if ((iCompH==iCompSj)
4661  //|| (0==iCompH) // can only happen,if iCompSj==0
4662  || (0==iCompSj))
4663  {
4664  enterOnePairSpecial(j,h,ecart,strat, atR);
4665  }
4666  }
4667  }
4668 
4669  if (strat->noClearS) return;
4670 
4671 // #ifdef HAVE_PLURAL
4672 /*
4673  if (rIsPluralRing(currRing))
4674  {
4675  j=pos;
4676  loop
4677  {
4678  if (j > k) break;
4679 
4680  if (pLmDivisibleBy(h, strat->S[j]))
4681  {
4682  deleteInS(j, strat);
4683  j--;
4684  k--;
4685  }
4686 
4687  j++;
4688  }
4689  }
4690  else
4691 */
4692 // #endif // ??? Why was the following cancelation disabled for non-commutative rings?
4693  {
4694  j=pos;
4695  loop
4696  {
4697  unsigned long h_sev = pGetShortExpVector(h);
4698  if (j > k) break;
4699  clearS(h,h_sev,&j,&k,strat);
4700  j++;
4701  }
4702  }
4703 }
char noClearS
Definition: kutil.h:402
static void enterOnePairRing(int i, poly p, int, int isFromQ, kStrategy strat, int atR)
Definition: kutil.cc:1426
void enterOnePairSpecial(int i, poly p, int ecart, kStrategy strat, int atR=-1)
Definition: kutil.cc:3185

◆ enterSBba()

void enterSBba ( LObject p,
int  atS,
kStrategy  strat,
int  atR 
)

Definition at line 9101 of file kutil.cc.

9102 {
9103  strat->news = TRUE;
9104  /*- puts p to the standardbasis s at position at -*/
9105  if (strat->sl == IDELEMS(strat->Shdl)-1)
9106  {
9107  strat->sevS = (unsigned long*) omRealloc0Size(strat->sevS,
9108  IDELEMS(strat->Shdl)*sizeof(unsigned long),
9109  (IDELEMS(strat->Shdl)+setmaxTinc)
9110  *sizeof(unsigned long));
9111  strat->ecartS = (intset)omReallocSize(strat->ecartS,
9112  IDELEMS(strat->Shdl)*sizeof(int),
9113  (IDELEMS(strat->Shdl)+setmaxTinc)
9114  *sizeof(int));
9115  strat->S_2_R = (int*) omRealloc0Size(strat->S_2_R,
9116  IDELEMS(strat->Shdl)*sizeof(int),
9117  (IDELEMS(strat->Shdl)+setmaxTinc)
9118  *sizeof(int));
9119  if (strat->lenS!=NULL)
9120  strat->lenS=(int*)omRealloc0Size(strat->lenS,
9121  IDELEMS(strat->Shdl)*sizeof(int),
9122  (IDELEMS(strat->Shdl)+setmaxTinc)
9123  *sizeof(int));
9124  if (strat->lenSw!=NULL)
9125  strat->lenSw=(wlen_type*)omRealloc0Size(strat->lenSw,
9126  IDELEMS(strat->Shdl)*sizeof(wlen_type),
9127  (IDELEMS(strat->Shdl)+setmaxTinc)
9128  *sizeof(wlen_type));
9129  if (strat->fromQ!=NULL)
9130  {
9131  strat->fromQ = (intset)omReallocSize(strat->fromQ,
9132  IDELEMS(strat->Shdl)*sizeof(int),
9133  (IDELEMS(strat->Shdl)+setmaxTinc)*sizeof(int));
9134  }
9135  pEnlargeSet(&strat->S,IDELEMS(strat->Shdl),setmaxTinc);
9136  IDELEMS(strat->Shdl)+=setmaxTinc;
9137  strat->Shdl->m=strat->S;
9138  }
9139  if (atS <= strat->sl)
9140  {
9141 #ifdef ENTER_USE_MEMMOVE
9142  memmove(&(strat->S[atS+1]), &(strat->S[atS]),
9143  (strat->sl - atS + 1)*sizeof(poly));
9144  memmove(&(strat->ecartS[atS+1]), &(strat->ecartS[atS]),
9145  (strat->sl - atS + 1)*sizeof(int));
9146  memmove(&(strat->sevS[atS+1]), &(strat->sevS[atS]),
9147  (strat->sl - atS + 1)*sizeof(unsigned long));
9148  memmove(&(strat->S_2_R[atS+1]), &(strat->S_2_R[atS]),
9149  (strat->sl - atS + 1)*sizeof(int));
9150  if (strat->lenS!=NULL)
9151  memmove(&(strat->lenS[atS+1]), &(strat->lenS[atS]),
9152  (strat->sl - atS + 1)*sizeof(int));
9153  if (strat->lenSw!=NULL)
9154  memmove(&(strat->lenSw[atS+1]), &(strat->lenSw[atS]),
9155  (strat->sl - atS + 1)*sizeof(wlen_type));
9156 #else
9157  for (i=strat->sl+1; i>=atS+1; i--)
9158  {
9159  strat->S[i] = strat->S[i-1];
9160  strat->ecartS[i] = strat->ecartS[i-1];
9161  strat->sevS[i] = strat->sevS[i-1];
9162  strat->S_2_R[i] = strat->S_2_R[i-1];
9163  }
9164  if (strat->lenS!=NULL)
9165  for (i=strat->sl+1; i>=atS+1; i--)
9166  strat->lenS[i] = strat->lenS[i-1];
9167  if (strat->lenSw!=NULL)
9168  for (i=strat->sl+1; i>=atS+1; i--)
9169  strat->lenSw[i] = strat->lenSw[i-1];
9170 #endif
9171  }
9172  if (strat->fromQ!=NULL)
9173  {
9174 #ifdef ENTER_USE_MEMMOVE
9175  memmove(&(strat->fromQ[atS+1]), &(strat->fromQ[atS]),
9176  (strat->sl - atS + 1)*sizeof(int));
9177 #else
9178  for (i=strat->sl+1; i>=atS+1; i--)
9179  {
9180  strat->fromQ[i] = strat->fromQ[i-1];
9181  }
9182 #endif
9183  strat->fromQ[atS]=0;
9184  }
9185 
9186  /*- save result -*/
9187  poly pp=p.p;
9188  strat->S[atS] = pp;
9189  if (strat->honey) strat->ecartS[atS] = p.ecart;
9190  if (p.sev == 0)
9191  p.sev = pGetShortExpVector(pp);
9192  else
9193  assume(p.sev == pGetShortExpVector(pp));
9194  strat->sevS[atS] = p.sev;
9195  strat->ecartS[atS] = p.ecart;
9196  strat->S_2_R[atS] = atR;
9197  strat->sl++;
9198 }
CanonicalForm FACTORY_PUBLIC pp(const CanonicalForm &)
CanonicalForm pp ( const CanonicalForm & f )
Definition: cf_gcd.cc:676
char news
Definition: kutil.h:400
char honey
Definition: kutil.h:377
ideal Shdl
Definition: kutil.h:303
#define setmaxTinc
Definition: kutil.h:34
int * intset
Definition: kutil.h:53
void pEnlargeSet(poly **p, int l, int increment)
Definition: p_polys.cc:3812

◆ enterSBbaShift()

void enterSBbaShift ( LObject p,
int  atS,
kStrategy  strat,
int  atR 
)

Definition at line 9201 of file kutil.cc.

9202 {
9203  enterSBba(p, atS, strat, atR);
9204 
9205  int maxPossibleShift = p_mLPmaxPossibleShift(p.p, strat->tailRing);
9206  for (int i = maxPossibleShift; i > 0; i--)
9207  {
9208  // NOTE: don't use "shared tails" here. In rare cases it can cause problems
9209  // in `kNF2` because of lazy poly normalizations.
9210  LObject qq(p_Copy(p.p, strat->tailRing));
9211  p_mLPshift(qq.p, i, strat->tailRing);
9212  qq.shift = i;
9213  strat->initEcart(&qq); // initEcartBBA sets length, pLength, FDeg and ecart
9214  int atS = posInS(strat, strat->sl, qq.p, qq.ecart); // S needs to stay sorted because this is for example assumed when searching S later
9215  enterSBba(qq, atS, strat, -1);
9216  }
9217 }
int posInS(const kStrategy strat, const int length, const poly p, const int ecart_p)
Definition: kutil.cc:4763
void enterSBba(LObject &p, int atS, kStrategy strat, int atR)
Definition: kutil.cc:9101
int p_mLPmaxPossibleShift(poly p, const ring r)
Definition: shiftgb.cc:45
void p_mLPshift(poly m, int sh, const ring ri)
Definition: shiftop.cc:362

◆ enterSMora()

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

Definition at line 1615 of file kstd1.cc.

1616 {
1617  enterSBba(p, atS, strat, atR);
1618  #ifdef KDEBUG
1619  if (TEST_OPT_DEBUG)
1620  {
1621  Print("new s%d:",atS);
1622  p_wrp(p.p,currRing,strat->tailRing);
1623  PrintLn();
1624  }
1625  #endif
1626  HEckeTest(p.p,strat);
1627  if (strat->kAllAxis)
1628  {
1629  if (newHEdge(strat))
1630  {
1631  firstUpdate(strat);
1632  if (TEST_OPT_FINDET)
1633  return;
1634 
1635  /*- cuts elements in L above noether and reorders L -*/
1636  updateLHC(strat);
1637  /*- reorders L with respect to posInL -*/
1638  reorderL(strat);
1639  }
1640  }
1641  else if ((strat->kNoether==NULL)
1642  && (TEST_OPT_FASTHC))
1643  {
1644  if (strat->posInLOldFlag)
1645  {
1646  missingAxis(&strat->lastAxis,strat);
1647  if (strat->lastAxis)
1648  {
1649  strat->posInLOld = strat->posInL;
1650  strat->posInLOldFlag = FALSE;
1651  strat->posInL = posInL10;
1652  strat->posInLDependsOnLength = TRUE;
1653  updateL(strat);
1654  reorderL(strat);
1655  }
1656  }
1657  else if (strat->lastAxis)
1658  updateL(strat);
1659  }
1660 }
char posInLOldFlag
Definition: kutil.h:382
int lastAxis
Definition: kutil.h:355
int(* posInLOld)(const LSet Ls, const int Ll, LObject *Lo, const kStrategy strat)
Definition: kutil.h:288
char kAllAxis
Definition: kutil.h:376
char posInLDependsOnLength
Definition: kutil.h:389
void firstUpdate(kStrategy strat)
Definition: kstd1.cc:1548
void updateLHC(kStrategy strat)
Definition: kstd1.cc:1456
void missingAxis(int *last, kStrategy strat)
Definition: kstd1.cc:1271
void reorderL(kStrategy strat)
Definition: kstd1.cc:1213
int posInL10(const LSet set, const int length, LObject *p, const kStrategy strat)
Definition: kstd1.cc:1352
void updateL(kStrategy strat)
Definition: kstd1.cc:1385
void HEckeTest(poly pp, kStrategy strat)
Definition: kutil.cc:505
BOOLEAN newHEdge(kStrategy strat)
Definition: kutil.cc:10735
#define TEST_OPT_FINDET
Definition: options.h:112
#define TEST_OPT_FASTHC
Definition: options.h:110

◆ enterSMoraNF()

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

Definition at line 1668 of file kstd1.cc.

1669 {
1670  enterSBba(p, atS, strat, atR);
1671  if ((!strat->kAllAxis) || (strat->kNoether!=NULL)) HEckeTest(p.p,strat);
1672  if (strat->kAllAxis)
1673  newHEdge(strat);
1674 }

◆ enterSSba()

void enterSSba ( LObject p,
int  atS,
kStrategy  strat,
int  atR 
)

Definition at line 9224 of file kutil.cc.

9225 {
9226  strat->news = TRUE;
9227  /*- puts p to the standardbasis s at position at -*/
9228  if (strat->sl == IDELEMS(strat->Shdl)-1)
9229  {
9230  strat->sevS = (unsigned long*) omRealloc0Size(strat->sevS,
9231  IDELEMS(strat->Shdl)*sizeof(unsigned long),
9232  (IDELEMS(strat->Shdl)+setmax)
9233  *sizeof(unsigned long));
9234  strat->sevSig = (unsigned long*) omRealloc0Size(strat->sevSig,
9235  IDELEMS(strat->Shdl)*sizeof(unsigned long),
9236  (IDELEMS(strat->Shdl)+setmax)
9237  *sizeof(unsigned long));
9238  strat->ecartS = (intset)omReallocSize(strat->ecartS,
9239  IDELEMS(strat->Shdl)*sizeof(int),
9240  (IDELEMS(strat->Shdl)+setmax)
9241  *sizeof(int));
9242  strat->S_2_R = (int*) omRealloc0Size(strat->S_2_R,
9243  IDELEMS(strat->Shdl)*sizeof(int),
9244  (IDELEMS(strat->Shdl)+setmax)
9245  *sizeof(int));
9246  if (strat->lenS!=NULL)
9247  strat->lenS=(int*)omRealloc0Size(strat->lenS,
9248  IDELEMS(strat->Shdl)*sizeof(int),
9249  (IDELEMS(strat->Shdl)+setmax)
9250  *sizeof(int));
9251  if (strat->lenSw!=NULL)
9252  strat->lenSw=(wlen_type*)omRealloc0Size(strat->lenSw,
9253  IDELEMS(strat->Shdl)*sizeof(wlen_type),
9254  (IDELEMS(strat->Shdl)+setmax)
9255  *sizeof(wlen_type));
9256  if (strat->fromQ!=NULL)
9257  {
9258  strat->fromQ = (intset)omReallocSize(strat->fromQ,
9259  IDELEMS(strat->Shdl)*sizeof(int),
9260  (IDELEMS(strat->Shdl)+setmax)*sizeof(int));
9261  }
9262  pEnlargeSet(&strat->S,IDELEMS(strat->Shdl),setmax);
9263  pEnlargeSet(&strat->sig,IDELEMS(strat->Shdl),setmax);
9264  IDELEMS(strat->Shdl)+=setmax;
9265  strat->Shdl->m=strat->S;
9266  }
9267  // in a signature-based algorithm the following situation will never
9268  // appear due to the fact that the critical pairs are already sorted
9269  // by increasing signature.
9270  // True. However, in the case of integers we need to put the element
9271  // that caused the signature drop on the first position
9272  if (atS <= strat->sl)
9273  {
9274 #ifdef ENTER_USE_MEMMOVE
9275  memmove(&(strat->S[atS+1]), &(strat->S[atS]),
9276  (strat->sl - atS + 1)*sizeof(poly));
9277  memmove(&(strat->sig[atS+1]), &(strat->sig[atS]),
9278  (strat->sl - atS + 1)*sizeof(poly));
9279  memmove(&(strat->sevSig[atS+1]), &(strat->sevSig[atS]),
9280  (strat->sl - atS + 1)*sizeof(unsigned long));
9281  memmove(&(strat->ecartS[atS+1]), &(strat->ecartS[atS]),
9282  (strat->sl - atS + 1)*sizeof(int));
9283  memmove(&(strat->sevS[atS+1]), &(strat->sevS[atS]),
9284  (strat->sl - atS + 1)*sizeof(unsigned long));
9285  memmove(&(strat->S_2_R[atS+1]), &(strat->S_2_R[atS]),
9286  (strat->sl - atS + 1)*sizeof(int));
9287  if (strat->lenS!=NULL)
9288  memmove(&(strat->lenS[atS+1]), &(strat->lenS[atS]),
9289  (strat->sl - atS + 1)*sizeof(int));
9290  if (strat->lenSw!=NULL)
9291  memmove(&(strat->lenSw[atS+1]), &(strat->lenSw[atS]),
9292  (strat->sl - atS + 1)*sizeof(wlen_type));
9293 #else
9294  for (i=strat->sl+1; i>=atS+1; i--)
9295  {
9296  strat->S[i] = strat->S[i-1];
9297  strat->ecartS[i] = strat->ecartS[i-1];
9298  strat->sevS[i] = strat->sevS[i-1];
9299  strat->S_2_R[i] = strat->S_2_R[i-1];
9300  strat->sig[i] = strat->sig[i-1];
9301  strat->sevSig[i] = strat->sevSig[i-1];
9302  }
9303  if (strat->lenS!=NULL)
9304  for (i=strat->sl+1; i>=atS+1; i--)
9305  strat->lenS[i] = strat->lenS[i-1];
9306  if (strat->lenSw!=NULL)
9307  for (i=strat->sl+1; i>=atS+1; i--)
9308  strat->lenSw[i] = strat->lenSw[i-1];
9309 #endif
9310  }
9311  if (strat->fromQ!=NULL)
9312  {
9313 #ifdef ENTER_USE_MEMMOVE
9314  memmove(&(strat->fromQ[atS+1]), &(strat->fromQ[atS]),
9315  (strat->sl - atS + 1)*sizeof(int));
9316 #else
9317  for (i=strat->sl+1; i>=atS+1; i--)
9318  {
9319  strat->fromQ[i] = strat->fromQ[i-1];
9320  }
9321 #endif
9322  strat->fromQ[atS]=0;
9323  }
9324 
9325  /*- save result -*/
9326  strat->S[atS] = p.p;
9327  strat->sig[atS] = p.sig; // TODO: get ths correct signature in here!
9328  if (strat->honey) strat->ecartS[atS] = p.ecart;
9329  if (p.sev == 0)
9330  p.sev = pGetShortExpVector(p.p);
9331  else
9332  assume(p.sev == pGetShortExpVector(p.p));
9333  strat->sevS[atS] = p.sev;
9334  // during the interreduction process of a signature-based algorithm we do not
9335  // compute the signature at this point, but when the whole interreduction
9336  // process finishes, i.e. f5c terminates!
9337  if (p.sig != NULL)
9338  {
9339  if (p.sevSig == 0)
9340  p.sevSig = pGetShortExpVector(p.sig);
9341  else
9342  assume(p.sevSig == pGetShortExpVector(p.sig));
9343  strat->sevSig[atS] = p.sevSig; // TODO: get the correct signature in here!
9344  }
9345  strat->ecartS[atS] = p.ecart;
9346  strat->S_2_R[atS] = atR;
9347  strat->sl++;
9348 #ifdef DEBUGF5
9349  int k;
9350  Print("--- LIST S: %d ---\n",strat->sl);
9351  for(k=0;k<=strat->sl;k++)
9352  {
9353  pWrite(strat->sig[k]);
9354  }
9355  PrintS("--- LIST S END ---\n");
9356 #endif
9357 }
#define setmax
Definition: kutil.h:29

◆ enterSyz()

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

Definition at line 9652 of file kutil.cc.

9653 {
9654  int i;
9655  strat->newt = TRUE;
9656  if (strat->syzl == strat->syzmax-1)
9657  {
9658  pEnlargeSet(&strat->syz,strat->syzmax,setmax);
9659  strat->sevSyz = (unsigned long*) omRealloc0Size(strat->sevSyz,
9660  (strat->syzmax)*sizeof(unsigned long),
9661  ((strat->syzmax)+setmax)
9662  *sizeof(unsigned long));
9663  strat->syzmax += setmax;
9664  }
9665  if (atT < strat->syzl)
9666  {
9667 #ifdef ENTER_USE_MEMMOVE
9668  memmove(&(strat->syz[atT+1]), &(strat->syz[atT]),
9669  (strat->syzl-atT+1)*sizeof(poly));
9670  memmove(&(strat->sevSyz[atT+1]), &(strat->sevSyz[atT]),
9671  (strat->syzl-atT+1)*sizeof(unsigned long));
9672 #endif
9673  for (i=strat->syzl; i>=atT+1; i--)
9674  {
9675 #ifndef ENTER_USE_MEMMOVE
9676  strat->syz[i] = strat->syz[i-1];
9677  strat->sevSyz[i] = strat->sevSyz[i-1];
9678 #endif
9679  }
9680  }
9681  //i = strat->syzl;
9682  i = atT;
9683  //Makes sure the syz saves just the signature
9684  #ifdef HAVE_RINGS
9686  pNext(p.sig) = NULL;
9687  #endif
9688  strat->syz[atT] = p.sig;
9689  strat->sevSyz[atT] = p.sevSig;
9690  strat->syzl++;
9691 #if F5DEBUG
9692  Print("element in strat->syz: %d--%d ",atT+1,strat->syzmax);
9693  pWrite(strat->syz[atT]);
9694 #endif
9695  // recheck pairs in strat->L with new rule and delete correspondingly
9696  int cc = strat->Ll;
9697  while (cc>-1)
9698  {
9699  //printf("\nCheck if syz is div by L\n");pWrite(strat->syz[atT]);pWrite(strat->L[cc].sig);
9700  //printf("\npLmShDivBy(syz,L) = %i\nn_DivBy(L,syz) = %i\n pLtCmp(L,syz) = %i",p_LmShortDivisibleBy( strat->syz[atT], strat->sevSyz[atT],strat->L[cc].sig, ~strat->L[cc].sevSig, currRing), n_DivBy(pGetCoeff(strat->L[cc].sig),pGetCoeff(strat->syz[atT]),currRing), pLtCmp(strat->L[cc].sig,strat->syz[atT])==1);
9701  if (p_LmShortDivisibleBy( strat->syz[atT], strat->sevSyz[atT],
9702  strat->L[cc].sig, ~strat->L[cc].sevSig, currRing)
9703  #ifdef HAVE_RINGS
9704  &&((!rField_is_Ring(currRing))
9705  || (n_DivBy(pGetCoeff(strat->L[cc].sig),pGetCoeff(strat->syz[atT]),currRing->cf) && (pLtCmp(strat->L[cc].sig,strat->syz[atT])==1)))
9706  #endif
9707  )
9708  {
9709  //printf("\nYES!\n");
9710  deleteInL(strat->L,&strat->Ll,cc,strat);
9711  }
9712  cc--;
9713  }
9714 //#if 1
9715 #ifdef DEBUGF5
9716  PrintS("--- Syzygies ---\n");
9717  Print("syzl %d\n",strat->syzl);
9718  Print("syzmax %d\n",strat->syzmax);
9719  PrintS("--------------------------------\n");
9720  for(i=0;i<=strat->syzl-1;i++)
9721  {
9722  Print("%d - ",i);
9723  pWrite(strat->syz[i]);
9724  }
9725  PrintS("--------------------------------\n");
9726 #endif
9727 }
unsigned long * sevSyz
Definition: kutil.h:323
int syzmax
Definition: kutil.h:349
int syzl
Definition: kutil.h:349
polyset syz
Definition: kutil.h:307
char newt
Definition: kutil.h:401

◆ enterT()

void enterT ( LObject p,
kStrategy  strat,
int  atT 
)

Definition at line 9450 of file kutil.cc.

9451 {
9452  int i;
9453 
9454 #ifdef PDEBUG
9455 #ifdef HAVE_SHIFTBBA
9456  if (currRing->isLPring && p.shift > 0)
9457  {
9458  // in this case, the order is not correct. test LM and tail separately
9459  p_LmTest(p.p, currRing);
9460  p_Test(pNext(p.p), currRing);
9461  }
9462  else
9463 #endif
9464  {
9465  pp_Test(p.p, currRing, p.tailRing);
9466  }
9467 #endif
9468  assume(strat->tailRing == p.tailRing);
9469  // redMoraNF complains about this -- but, we don't really
9470  // neeed this so far
9471  assume(p.pLength == 0 || pLength(p.p) == p.pLength || rIsSyzIndexRing(currRing)); // modulo syzring
9472  assume(!strat->homog || (p.FDeg == p.pFDeg()));
9473  assume(!p.is_normalized || nIsOne(pGetCoeff(p.p)));
9474 
9475 #ifdef KDEBUG
9476  // do not put an LObject twice into T:
9477  for(i=strat->tl;i>=0;i--)
9478  {
9479  if (p.p==strat->T[i].p)
9480  {
9481  printf("already in T at pos %d of %d, atT=%d\n",i,strat->tl,atT);
9482  return;
9483  }
9484  }
9485 #endif
9486 
9487 #ifdef HAVE_TAIL_RING
9488  if (currRing!=strat->tailRing)
9489  {
9490  p.t_p=p.GetLmTailRing();
9491  }
9492 #endif
9493  strat->newt = TRUE;
9494  if (atT < 0)
9495  atT = strat->posInT(strat->T, strat->tl, p);
9496  if (strat->tl == strat->tmax-1)
9497  enlargeT(strat->T,strat->R,strat->sevT,strat->tmax,setmaxTinc);
9498  if (atT <= strat->tl)
9499  {
9500 #ifdef ENTER_USE_MEMMOVE
9501  memmove(&(strat->T[atT+1]), &(strat->T[atT]),
9502  (strat->tl-atT+1)*sizeof(TObject));
9503  memmove(&(strat->sevT[atT+1]), &(strat->sevT[atT]),
9504  (strat->tl-atT+1)*sizeof(unsigned long));
9505 #endif
9506  for (i=strat->tl+1; i>=atT+1; i--)
9507  {
9508 #ifndef ENTER_USE_MEMMOVE
9509  strat->T[i] = strat->T[i-1];
9510  strat->sevT[i] = strat->sevT[i-1];
9511 #endif
9512  strat->R[strat->T[i].i_r] = &(strat->T[i]);
9513  }
9514  }
9515 
9516  if ((strat->tailBin != NULL) && (pNext(p.p) != NULL))
9517  {
9518 #ifdef HAVE_SHIFTBBA
9519  // letterplace: if p.shift > 0 then pNext(p.p) is already in the tailBin
9520  if (!(currRing->isLPring && p.shift > 0))
9521 #endif
9522  {
9524  (strat->tailRing != NULL ?
9525  strat->tailRing : currRing),
9526  strat->tailBin);
9527  if (p.t_p != NULL) pNext(p.t_p) = pNext(p.p);
9528  }
9529  }
9530  strat->T[atT] = (TObject) p;
9531  //printf("\nenterT: add new: length = %i, ecart = %i\n",p.length,p.ecart);
9532 
9533  if ((pNext(p.p) != NULL) && (!rIsLPRing(currRing)))
9534  strat->T[atT].max_exp = p_GetMaxExpP(pNext(p.p), strat->tailRing);
9535  else
9536  strat->T[atT].max_exp = NULL;
9537 
9538  strat->tl++;
9539  strat->R[strat->tl] = &(strat->T[atT]);
9540  strat->T[atT].i_r = strat->tl;
9541  assume((p.sev == 0) || (pGetShortExpVector(p.p) == p.sev));
9542  strat->sevT[atT] = (p.sev == 0 ? pGetShortExpVector(p.p) : p.sev);
9543  kTest_T(&(strat->T[atT]),strat);
9544 }
TObject ** R
Definition: kutil.h:340
unsigned long * sevT
Definition: kutil.h:325
int tmax
Definition: kutil.h:350
omBin tailBin
Definition: kutil.h:345
int(* posInT)(const TSet T, const int tl, LObject &h)
Definition: kutil.h:281
char homog
Definition: kutil.h:372
static void enlargeT(TSet &T, TObject **&R, unsigned long *&sevT, int &length, const int incr)
Definition: kutil.cc:548
BOOLEAN kTest_T(TObject *T, kStrategy strat, int i, char TN)
Definition: kutil.cc:825
#define pp_Test(p, lmRing, tailRing)
Definition: p_polys.h:164
static poly p_ShallowCopyDelete(poly p, const ring r, omBin bin)
Definition: p_polys.h:930
#define p_LmTest(p, r)
Definition: p_polys.h:163
static BOOLEAN rIsSyzIndexRing(const ring r)
Definition: ring.h:721

◆ enterT_strong()

void enterT_strong ( LObject p,
kStrategy  strat,
int  atT 
)

Definition at line 9550 of file kutil.cc.

9551 {
9553  int i;
9554 
9555  pp_Test(p.p, currRing, p.tailRing);
9556  assume(strat->tailRing == p.tailRing);
9557  // redMoraNF complains about this -- but, we don't really
9558  // neeed this so far
9559  assume(p.pLength == 0 || (int)pLength(p.p) == p.pLength || rIsSyzIndexRing(currRing)); // modulo syzring
9560  assume(p.FDeg == p.pFDeg());
9561  assume(!p.is_normalized || nIsOne(pGetCoeff(p.p)));
9562 
9563 #ifdef KDEBUG
9564  // do not put an LObject twice into T:
9565  for(i=strat->tl;i>=0;i--)
9566  {
9567  if (p.p==strat->T[i].p)
9568  {
9569  printf("already in T at pos %d of %d, atT=%d\n",i,strat->tl,atT);
9570  return;
9571  }
9572  }
9573 #endif
9574 
9575 #ifdef HAVE_TAIL_RING
9576  if (currRing!=strat->tailRing)
9577  {
9578  p.t_p=p.GetLmTailRing();
9579  }
9580 #endif
9581  strat->newt = TRUE;
9582  if (atT < 0)
9583  atT = strat->posInT(strat->T, strat->tl, p);
9584  if (strat->tl == strat->tmax-1)
9585  enlargeT(strat->T,strat->R,strat->sevT,strat->tmax,setmaxTinc);
9586  if (atT <= strat->tl)
9587  {
9588 #ifdef ENTER_USE_MEMMOVE
9589  memmove(&(strat->T[atT+1]), &(strat->T[atT]),
9590  (strat->tl-atT+1)*sizeof(TObject));
9591  memmove(&(strat->sevT[atT+1]), &(strat->sevT[atT]),
9592  (strat->tl-atT+1)*sizeof(unsigned long));
9593 #endif
9594  for (i=strat->tl+1; i>=atT+1; i--)
9595  {
9596 #ifndef ENTER_USE_MEMMOVE
9597  strat->T[i] = strat->T[i-1];
9598  strat->sevT[i] = strat->sevT[i-1];
9599 #endif
9600  strat->R[strat->T[i].i_r] = &(strat->T[i]);
9601  }
9602  }
9603 
9604  if ((strat->tailBin != NULL) && (pNext(p.p) != NULL))
9605  {
9607  (strat->tailRing != NULL ?
9608  strat->tailRing : currRing),
9609  strat->tailBin);
9610  if (p.t_p != NULL) pNext(p.t_p) = pNext(p.p);
9611  }
9612  strat->T[atT] = (TObject) p;
9613  //printf("\nenterT_strong: add new: length = %i, ecart = %i\n",p.length,p.ecart);
9614 
9615  if (pNext(p.p) != NULL)
9616  strat->T[atT].max_exp = p_GetMaxExpP(pNext(p.p), strat->tailRing);
9617  else
9618  strat->T[atT].max_exp = NULL;
9619 
9620  strat->tl++;
9621  strat->R[strat->tl] = &(strat->T[atT]);
9622  strat->T[atT].i_r = strat->tl;
9623  assume(p.sev == 0 || pGetShortExpVector(p.p) == p.sev);
9624  strat->sevT[atT] = (p.sev == 0 ? pGetShortExpVector(p.p) : p.sev);
9625  #if 1
9627  && !n_IsUnit(p.p->coef, currRing->cf))
9628  {
9629  for(i=strat->tl;i>=0;i--)
9630  {
9631  if(strat->T[i].ecart <= p.ecart && pLmDivisibleBy(strat->T[i].p,p.p))
9632  {
9633  enterOneStrongPoly(i,p.p,p.ecart,0,strat,0 , TRUE);
9634  }
9635  }
9636  }
9637  /*
9638  printf("\nThis is T:\n");
9639  for(i=strat->tl;i>=0;i--)
9640  {
9641  pWrite(strat->T[i].p);
9642  }
9643  //getchar();*/
9644  #endif
9645  kTest_T(&(strat->T[atT]),strat);
9646 }
static FORCE_INLINE BOOLEAN n_IsUnit(number n, const coeffs r)
TRUE iff n has a multiplicative inverse in the given coeff field/ring r.
Definition: coeffs.h:515
static BOOLEAN enterOneStrongPoly(int i, poly p, int, int, kStrategy strat, int atR, bool enterTstrong)
Definition: kutil.cc:1630
#define pLmDivisibleBy(a, b)
like pDivisibleBy, except that it is assumed that a!=NULL, b!=NULL
Definition: polys.h:140

◆ enterTShift()

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

Definition at line 13450 of file kutil.cc.

13451 {
13452  /* determine how many elements we have to insert */
13453  /* x(0)y(1)z(2) : lastVblock-1=2, to add until lastVblock=uptodeg-1 */
13454  /* hence, a total number of elt's to add is: */
13455  /* int toInsert = 1 + (uptodeg-1) - (pLastVblock(p.p, lV) -1); */
13456  pAssume(p.p != NULL);
13457 
13458  int maxPossibleShift = p_mLPmaxPossibleShift(p.p, strat->tailRing);
13459 
13460  for (int i = 1; i <= maxPossibleShift; i++)
13461  {
13462  LObject qq;
13463  qq.p = pLPCopyAndShiftLM(p.p, i); // don't use Set() because it'll test the poly order
13464  qq.shift = i;
13465  strat->initEcart(&qq); // initEcartBBA sets length, pLength, FDeg and ecart
13466 
13467  enterT(qq, strat, atT); // enterT is modified, so it doesn't copy and delete the tail of shifted polys
13468  }
13469 }
#define pAssume(cond)
Definition: monomials.h:90

◆ exitBuchMora()

void exitBuchMora ( kStrategy  strat)

Definition at line 10158 of file kutil.cc.

10159 {
10160  /*- release temp data -*/
10161  cleanT(strat);
10162  omFreeSize(strat->T,(strat->tmax)*sizeof(TObject));
10163  omFreeSize(strat->R,(strat->tmax)*sizeof(TObject*));
10164  omFreeSize(strat->sevT, (strat->tmax)*sizeof(unsigned long));
10165  omFreeSize(strat->ecartS,IDELEMS(strat->Shdl)*sizeof(int));
10166  omFreeSize((ADDRESS)strat->sevS,IDELEMS(strat->Shdl)*sizeof(unsigned long));
10167  omFreeSize(strat->S_2_R,IDELEMS(strat->Shdl)*sizeof(int));
10168  /*- set L: should be empty -*/
10169  omFreeSize(strat->L,(strat->Lmax)*sizeof(LObject));
10170  /*- set B: should be empty -*/
10171  omFreeSize(strat->B,(strat->Bmax)*sizeof(LObject));
10172  pLmFree(&strat->tail);
10173  strat->syzComp=0;
10174 
10175 #ifdef HAVE_SHIFTBBA
10176  if (rIsLPRing(currRing) && strat->rightGB)
10177  {
10178  if (strat->fromQ!=NULL) omFreeSize(strat->fromQ,IDELEMS(strat->Shdl)*sizeof(int));
10179  strat->fromQ=NULL;
10180  }
10181 #endif
10182 }
void * ADDRESS
Definition: auxiliary.h:119
void cleanT(kStrategy strat)
Definition: kutil.cc:569

◆ exitSba()

void exitSba ( kStrategy  strat)

Definition at line 10361 of file kutil.cc.

10362 {
10363  /*- release temp data -*/
10365  cleanTSbaRing(strat);
10366  else
10367  cleanT(strat);
10368  omFreeSize(strat->T,(strat->tmax)*sizeof(TObject));
10369  omFreeSize(strat->R,(strat->tmax)*sizeof(TObject*));
10370  omFreeSize(strat->sevT, (strat->tmax)*sizeof(unsigned long));
10371  omFreeSize(strat->ecartS,IDELEMS(strat->Shdl)*sizeof(int));
10372  omFreeSize((ADDRESS)strat->sevS,IDELEMS(strat->Shdl)*sizeof(unsigned long));
10373  omFreeSize((ADDRESS)strat->sevSig,IDELEMS(strat->Shdl)*sizeof(unsigned long));
10374  if(strat->syzmax>0)
10375  {
10376  omFreeSize((ADDRESS)strat->syz,(strat->syzmax)*sizeof(poly));
10377  omFreeSize((ADDRESS)strat->sevSyz,(strat->syzmax)*sizeof(unsigned long));
10378  if (strat->sbaOrder == 1)
10379  {
10380  omFreeSize(strat->syzIdx,(strat->syzidxmax)*sizeof(int));
10381  }
10382  }
10383  omFreeSize(strat->S_2_R,IDELEMS(strat->Shdl)*sizeof(int));
10384  /*- set L: should be empty -*/
10385  omFreeSize(strat->L,(strat->Lmax)*sizeof(LObject));
10386  /*- set B: should be empty -*/
10387  omFreeSize(strat->B,(strat->Bmax)*sizeof(LObject));
10388  /*- set sig: no need for the signatures anymore -*/
10389  omFreeSize(strat->sig,IDELEMS(strat->Shdl)*sizeof(poly));
10390  pLmDelete(&strat->tail);
10391  strat->syzComp=0;
10392 }
int syzidxmax
Definition: kutil.h:349
intset syzIdx
Definition: kutil.h:313
unsigned sbaOrder
Definition: kutil.h:316
void cleanTSbaRing(kStrategy strat)
Definition: kutil.cc:628

◆ faugereRewCriterion()

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

Definition at line 6870 of file kutil.cc.

6871 {
6872  //printf("Faugere Rewritten Criterion\n");
6874  return FALSE;
6875 //#if 1
6876 #ifdef DEBUGF5
6877  PrintS("rewritten criterion checks: ");
6878  pWrite(sig);
6879 #endif
6880  for(int k = strat->sl; k>=start; k--)
6881  {
6882 //#if 1
6883 #ifdef DEBUGF5
6884  PrintS("checking with: ");
6885  pWrite(strat->sig[k]);
6886  pWrite(pHead(strat->S[k]));
6887 #endif
6888  if (p_LmShortDivisibleBy(strat->sig[k], strat->sevSig[k], sig, not_sevSig, currRing))
6889  {
6890 //#if 1
6891 #ifdef DEBUGF5
6892  PrintS("DELETE!\n");
6893 #endif
6894  strat->nrrewcrit++;
6895  return TRUE;
6896  }
6897  //k--;
6898  }
6899 #ifdef DEBUGF5
6900  PrintS("ALL ELEMENTS OF S\n----------------------------------------\n");
6901  for(int kk = 0; kk<strat->sl+1; kk++)
6902  {
6903  pWrite(pHead(strat->S[kk]));
6904  }
6905  PrintS("------------------------------\n");
6906 #endif
6907  return FALSE;
6908 }
int nrrewcrit
Definition: kutil.h:361

◆ finalReduceByMon()

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 11201 of file kutil.cc.

11202 {
11203  assume(strat->tl<0); /* can only be called with no elements in T:
11204  i.e. after exitBuchMora */
11205  /* do not use strat->S, strat->sl as they may be out of sync*/
11206  if(!nCoeff_is_Z(currRing->cf))
11207  return;
11208  poly p,pp;
11209  for(int j = 0; j<IDELEMS(strat->Shdl); j++)
11210  {
11211  if((strat->Shdl->m[j]!=NULL)&&(pNext(strat->Shdl->m[j]) == NULL))
11212  {
11213  for(int i = 0; i<IDELEMS(strat->Shdl); i++)
11214  {
11215  if((i != j) && (strat->Shdl->m[i] != NULL))
11216  {
11217  p = strat->Shdl->m[i];
11218  while((p!=NULL) && (pLmDivisibleBy(strat->Shdl->m[j], p)
11219 #if HAVE_SHIFTBBA
11220  || (rIsLPRing(currRing) && pLPLmDivisibleBy(strat->Shdl->m[j], p))
11221 #endif
11222  ))
11223  {
11224  number dummy = n_IntMod(p->coef, strat->Shdl->m[j]->coef, currRing->cf);
11225  if (!nEqual(dummy,p->coef))
11226  {
11227  if (nIsZero(dummy))
11228  {
11229  nDelete(&dummy);
11230  pLmDelete(&strat->Shdl->m[i]);
11231  p=strat->Shdl->m[i];
11232  }
11233  else
11234  {
11235  p_SetCoeff(p,dummy,currRing);
11236  break;
11237  }
11238  }
11239  else
11240  {
11241  nDelete(&dummy);
11242  break;
11243  }
11244  }
11245  if (p!=NULL)
11246  {
11247  pp = pNext(p);
11248  while(pp != NULL)
11249  {
11250  if(pLmDivisibleBy(strat->Shdl->m[j], pp)
11251 #if HAVE_SHIFTBBA
11252  || (rIsLPRing(currRing) && pLPLmDivisibleBy(strat->Shdl->m[j], pp))
11253 #endif
11254  )
11255  {
11256  number dummy = n_IntMod(pp->coef, strat->Shdl->m[j]->coef, currRing->cf);
11257  if (!nEqual(dummy,pp->coef))
11258  {
11259  p_SetCoeff(pp,dummy,currRing);
11260  if(nIsZero(pp->coef))
11261  {
11262  pLmDelete(&pNext(p));
11263  pp = pNext(p);
11264  }
11265  else
11266  {
11267  p = pp;
11268  pp = pNext(p);
11269  }
11270  }
11271  else
11272  {
11273  nDelete(&dummy);
11274  p = pp;
11275  pp = pNext(p);
11276  }
11277  }
11278  else
11279  {
11280  p = pp;
11281  pp = pNext(p);
11282  }
11283  }
11284  }
11285  }
11286  }
11287  //idPrint(strat->Shdl);
11288  }
11289  }
11290  idSkipZeroes(strat->Shdl);
11291 }
static FORCE_INLINE BOOLEAN nCoeff_is_Z(const coeffs r)
Definition: coeffs.h:816
static FORCE_INLINE number n_IntMod(number a, number b, const coeffs r)
for r a field, return n_Init(0,r) always: n_Div(a,b,r)*b+n_IntMod(a,b,r)==a n_IntMod(a,...
Definition: coeffs.h:628
#define nEqual(n1, n2)
Definition: numbers.h:20
static number p_SetCoeff(poly p, number n, ring r)
Definition: p_polys.h:414
#define pLPLmDivisibleBy(a, b)
Definition: shiftop.h:58
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size

◆ getIndexRng()

int getIndexRng ( long  coeff)
inline

Definition at line 6261 of file kutil.cc.

6262 {
6263  if (coeff == 0) return -1;
6264  long tmp = coeff;
6265  int ind = 0;
6266  while (tmp % 2 == 0)
6267  {
6268  tmp = tmp / 2;
6269  ind++;
6270  }
6271  return ind;
6272 }

◆ HEckeTest()

void HEckeTest ( poly  pp,
kStrategy  strat 
)

Definition at line 505 of file kutil.cc.

506 {
507  int j,/*k,*/p;
508 
509  if (currRing->pLexOrder
511  || (strat->ak >1)
513  {
514  return;
515  }
516  p=pIsPurePower(pp);
517  if (p!=0)
518  strat->NotUsedAxis[p] = FALSE;
519  /*- the leading term of pp is a power of the p-th variable -*/
520  for (j=(currRing->N);j>0; j--)
521  {
522  if (strat->NotUsedAxis[j])
523  {
524  strat->kAllAxis=FALSE;
525  return;
526  }
527  }
528  strat->kAllAxis=TRUE;
529 }
BOOLEAN * NotUsedAxis
Definition: kutil.h:332
#define pIsPurePower(p)
Definition: polys.h:248
BOOLEAN rHasMixedOrdering(const ring r)
Definition: ring.h:762

◆ initBuchMora()

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

Definition at line 10073 of file kutil.cc.

10074 {
10075  strat->interpt = BTEST1(OPT_INTERRUPT);
10076  /*- creating temp data structures------------------- -*/
10077  //strat->cp = 0; // already by skStragy()
10078  //strat->c3 = 0; // already by skStragy()
10079 #ifdef HAVE_SHIFTBBA
10080  strat->cv = 0; // already by skStragy()
10081 #endif
10082  strat->tail = pInit();
10083  /*- set s -*/
10084  strat->sl = -1;
10085  /*- set L -*/
10086  strat->Lmax = ((IDELEMS(F)+setmaxLinc-1)/setmaxLinc)*setmaxLinc;
10087  strat->Ll = -1;
10088  strat->L = initL(strat->Lmax);
10089  /*- set B -*/
10090  strat->Bmax = setmaxL;
10091  strat->Bl = -1;
10092  strat->B = initL();
10093  /*- set T -*/
10094  strat->tl = -1;
10095  strat->tmax = setmaxT;
10096  strat->T = initT();
10097  strat->R = initR();
10098  strat->sevT = initsevT();
10099  /*- init local data struct.---------------------------------------- -*/
10100  //strat->P.ecart=0; // already by skStragy()
10101  //strat->P.length=0; // already by skStragy()
10102  //strat->P.pLength=0; // already by skStragy()
10104  {
10105  if (strat->kNoether!=NULL)
10106  {
10107  pSetComp(strat->kNoether, strat->ak);
10108  pSetComp(strat->kNoetherTail(), strat->ak);
10109  }
10110  }
10112  {
10113  /*Shdl=*/initSL(F, Q,strat); /*sets also S, ecartS, fromQ */
10114  }
10115  else
10116  {
10117  if(TEST_OPT_SB_1)
10118  {
10119  int i;
10120  ideal P=idInit(IDELEMS(F)-strat->newIdeal,F->rank);
10121  for (i=strat->newIdeal;i<IDELEMS(F);i++)
10122  {
10123  P->m[i-strat->newIdeal] = F->m[i];
10124  F->m[i] = NULL;
10125  }
10126  initSSpecial(F,Q,P,strat);
10127  for (i=strat->newIdeal;i<IDELEMS(F);i++)
10128  {
10129  F->m[i] = P->m[i-strat->newIdeal];
10130  P->m[i-strat->newIdeal] = NULL;
10131  }
10132  idDelete(&P);
10133  }
10134  else
10135  {
10136  /*Shdl=*/initSL(F, Q,strat); /*sets also S, ecartS, fromQ */
10137  // /*Shdl=*/initS(F, Q,strat); /*sets also S, ecartS, fromQ */
10138  }
10139  }
10140  strat->fromT = FALSE;
10142  if ((!TEST_OPT_SB_1)
10143  || (rField_is_Ring(currRing))
10144  )
10145  {
10146  updateS(TRUE,strat);
10147  }
10148 #ifdef HAVE_SHIFTBBA
10149  if (!(rIsLPRing(currRing) && strat->rightGB)) // for right GB, we need to check later whether a poly is from Q
10150 #endif
10151  {
10152  if (strat->fromQ!=NULL) omFreeSize(strat->fromQ,IDELEMS(strat->Shdl)*sizeof(int));
10153  strat->fromQ=NULL;
10154  }
10155  assume(kTest_TS(strat));
10156 }
char interpt
Definition: kutil.h:371
int newIdeal
Definition: kutil.h:356
STATIC_VAR jList * Q
Definition: janet.cc:30
KINLINE unsigned long * initsevT()
Definition: kInline.h:100
KINLINE TSet initT()
Definition: kInline.h:84
KINLINE TObject ** initR()
Definition: kInline.h:95
void initSSpecial(ideal F, ideal Q, ideal P, kStrategy strat)
Definition: kutil.cc:8403
void updateS(BOOLEAN toT, kStrategy strat)
Definition: kutil.cc:8866
void initSL(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:8001
#define setmaxL
Definition: kutil.h:30
static LSet initL(int nr=setmaxL)
Definition: kutil.h:421
#define setmaxT
Definition: kutil.h:33
#define TEST_OPT_REDTAIL
Definition: options.h:117
#define TEST_OPT_SB_1
Definition: options.h:120
#define OPT_INTERRUPT
Definition: options.h:80
#define BTEST1(a)
Definition: options.h:34
#define pSetComp(p, v)
Definition: polys.h:38
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35

◆ initBuchMoraCrit()

void initBuchMoraCrit ( kStrategy  strat)

Definition at line 9748 of file kutil.cc.

9749 {
9751  strat->chainCrit=chainCritNormal;
9752  if (TEST_OPT_SB_1)
9753  strat->chainCrit=chainCritOpt_1;
9754 #ifdef HAVE_RINGS
9755  if (rField_is_Ring(currRing))
9756  {
9758  strat->chainCrit=chainCritRing;
9759  }
9760 #endif
9761 #ifdef HAVE_RATGRING
9762  if (rIsRatGRing(currRing))
9763  {
9764  strat->chainCrit=chainCritPart;
9765  /* enterOnePairNormal get rational part in it */
9766  }
9767 #endif
9768  if (TEST_OPT_IDLIFT
9769  && (strat->syzComp==1)
9770  && (!rIsPluralRing(currRing)))
9772 
9773  strat->sugarCrit = TEST_OPT_SUGARCRIT;
9774  strat->Gebauer = strat->homog || strat->sugarCrit;
9775  strat->honey = !strat->homog || strat->sugarCrit || TEST_OPT_WEIGHTM;
9776  if (TEST_OPT_NOT_SUGAR) strat->honey = FALSE;
9777  strat->pairtest = NULL;
9778  /* alway use tailreduction, except:
9779  * - in local rings, - in lex order case, -in ring over extensions */
9781  //if(rHasMixedOrdering(currRing)==2)
9782  //{
9783  // strat->noTailReduction =TRUE;
9784  //}
9785 
9786 #ifdef HAVE_PLURAL
9787  // and r is plural_ring
9788  // hence this holds for r a rational_plural_ring
9789  if( rIsPluralRing(currRing) || (rIsSCA(currRing) && !strat->z2homog) )
9790  { //or it has non-quasi-comm type... later
9791  strat->sugarCrit = FALSE;
9792  strat->Gebauer = FALSE;
9793  strat->honey = FALSE;
9794  }
9795 #endif
9796 
9797  // Coefficient ring?
9798  if (rField_is_Ring(currRing))
9799  {
9800  strat->sugarCrit = FALSE;
9801  strat->Gebauer = FALSE;
9802  strat->honey = FALSE;
9803  }
9804  #ifdef KDEBUG
9805  if (TEST_OPT_DEBUG)
9806  {
9807  if (strat->homog) PrintS("ideal/module is homogeneous\n");
9808  else PrintS("ideal/module is not homogeneous\n");
9809  }
9810  #endif
9811 }
void(* chainCrit)(poly p, int ecart, kStrategy strat)
Definition: kutil.h:291
char z2homog
Definition: kutil.h:374
void(* enterOnePair)(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR)
Definition: kutil.h:290
void enterOnePairNormal(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR=-1)
Definition: kutil.cc:2032
void chainCritOpt_1(poly, int, kStrategy strat)
Definition: kutil.cc:3538
static void enterOnePairLift(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR=-1)
Definition: kutil.cc:2314
void chainCritPart(poly p, int ecart, kStrategy strat)
Definition: kutil.cc:3613
void chainCritNormal(poly p, int ecart, kStrategy strat)
Definition: kutil.cc:3297
void chainCritRing(poly p, int, kStrategy strat)
Definition: kutil.cc:4089
static bool rIsSCA(const ring r)
Definition: nc.h:190
#define TEST_OPT_WEIGHTM
Definition: options.h:122
#define TEST_OPT_IDLIFT
Definition: options.h:130
#define TEST_OPT_SUGARCRIT
Definition: options.h:108
#define TEST_OPT_NOT_SUGAR
Definition: options.h:107

◆ initBuchMoraPos()

void initBuchMoraPos ( kStrategy  strat)

Definition at line 9900 of file kutil.cc.

9901 {
9903  {
9904  if (strat->honey)
9905  {
9906  strat->posInL = posInL15;
9907  // ok -- here is the deal: from my experiments for Singular-2-0
9908  // I conclude that that posInT_EcartpLength is the best of
9909  // posInT15, posInT_EcartFDegpLength, posInT_FDegLength, posInT_pLength
9910  // see the table at the end of this file
9911  if (TEST_OPT_OLDSTD)
9912  strat->posInT = posInT15;
9913  else
9914  strat->posInT = posInT_EcartpLength;
9915  }
9916  else if (currRing->pLexOrder && !TEST_OPT_INTSTRATEGY)
9917  {
9918  strat->posInL = posInL11;
9919  strat->posInT = posInT11;
9920  }
9921  else if (TEST_OPT_INTSTRATEGY)
9922  {
9923  strat->posInL = posInL11;
9924  strat->posInT = posInT11;
9925  }
9926  else
9927  {
9928  strat->posInL = posInL0;
9929  strat->posInT = posInT0;
9930  }
9931  //if (strat->minim>0) strat->posInL =posInLSpecial;
9932  if (strat->homog)
9933  {
9934  strat->posInL = posInL110;
9935  strat->posInT = posInT110;
9936  }
9937  }
9938  else /* local/mixed ordering */
9939  {
9940  if (strat->homog)
9941  {
9942  strat->posInL = posInL11;
9943  strat->posInT = posInT11;
9944  }
9945  else
9946  {
9947  if ((currRing->order[0]==ringorder_c)
9948  ||(currRing->order[0]==ringorder_C))
9949  {
9950  strat->posInL = posInL17_c;
9951  strat->posInT = posInT17_c;
9952  }
9953  else
9954  {
9955  strat->posInL = posInL17;
9956  strat->posInT = posInT17;
9957  }
9958  }
9959  }
9960  if (strat->minim>0) strat->posInL =posInLSpecial;
9961  // for further tests only
9962  if ((BTEST1(11)) || (BTEST1(12)))
9963  strat->posInL = posInL11;
9964  else if ((BTEST1(13)) || (BTEST1(14)))
9965  strat->posInL = posInL13;
9966  else if ((BTEST1(15)) || (BTEST1(16)))
9967  strat->posInL = posInL15;
9968  else if ((BTEST1(17)) || (BTEST1(18)))
9969  strat->posInL = posInL17;
9970  if (BTEST1(11))
9971  strat->posInT = posInT11;
9972  else if (BTEST1(13))
9973  strat->posInT = posInT13;
9974  else if (BTEST1(15))
9975  strat->posInT = posInT15;
9976  else if ((BTEST1(17)))
9977  strat->posInT = posInT17;
9978  else if ((BTEST1(19)))
9979  strat->posInT = posInT19;
9980  else if (BTEST1(12) || BTEST1(14) || BTEST1(16) || BTEST1(18))
9981  strat->posInT = posInT1;
9983 }
int minim
Definition: kutil.h:357
int posInL110(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:6358
int posInT17(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5460
int posInT11(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5053
int posInT1(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4996
int posInT_EcartpLength(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5326
int posInT0(const TSet, const int length, LObject &)
Definition: kutil.cc:4985
int posInL13(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:6447
BOOLEAN kPosInLDependsOnLength(int(*pos_in_l)(const LSet set, const int length, LObject *L, const kStrategy strat))
Definition: kutil.cc:9884
int posInT13(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5297
int posInL0(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:5797
int posInL15(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:6482
int posInT17_c(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5568
int posInT15(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5364
int posInLSpecial(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:5753
int posInL17(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:6559
int posInT110(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5207
int posInT19(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5696
int posInL17_c(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:6654
int posInL11(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:6059
#define TEST_OPT_OLDSTD
Definition: options.h:124
@ ringorder_C
Definition: ring.h:73
@ ringorder_c
Definition: ring.h:72

◆ initBuchMoraPosRing()

void initBuchMoraPosRing ( kStrategy  strat)

Definition at line 9986 of file kutil.cc.

9987 {
9989  {
9990  if (strat->honey)
9991  {
9992  strat->posInL = posInL15Ring;
9993  // ok -- here is the deal: from my experiments for Singular-2-0
9994  // I conclude that that posInT_EcartpLength is the best of
9995  // posInT15, posInT_EcartFDegpLength, posInT_FDegLength, posInT_pLength
9996  // see the table at the end of this file
9997  if (TEST_OPT_OLDSTD)
9998  strat->posInT = posInT15Ring;
9999  else
10000  strat->posInT = posInT_EcartpLength;
10001  }
10002  else if (currRing->pLexOrder && !TEST_OPT_INTSTRATEGY)
10003  {
10004  strat->posInL = posInL11Ring;
10005  strat->posInT = posInT11;
10006  }
10007  else if (TEST_OPT_INTSTRATEGY)
10008  {
10009  strat->posInL = posInL11Ring;
10010  strat->posInT = posInT11;
10011  }
10012  else
10013  {
10014  strat->posInL = posInL0Ring;
10015  strat->posInT = posInT0;
10016  }
10017  //if (strat->minim>0) strat->posInL =posInLSpecial;
10018  if (strat->homog)
10019  {
10020  strat->posInL = posInL110Ring;
10021  strat->posInT = posInT110Ring;
10022  }
10023  }
10024  else
10025  {
10026  if (strat->homog)
10027  {
10028  //printf("\nHere 3\n");
10029  strat->posInL = posInL11Ring;
10030  strat->posInT = posInT11Ring;
10031  }
10032  else
10033  {
10034  if ((currRing->order[0]==ringorder_c)
10035  ||(currRing->order[0]==ringorder_C))
10036  {
10037  strat->posInL = posInL17_cRing;
10038  strat->posInT = posInT17_cRing;
10039  }
10040  else
10041  {
10042  strat->posInL = posInL11Ringls;
10043  strat->posInT = posInT17Ring;
10044  }
10045  }
10046  }
10047  if (strat->minim>0) strat->posInL =posInLSpecial;
10048  // for further tests only
10049  if ((BTEST1(11)) || (BTEST1(12)))
10050  strat->posInL = posInL11Ring;
10051  else if ((BTEST1(13)) || (BTEST1(14)))
10052  strat->posInL = posInL13;
10053  else if ((BTEST1(15)) || (BTEST1(16)))
10054  strat->posInL = posInL15Ring;
10055  else if ((BTEST1(17)) || (BTEST1(18)))
10056  strat->posInL = posInL17Ring;
10057  if (BTEST1(11))
10058  strat->posInT = posInT11Ring;
10059  else if (BTEST1(13))
10060  strat->posInT = posInT13;
10061  else if (BTEST1(15))
10062  strat->posInT = posInT15Ring;
10063  else if ((BTEST1(17)))
10064  strat->posInT = posInT17Ring;
10065  else if ((BTEST1(19)))
10066  strat->posInT = posInT19;
10067  else if (BTEST1(12) || BTEST1(14) || BTEST1(16) || BTEST1(18))
10068  strat->posInT = posInT1;
10070 }
int posInL17Ring(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:6604
int posInL17_cRing(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:6719
int posInL11Ring(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:6102
int posInT110Ring(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5250
int posInL110Ring(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:6400
int posInL0Ring(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:5825
int posInT11Ring(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5090
int posInL11Ringls(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:6172
int posInL15Ring(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:6518
int posInT15Ring(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5419
int posInT17Ring(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5522
int posInT17_cRing(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5630

◆ initec()

static intset initec ( const int  maxnr)
inlinestatic

Definition at line 534 of file kutil.cc.

535 {
536  return (intset)omAlloc(maxnr*sizeof(int));
537 }

◆ initEcartBBA()

void initEcartBBA ( TObject h)

Definition at line 1392 of file kutil.cc.

1393 {
1394  h->FDeg = h->pFDeg();
1395  (*h).ecart = 0;
1396  h->length=h->pLength=pLength(h->p);
1397 }

◆ initEcartNormal()

void initEcartNormal ( TObject h)

Definition at line 1384 of file kutil.cc.

1385 {
1386  h->FDeg = h->pFDeg();
1387  h->ecart = h->pLDeg() - h->FDeg;
1388  // h->length is set by h->pLDeg
1389  h->length=h->pLength=pLength(h->p);
1390 }

◆ initEcartPairBba()

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

Definition at line 1399 of file kutil.cc.

1400 {
1401  Lp->FDeg = Lp->pFDeg();
1402  (*Lp).ecart = 0;
1403  (*Lp).length = 0;
1404 }

◆ initEcartPairMora()

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

Definition at line 1406 of file kutil.cc.

1407 {
1408  Lp->FDeg = Lp->pFDeg();
1409  (*Lp).ecart = si_max(ecartF,ecartG);
1410  (*Lp).ecart = (*Lp).ecart- (Lp->FDeg -p_FDeg((*Lp).lcm,currRing));
1411  (*Lp).length = 0;
1412 }
static long p_FDeg(const poly p, const ring r)
Definition: p_polys.h:382

◆ initenterpairs()

void initenterpairs ( poly  h,
int  k,
int  ecart,
int  isFromQ,
kStrategy  strat,
int  atR 
)

Definition at line 3902 of file kutil.cc.

3903 {
3904 
3905  if ((strat->syzComp==0)
3906  || (pGetComp(h)<=strat->syzComp))
3907  {
3908  int j;
3909  BOOLEAN new_pair=FALSE;
3910 
3911  if (pGetComp(h)==0)
3912  {
3913  /* for Q!=NULL: build pairs (f,q),(f1,f2), but not (q1,q2)*/
3914  if ((isFromQ)&&(strat->fromQ!=NULL))
3915  {
3916  for (j=0; j<=k; j++)
3917  {
3918  if (!strat->fromQ[j])
3919  {
3920  new_pair=TRUE;
3921  strat->enterOnePair(j,h,ecart,isFromQ,strat, atR);
3922  //Print("j:%d, Ll:%d\n",j,strat->Ll);
3923  }
3924  }
3925  }
3926  else
3927  {
3928  new_pair=TRUE;
3929  for (j=0; j<=k; j++)
3930  {
3931  strat->enterOnePair(j,h,ecart,isFromQ,strat, atR);
3932  //Print("j:%d, Ll:%d\n",j,strat->Ll);
3933  }
3934  }
3935  }
3936  else
3937  {
3938  for (j=0; j<=k; j++)
3939  {
3940  if ((pGetComp(h)==pGetComp(strat->S[j]))
3941  || (pGetComp(strat->S[j])==0))
3942  {
3943  new_pair=TRUE;
3944  strat->enterOnePair(j,h,ecart,isFromQ,strat, atR);
3945  //Print("j:%d, Ll:%d\n",j,strat->Ll);
3946  }
3947  }
3948  }
3949  if (new_pair)
3950  {
3951  #ifdef HAVE_RATGRING
3952  if (currRing->real_var_start>0)
3953  chainCritPart(h,ecart,strat);
3954  else
3955  #endif
3956  strat->chainCrit(h,ecart,strat);
3957  }
3958  kMergeBintoL(strat);
3959  }
3960 }

◆ initenterpairsShift()

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

Definition at line 12968 of file kutil.cc.

12969 {
12970  int h_lastVblock = pmLastVblock(h);
12971  assume(h_lastVblock != 0 || pLmIsConstantComp(h));
12972  // TODO: is it allowed to skip pairs with constants? also with constants from other components?
12973  if (h_lastVblock == 0) return;
12974  assume(pmFirstVblock(h) == 1);
12975  /* h comes from strat->P.p, that is LObject with LM in currRing and Tail in tailRing */
12976  // atR = -1;
12977  if ((strat->syzComp==0)
12978  || (pGetComp(h)<=strat->syzComp))
12979  {
12980  int i,j;
12981  BOOLEAN new_pair=FALSE;
12982 
12983  int degbound = currRing->N/currRing->isLPring;
12984  int maxShift = degbound - h_lastVblock;
12985 
12986  if (pGetComp(h)==0)
12987  {
12988  if (strat->rightGB)
12989  {
12990  if (isFromQ)
12991  {
12992  // pairs (shifts(h),s[1..k]), (h, s[1..k])
12993  for (i=0; i<=maxShift; i++)
12994  {
12995  poly hh = pLPCopyAndShiftLM(h, i);
12996  BOOLEAN delete_hh=TRUE;
12997  for (j=0; j<=k; j++)
12998  {
12999  if (strat->fromQ == NULL || !strat->fromQ[j])
13000  {
13001  new_pair=TRUE;
13002  poly s = strat->S[j];
13003  if (!enterOnePairWithoutShifts(j, hh, s, ecart, isFromQ, strat, atR, pmLastVblock(s), i))
13004  delete_hh=FALSE;
13005  }
13006  }
13007  if (delete_hh) pLmDelete(hh);
13008  }
13009  }
13010  else
13011  {
13012  new_pair=TRUE;
13013  for (j=0; j<=k; j++)
13014  {
13015  poly s = strat->S[j];
13016  if (strat->fromQ != NULL && strat->fromQ[j])
13017  {
13018  // pairs (shifts(s[j]),h), (s[j],h)
13019  enterOnePairWithShifts(j, s, h, ecart, isFromQ, strat, atR, h_lastVblock, pmLastVblock(s));
13020  }
13021  else
13022  {
13023  // pair (h, s[j])
13024  enterOnePairWithoutShifts(j, h, s, ecart, isFromQ, strat, atR, pmLastVblock(s), 0);
13025  }
13026  }
13027  }
13028  }
13029  /* for Q!=NULL: build pairs (f,q),(f1,f2), but not (q1,q2)*/
13030  else if ((isFromQ)&&(strat->fromQ!=NULL))
13031  {
13032  // pairs (shifts(s[1..k]),h), (s[1..k],h)
13033  for (j=0; j<=k; j++)
13034  {
13035  if (!strat->fromQ[j])
13036  {
13037  new_pair=TRUE;
13038  poly s = strat->S[j];
13039  enterOnePairWithShifts(j, s, h, ecart, isFromQ, strat, atR, h_lastVblock, pmLastVblock(s));
13040  }
13041  }
13042  // pairs (shifts(h),s[1..k])
13043  if (new_pair)
13044  {
13045  for (i=1; i<=maxShift; i++)
13046  {
13047  BOOLEAN delete_hh=TRUE;
13048  poly hh = pLPCopyAndShiftLM(h, i);
13049  for (j=0; j<=k; j++)
13050  {
13051  if (!strat->fromQ[j])
13052  {
13053  poly s = strat->S[j];
13054  int s_lastVblock = pmLastVblock(s);
13055  if (i < s_lastVblock || (pGetComp(s) > 0 && i == s_lastVblock)) // in the module case, product criterion does not hold (note: comp h is always zero here)
13056  {
13057  if(!enterOnePairWithoutShifts(j, hh, s, ecart, isFromQ, strat, atR, s_lastVblock, i))
13058  delete_hh=FALSE;
13059  }
13060 #ifdef HAVE_RINGS
13061  else if (rField_is_Ring(currRing))
13062  {
13063  assume(i >= s_lastVblock); // this is always the case, but just to be very sure
13064  ideal fillers = id_MaxIdeal(i - s_lastVblock, currRing);
13065  for (int k = 0; k < IDELEMS(fillers); k++)
13066  {
13067  poly hhh = pLPCopyAndShiftLM(pp_mm_Mult(h, fillers->m[k], currRing), s_lastVblock);
13068  enterOnePairWithoutShifts(j, hhh, s, ecart, isFromQ, strat, atR, s_lastVblock, s_lastVblock);
13069  }
13070  idDelete(&fillers);
13071  }
13072 #endif
13073  }
13074  }
13075  if (delete_hh) p_LmDelete(hh,currRing);
13076  }
13077  }
13078  }
13079  else
13080  {
13081  new_pair=TRUE;
13082  // pairs (shifts(s[1..k]),h), (s[1..k],h)
13083  for (j=0; j<=k; j++)
13084  {
13085  poly s = strat->S[j];
13086  enterOnePairWithShifts(j, s, h, ecart, isFromQ, strat, atR, h_lastVblock, pmLastVblock(s));
13087  }
13088  // pairs (shifts(h),s[1..k]), (shifts(h), h)
13089  for (i=1; i<=maxShift; i++)
13090  {
13091  poly hh = pLPCopyAndShiftLM(h, i);
13092  BOOLEAN delete_hh=TRUE;
13093  for (j=0; j<=k; j++)
13094  {
13095  poly s = strat->S[j];
13096  int s_lastVblock = pmLastVblock(s);
13097  if (i < s_lastVblock || (pGetComp(s) > 0 && i == s_lastVblock)) // in the module case, product criterion does not hold (note: comp h is always zero here)
13098  delete_hh=enterOnePairWithoutShifts(j, hh, s, ecart, isFromQ, strat, atR, s_lastVblock, i)
13099  && delete_hh;
13100 #ifdef HAVE_RINGS
13101  else if (rField_is_Ring(currRing))
13102  {
13103  assume(i >= s_lastVblock); // this is always the case, but just to be very sure
13104  ideal fillers = id_MaxIdeal(i - s_lastVblock, currRing);
13105  for (int k = 0; k < IDELEMS(fillers); k++)
13106  {
13107  poly hhh = pLPCopyAndShiftLM(pp_mm_Mult(h, fillers->m[k], currRing), s_lastVblock);
13108  enterOnePairWithoutShifts(j, hhh, s, ecart, isFromQ, strat, atR, s_lastVblock, s_lastVblock);
13109  }
13110  idDelete(&fillers);
13111  }
13112 #endif
13113  }
13114  if (i < h_lastVblock) // in the module case, product criterion does not hold (note: comp h is always zero here)
13115  delete_hh=enterOnePairWithoutShifts(-1, hh, h, ecart, isFromQ, strat, atR, h_lastVblock, i)
13116  && delete_hh;
13117 #ifdef HAVE_RINGS
13118  else if (rField_is_Ring(currRing))
13119  {
13120  assume(i >= h_lastVblock); // this is always the case, but just to be very sure
13121  ideal fillers = id_MaxIdeal(i - h_lastVblock, currRing);
13122  for (int k = 0; k < IDELEMS(fillers); k++)
13123  {
13124  poly hhh = pLPCopyAndShiftLM(pp_mm_Mult(h, fillers->m[k], currRing), h_lastVblock);
13125  enterOnePairWithoutShifts(-1, hhh, h, ecart, isFromQ, strat, atR, h_lastVblock, h_lastVblock);
13126  }
13127  idDelete(&fillers);
13128  }
13129 #endif
13130  if (delete_hh) pLmDelete(hh);
13131  }
13132  }
13133  }
13134  else
13135  {
13136  assume(isFromQ == 0); // an element from Q should always has 0 component
13137  new_pair=TRUE;
13138  if (strat->rightGB)
13139  {
13140  for (j=0; j<=k; j++)
13141  {
13142  if ((pGetComp(h)==pGetComp(strat->S[j]))
13143  || (pGetComp(strat->S[j])==0))
13144  {
13145  poly s = strat->S[j];
13146  if (strat->fromQ != NULL && strat->fromQ[j])
13147  {
13148  // pairs (shifts(s[j]),h), (s[j],h)
13149  enterOnePairWithShifts(j, s, h, ecart, isFromQ, strat, atR, h_lastVblock, pmLastVblock(s));
13150  }
13151  else
13152  {
13153  // pair (h, s[j])
13154  enterOnePairWithoutShifts(j, h, s, ecart, isFromQ, strat, atR, pmLastVblock(s), 0);
13155  }
13156  }
13157  }
13158  }
13159  else
13160  {
13161  // pairs (shifts(s[1..k]),h), (s[1..k],h)
13162  for (j=0; j<=k; j++)
13163  {
13164  if ((pGetComp(h)==pGetComp(strat->S[j]))
13165  || (pGetComp(strat->S[j])==0))
13166  {
13167  poly s = strat->S[j];
13168  enterOnePairWithShifts(j, s, h, ecart, isFromQ, strat, atR, h_lastVblock, pmLastVblock(s));
13169  }
13170  }
13171  // pairs (shifts(h),s[1..k]), (shifts(h), h)
13172  for (i=1; i<=maxShift; i++)
13173  {
13174  poly hh = pLPCopyAndShiftLM(h, i);
13175  for (j=0; j<=k; j++)
13176  {
13177  if ((pGetComp(h)==pGetComp(strat->S[j]))
13178  || (pGetComp(strat->S[j])==0))
13179  {
13180  poly s = strat->S[j];
13181  int s_lastVblock = pmLastVblock(s);
13182  if (i <= s_lastVblock) // in the module case, product criterion does not hold
13183  enterOnePairWithoutShifts(j, hh, s, ecart, isFromQ, strat, atR, s_lastVblock, i);
13184 #ifdef HAVE_RINGS
13185  else if (rField_is_Ring(currRing))
13186  {
13187  assume(i >= s_lastVblock); // this is always the case, but just to be very sure
13188  ideal fillers = id_MaxIdeal(i - s_lastVblock, currRing);
13189  for (int k = 0; k < IDELEMS(fillers); k++)
13190  {
13191  poly hhh = pLPCopyAndShiftLM(pp_mm_Mult(h, fillers->m[k], currRing), s_lastVblock);
13192  enterOnePairWithoutShifts(j, hhh, s, ecart, isFromQ, strat, atR, s_lastVblock, s_lastVblock);
13193  }
13194  idDelete(&fillers);
13195  }
13196 #endif
13197  }
13198  }
13199  if (i <= h_lastVblock) // in the module case, product criterion does not hold
13200  enterOnePairWithoutShifts(-1, hh, h, ecart, isFromQ, strat, atR, h_lastVblock, i);
13201 #ifdef HAVE_RINGS
13202  else if (rField_is_Ring(currRing))
13203  {
13204  assume(i >= h_lastVblock); // this is always the case, but just to be very sure
13205  ideal fillers = id_MaxIdeal(i - h_lastVblock, currRing);
13206  for (int k = 0; k < IDELEMS(fillers); k++)
13207  {
13208  BOOLEAN delete_hhh=TRUE;
13209  poly hhh = pLPCopyAndShiftLM(pp_mm_Mult(h, fillers->m[k], currRing), h_lastVblock);
13210  if(!enterOnePairWithoutShifts(-1, hhh, h, ecart, isFromQ, strat, atR, h_lastVblock, h_lastVblock))
13211  delete_hhh=FALSE;
13212  if (delete_hhh) p_LmDelete(hhh,currRing);
13213  }
13214  idDelete(&fillers);
13215  }
13216 #endif
13217  }
13218  }
13219  }
13220 
13221  if (new_pair)
13222  {
13223  strat->chainCrit(h,ecart,strat);
13224  }
13225  kMergeBintoL(strat);
13226  }
13227 }
static BOOLEAN enterOnePairWithShifts(int q_inS, poly q, poly p, int ecartp, int p_isFromQ, kStrategy strat, int, int p_lastVblock, int q_lastVblock)
Definition: kutil.cc:12520
static BOOLEAN enterOnePairWithoutShifts(int p_inS, poly q, poly p, int ecartq, int q_isFromQ, kStrategy strat, int, int p_lastVblock, int q_shift)
Definition: kutil.cc:12585
#define pLmIsConstantComp(p)
like above, except that p must be != NULL
Definition: polys.h:242

◆ initenterpairsSig()

void initenterpairsSig ( poly  h,
poly  hSig,
int  hFrom,
int  k,
int  ecart,
int  isFromQ,
kStrategy  strat,
int  atR = -1 
)

Definition at line 3967 of file kutil.cc.

3968 {
3969 
3970  if ((strat->syzComp==0)
3971  || (pGetComp(h)<=strat->syzComp))
3972  {
3973  int j;
3974  BOOLEAN new_pair=FALSE;
3975 
3976  if (pGetComp(h)==0)
3977  {
3978  /* for Q!=NULL: build pairs (f,q),(f1,f2), but not (q1,q2)*/
3979  if ((isFromQ)&&(strat->fromQ!=NULL))
3980  {
3981  for (j=0; j<=k; j++)
3982  {
3983  if (!strat->fromQ[j])
3984  {
3985  new_pair=TRUE;
3986  enterOnePairSig(j,h,hSig,hFrom,ecart,isFromQ,strat, atR);
3987  //Print("j:%d, Ll:%d\n",j,strat->Ll);
3988  }
3989  }
3990  }
3991  else
3992  {
3993  new_pair=TRUE;
3994  for (j=0; j<=k; j++)
3995  {
3996  enterOnePairSig(j,h,hSig,hFrom,ecart,isFromQ,strat, atR);
3997  //Print("j:%d, Ll:%d\n",j,strat->Ll);
3998  }
3999  }
4000  }
4001  else
4002  {
4003  for (j=0; j<=k; j++)
4004  {
4005  if ((pGetComp(h)==pGetComp(strat->S[j]))
4006  || (pGetComp(strat->S[j])==0))
4007  {
4008  new_pair=TRUE;
4009  enterOnePairSig(j,h,hSig,hFrom,ecart,isFromQ,strat, atR);
4010  //Print("j:%d, Ll:%d\n",j,strat->Ll);
4011  }
4012  }
4013  }
4014 
4015  if (new_pair)
4016  {
4017 #ifdef HAVE_RATGRING
4018  if (currRing->real_var_start>0)
4019  chainCritPart(h,ecart,strat);
4020  else
4021 #endif
4022  strat->chainCrit(h,ecart,strat);
4023  }
4024  }
4025 }
static void enterOnePairSig(int i, poly p, poly pSig, int, int ecart, int isFromQ, kStrategy strat, int atR=-1)
Definition: kutil.cc:2526

◆ initenterpairsSigRing()

void initenterpairsSigRing ( poly  h,
poly  hSig,
int  hFrom,
int  k,
int  ecart,
int  isFromQ,
kStrategy  strat,
int  atR = -1 
)

Definition at line 4027 of file kutil.cc.

4028 {
4029 
4030  if ((strat->syzComp==0)
4031  || (pGetComp(h)<=strat->syzComp))
4032  {
4033  int j;
4034 
4035  if (pGetComp(h)==0)
4036  {
4037  /* for Q!=NULL: build pairs (f,q),(f1,f2), but not (q1,q2)*/
4038  if ((isFromQ)&&(strat->fromQ!=NULL))
4039  {
4040  for (j=0; j<=k && !strat->sigdrop; j++)
4041  {
4042  if (!strat->fromQ[j])
4043  {
4044  enterOnePairSigRing(j,h,hSig,hFrom,ecart,isFromQ,strat, atR);
4045  //Print("j:%d, Ll:%d\n",j,strat->Ll);
4046  }
4047  }
4048  }
4049  else
4050  {
4051  for (j=0; j<=k && !strat->sigdrop; j++)
4052  {
4053  enterOnePairSigRing(j,h,hSig,hFrom,ecart,isFromQ,strat, atR);
4054  //Print("j:%d, Ll:%d\n",j,strat->Ll);
4055  }
4056  }
4057  }
4058  else
4059  {
4060  for (j=0; j<=k && !strat->sigdrop; j++)
4061  {
4062  if ((pGetComp(h)==pGetComp(strat->S[j]))
4063  || (pGetComp(strat->S[j])==0))
4064  {
4065  enterOnePairSigRing(j,h,hSig,hFrom,ecart,isFromQ,strat, atR);
4066  //Print("j:%d, Ll:%d\n",j,strat->Ll);
4067  }
4068  }
4069  }
4070 
4071 #if 0
4072  if (new_pair)
4073  {
4074 #ifdef HAVE_RATGRING
4075  if (currRing->real_var_start>0)
4076  chainCritPart(h,ecart,strat);
4077  else
4078 #endif
4079  strat->chainCrit(h,ecart,strat);
4080  }
4081 #endif
4082  }
4083 }
static void enterOnePairSigRing(int i, poly p, poly pSig, int, int ecart, int isFromQ, kStrategy strat, int atR=-1)
Definition: kutil.cc:2783

◆ initenterstrongPairs()

void initenterstrongPairs ( poly  h,
int  k,
int  ecart,
int  isFromQ,
kStrategy  strat,
int  atR = -1 
)

Definition at line 4247 of file kutil.cc.

4248 {
4249  if (!nIsOne(pGetCoeff(h)))
4250  {
4251  int j;
4252  BOOLEAN new_pair=FALSE;
4253 
4254  if (pGetComp(h)==0)
4255  {
4256  /* for Q!=NULL: build pairs (f,q),(f1,f2), but not (q1,q2)*/
4257  if ((isFromQ)&&(strat->fromQ!=NULL))
4258  {
4259  for (j=0; j<=k; j++)
4260  {
4261  if (!strat->fromQ[j])
4262  {
4263  new_pair=TRUE;
4264  enterOneStrongPoly(j,h,ecart,isFromQ,strat, atR, FALSE);
4265  }
4266  }
4267  }
4268  else
4269  {
4270  new_pair=TRUE;
4271  for (j=0; j<=k; j++)
4272  {
4273  enterOneStrongPoly(j,h,ecart,isFromQ,strat, atR, FALSE);
4274  }
4275  }
4276  }
4277  else
4278  {
4279  for (j=0; j<=k; j++)
4280  {
4281  if ((pGetComp(h)==pGetComp(strat->S[j]))
4282  || (pGetComp(strat->S[j])==0))
4283  {
4284  new_pair=TRUE;
4285  enterOneStrongPoly(j,h,ecart,isFromQ,strat, atR, FALSE);
4286  }
4287  }
4288  }
4289  if (new_pair)
4290  {
4291  #ifdef HAVE_RATGRING
4292  if (currRing->real_var_start>0)
4293  chainCritPart(h,ecart,strat);
4294  else
4295  #endif
4296  strat->chainCrit(h,ecart,strat);
4297  }
4298  kMergeBintoL(strat);
4299  }
4300 }

◆ initenterstrongPairsShift()

void initenterstrongPairsShift ( poly  h,
int  k,
int  ecart,
int  isFromQ,
kStrategy  strat,
int  atR 
)

Definition at line 13236 of file kutil.cc.

13237 {
13238  int h_lastVblock = pmLastVblock(h);
13239  assume(h_lastVblock != 0 || pLmIsConstantComp(h));
13240  // TODO: is it allowed to skip pairs with constants? also with constants from other components?
13241  if (h_lastVblock == 0) return;
13242  assume(pmFirstVblock(h) == 1);
13243  /* h comes from strat->P.p, that is LObject with LM in currRing and Tail in tailRing */
13244  // atR = -1;
13245  if ((strat->syzComp==0)
13246  || (pGetComp(h)<=strat->syzComp))
13247  {
13248  int i,j;
13249  BOOLEAN new_pair=FALSE;
13250 
13251  int degbound = currRing->N/currRing->isLPring;
13252  int maxShift = degbound - h_lastVblock;
13253 
13254  if (pGetComp(h)==0)
13255  {
13256  if (strat->rightGB)
13257  {
13258  if (isFromQ)
13259  {
13260  // pairs (shifts(h),s[1..k]), (h, s[1..k])
13261  for (i=0; i<=maxShift; i++)
13262  {
13263  poly hh = pLPCopyAndShiftLM(h, i);
13264  for (j=0; j<=k; j++)
13265  {
13266  if (strat->fromQ == NULL || !strat->fromQ[j])
13267  {
13268  new_pair=TRUE;
13269  poly s = strat->S[j];
13270  enterOnePairWithoutShifts(j, hh, s, ecart, isFromQ, strat, atR, pmLastVblock(s), i);
13271  }
13272  }
13273  }
13274  }
13275  else
13276  {
13277  new_pair=TRUE;
13278  for (j=0; j<=k; j++)
13279  {
13280  poly s = strat->S[j];
13281  if (strat->fromQ != NULL && strat->fromQ[j])
13282  {
13283  // pairs (shifts(s[j]),h), (s[j],h)
13284  enterOnePairWithShifts(j, s, h, ecart, isFromQ, strat, atR, h_lastVblock, pmLastVblock(s));
13285  }
13286  else
13287  {
13288  // pair (h, s[j])
13289  enterOnePairWithoutShifts(j, h, s, ecart, isFromQ, strat, atR, pmLastVblock(s), 0);
13290  }
13291  }
13292  }
13293  }
13294  /* for Q!=NULL: build pairs (f,q),(f1,f2), but not (q1,q2)*/
13295  else if ((isFromQ)&&(strat->fromQ!=NULL))
13296  {
13297  // pairs (shifts(s[1..k]),h), (s[1..k],h)
13298  for (j=0; j<=k; j++)
13299  {
13300  if (!strat->fromQ[j])
13301  {
13302  new_pair=TRUE;
13303  poly s = strat->S[j];
13304  enterOnePairWithShifts(j, s, h, ecart, isFromQ, strat, atR, h_lastVblock, pmLastVblock(s));
13305  }
13306  }
13307  // pairs (shifts(h),s[1..k])
13308  if (new_pair)
13309  {
13310  for (i=1; i<=maxShift; i++)
13311  {
13312  poly hh = pLPCopyAndShiftLM(h, i);
13313  for (j=0; j<=k; j++)
13314  {
13315  if (!strat->fromQ[j])
13316  {
13317  poly s = strat->S[j];
13318  enterOnePairWithoutShifts(j, hh, s, ecart, isFromQ, strat, atR, pmLastVblock(s), i);
13319  }
13320  }
13321  }
13322  }
13323  }
13324  else
13325  {
13326  new_pair=TRUE;
13327  // pairs (shifts(s[1..k]),h), (s[1..k],h)
13328  for (j=0; j<=k; j++)
13329  {
13330  poly s = strat->S[j];
13331  // TODO: cache lastVblock of s[1..k] for later use
13332  enterOnePairWithShifts(j, s, h, ecart, isFromQ, strat, atR, h_lastVblock, pmLastVblock(s));
13333  }
13334  // pairs (shifts(h),s[1..k]), (shifts(h), h)
13335  for (i=1; i<=maxShift; i++)
13336  {
13337  poly hh = pLPCopyAndShiftLM(h, i);
13338  BOOLEAN delete_hh=TRUE;
13339  for (j=0; j<=k; j++)
13340  {
13341  poly s = strat->S[j];
13342  if(!enterOnePairWithoutShifts(j, hh, s, ecart, isFromQ, strat, atR, pmLastVblock(s), i))
13343  delete_hh=FALSE;
13344  }
13345  if(!enterOnePairWithoutShifts(-1, hh, h, ecart, isFromQ, strat, atR, h_lastVblock, i))
13346  delete_hh=FALSE;
13347  if (delete_hh) p_LmDelete(hh,currRing);
13348  }
13349  }
13350  }
13351  else
13352  {
13353  new_pair=TRUE;
13354  if (strat->rightGB)
13355  {
13356  for (j=0; j<=k; j++)
13357  {
13358  if ((pGetComp(h)==pGetComp(strat->S[j]))
13359  || (pGetComp(strat->S[j])==0))
13360  {
13361  assume(isFromQ == 0); // this case is not handeled here and should also never happen
13362  poly s = strat->S[j];
13363  if (strat->fromQ != NULL && strat->fromQ[j])
13364  {
13365  // pairs (shifts(s[j]),h), (s[j],h)
13366  enterOnePairWithShifts(j, s, h, ecart, isFromQ, strat, atR, h_lastVblock, pmLastVblock(s));
13367  }
13368  else
13369  {
13370  // pair (h, s[j])
13371  enterOnePairWithoutShifts(j, h, s, ecart, isFromQ, strat, atR, pmLastVblock(s), 0);
13372  }
13373  }
13374  }
13375  }
13376  else
13377  {
13378  // pairs (shifts(s[1..k]),h), (s[1..k],h)
13379  for (j=0; j<=k; j++)
13380  {
13381  if ((pGetComp(h)==pGetComp(strat->S[j]))
13382  || (pGetComp(strat->S[j])==0))
13383  {
13384  poly s = strat->S[j];
13385  enterOnePairWithShifts(j, s, h, ecart, isFromQ, strat, atR, h_lastVblock, pmLastVblock(s));
13386  }
13387  }
13388  // pairs (shifts(h),s[1..k]), (shifts(h), h)
13389  for (i=1; i<=maxShift; i++)
13390  {
13391  poly hh = pLPCopyAndShiftLM(h, i);
13392  for (j=0; j<=k; j++)
13393  {
13394  if ((pGetComp(h)==pGetComp(strat->S[j]))
13395  || (pGetComp(strat->S[j])==0))
13396  {
13397  poly s = strat->S[j];
13398  enterOnePairWithoutShifts(j, hh, s, ecart, isFromQ, strat, atR, pmLastVblock(s), i);
13399  }
13400  }
13401  enterOnePairWithoutShifts(-1, hh, h, ecart, isFromQ, strat, atR, h_lastVblock, i);
13402  }
13403  }
13404  }
13405 
13406  if (new_pair)
13407  {
13408  strat->chainCrit(h,ecart,strat);
13409  }
13410  kMergeBintoL(strat);
13411  }
13412 }

◆ initenterstrongPairsSig()

static void initenterstrongPairsSig ( poly  h,
poly  hSig,
int  k,
int  ecart,
int  isFromQ,
kStrategy  strat,
int  atR = -1 
)
static

Definition at line 4302 of file kutil.cc.

4303 {
4304  const int iCompH = pGetComp(h);
4305  if (!nIsOne(pGetCoeff(h)))
4306  {
4307  int j;
4308 
4309  for (j=0; j<=k && !strat->sigdrop; j++)
4310  {
4311  // Print("j:%d, Ll:%d\n",j,strat->Ll);
4312 // if (((unsigned long) pGetCoeff(h) % (unsigned long) pGetCoeff(strat->S[j]) != 0) &&
4313 // ((unsigned long) pGetCoeff(strat->S[j]) % (unsigned long) pGetCoeff(h) != 0))
4314  if (((iCompH == pGetComp(strat->S[j]))
4315  || (0 == pGetComp(strat->S[j])))
4316  && ((iCompH<=strat->syzComp)||(strat->syzComp==0)))
4317  {
4318  enterOneStrongPolySig(j,h,hSig,ecart,isFromQ,strat, atR);
4319  }
4320  }
4321  }
4322 }
static BOOLEAN enterOneStrongPolySig(int i, poly p, poly sig, int, int, kStrategy strat, int atR)
Definition: kutil.cc:1838

◆ initHilbCrit()

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

Definition at line 9730 of file kutil.cc.

9731 {
9732 
9733  //if the ordering is local, then hilb criterion
9734  //can be used also if the ideal is not homogenous
9736  {
9738  *hilb=NULL;
9739  else
9740  return;
9741  }
9742  if (strat->homog!=isHomog)
9743  {
9744  *hilb=NULL;
9745  }
9746 }
@ isHomog
Definition: structs.h:37

◆ initPairtest()

void initPairtest ( kStrategy  strat)

Definition at line 697 of file kutil.cc.

698 {
699  strat->pairtest = (BOOLEAN *)omAlloc0((strat->sl+2)*sizeof(BOOLEAN));
700 }
#define omAlloc0(size)
Definition: omAllocDecl.h:211

◆ initS()

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

Definition at line 7907 of file kutil.cc.

7908 {
7909  int i,pos;
7910 
7911  if (Q!=NULL) i=((IDELEMS(F)+IDELEMS(Q)+(setmaxTinc-1))/setmaxTinc)*setmaxTinc;
7912  else i=((IDELEMS(F)+(setmaxTinc-1))/setmaxTinc)*setmaxTinc;
7913  strat->ecartS=initec(i);
7914  strat->sevS=initsevS(i);
7915  strat->S_2_R=initS_2_R(i);
7916  strat->fromQ=NULL;
7917  strat->Shdl=idInit(i,F->rank);
7918  strat->S=strat->Shdl->m;
7919  /*- put polys into S -*/
7920  if (Q!=NULL)
7921  {
7922  strat->fromQ=initec(i);
7923  memset(strat->fromQ,0,i*sizeof(int));
7924  for (i=0; i<IDELEMS(Q); i++)
7925  {
7926  if (Q->m[i]!=NULL)
7927  {
7928  LObject h;
7929  h.p = pCopy(Q->m[i]);
7931  {
7932  h.pCleardenom(); // also does remove Content
7933  }
7934  else
7935  {
7936  h.pNorm();
7937  }
7939  {
7940  deleteHC(&h, strat);
7941  }
7942  if (h.p!=NULL)
7943  {
7944  strat->initEcart(&h);
7945  if (strat->sl==-1)
7946  pos =0;
7947  else
7948  {
7949  pos = posInS(strat,strat->sl,h.p,h.ecart);
7950  }
7951  h.sev = pGetShortExpVector(h.p);
7952  strat->enterS(h,pos,strat,-1);
7953  strat->fromQ[pos]=1;
7954  }
7955  }
7956  }
7957  }
7958  for (i=0; i<IDELEMS(F); i++)
7959  {
7960  if (F->m[i]!=NULL)
7961  {
7962  LObject h;
7963  h.p = pCopy(F->m[i]);
7965  {
7966  cancelunit(&h); /*- tries to cancel a unit -*/
7967  deleteHC(&h, strat);
7968  }
7969  if (h.p!=NULL)
7970  // do not rely on the input being a SB!
7971  {
7973  {
7974  h.pCleardenom(); // also does remove Content
7975  }
7976  else
7977  {
7978  h.pNorm();
7979  }
7980  strat->initEcart(&h);
7981  if (strat->sl==-1)
7982  pos =0;
7983  else
7984  pos = posInS(strat,strat->sl,h.p,h.ecart);
7985  h.sev = pGetShortExpVector(h.p);
7986  strat->enterS(h,pos,strat,-1);
7987  }
7988  }
7989  }
7990  /*- test, if a unit is in F -*/
7991  if ((strat->sl>=0)
7992 #ifdef HAVE_RINGS
7993  && n_IsUnit(pGetCoeff(strat->S[0]),currRing->cf)
7994 #endif
7995  && pIsConstant(strat->S[0]))
7996  {
7997  while (strat->sl>0) deleteInS(strat->sl,strat);
7998  }
7999 }
static intset initec(const int maxnr)
Definition: kutil.cc:534
void deleteInS(int i, kStrategy strat)
Definition: kutil.cc:1163
static unsigned long * initsevS(const int maxnr)
Definition: kutil.cc:539
static int * initS_2_R(const int maxnr)
Definition: kutil.cc:543
void cancelunit(LObject *L, BOOLEAN inNF)
Definition: kutil.cc:373
#define pIsConstant(p)
like above, except that Comp must be 0
Definition: polys.h:238

◆ initS_2_R()

static int* initS_2_R ( const int  maxnr)
inlinestatic

Definition at line 543 of file kutil.cc.

544 {
545  return (int*)omAlloc0(maxnr*sizeof(int));
546 }

◆ initSbaBuchMora()

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

Definition at line 10286 of file kutil.cc.

10287 {
10288  strat->interpt = BTEST1(OPT_INTERRUPT);
10289  //strat->kNoether=NULL; // done by skStrategy
10290  /*- creating temp data structures------------------- -*/
10291  //strat->cp = 0; // done by skStrategy
10292  //strat->c3 = 0; // done by skStrategy
10293  strat->tail = pInit();
10294  /*- set s -*/
10295  strat->sl = -1;
10296  /*- set ps -*/
10297  strat->syzl = -1;
10298  /*- set L -*/
10299  strat->Lmax = ((IDELEMS(F)+setmaxLinc-1)/setmaxLinc)*setmaxLinc;
10300  strat->Ll = -1;
10301  strat->L = initL(strat->Lmax);
10302  /*- set B -*/
10303  strat->Bmax = setmaxL;
10304  strat->Bl = -1;
10305  strat->B = initL();
10306  /*- set T -*/
10307  strat->tl = -1;
10308  strat->tmax = setmaxT;
10309  strat->T = initT();
10310  strat->R = initR();
10311  strat->sevT = initsevT();
10312  /*- init local data struct.---------------------------------------- -*/
10313  //strat->P.ecart=0; // done by skStrategy
10314  //strat->P.length=0; // done by skStrategy
10316  {
10317  if (strat->kNoether!=NULL)
10318  {
10319  pSetComp(strat->kNoether, strat->ak);
10320  pSetComp(strat->kNoetherTail(), strat->ak);
10321  }
10322  }
10324  {
10325  /*Shdl=*/initSLSba(F, Q,strat); /*sets also S, ecartS, fromQ */
10326  }
10327  else
10328  {
10329  if(TEST_OPT_SB_1)
10330  {
10331  int i;
10332  ideal P=idInit(IDELEMS(F)-strat->newIdeal,F->rank);
10333  for (i=strat->newIdeal;i<IDELEMS(F);i++)
10334  {
10335  P->m[i-strat->newIdeal] = F->m[i];
10336  F->m[i] = NULL;
10337  }
10338  initSSpecialSba(F,Q,P,strat);
10339  for (i=strat->newIdeal;i<IDELEMS(F);i++)
10340  {
10341  F->m[i] = P->m[i-strat->newIdeal];
10342  P->m[i-strat->newIdeal] = NULL;
10343  }
10344  idDelete(&P);
10345  }
10346  else
10347  {
10348  initSLSba(F, Q,strat); /*sets also S, ecartS, fromQ */
10349  }
10350  }
10351  //strat->fromT = FALSE; // done by skStrategy
10352  if (!TEST_OPT_SB_1)
10353  {
10354  if(!rField_is_Ring(currRing)) updateS(TRUE,strat);
10355  }
10356  //if (strat->fromQ!=NULL) omFreeSize(strat->fromQ,IDELEMS(strat->Shdl)*sizeof(int));
10357  //strat->fromQ=NULL;
10358  assume(kTest_TS(strat));
10359 }
void initSLSba(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:8098
void initSSpecialSba(ideal F, ideal Q, ideal P, kStrategy strat)
Definition: kutil.cc:8547

◆ initSbaCrit()

void initSbaCrit ( kStrategy  strat)

Definition at line 9813 of file kutil.cc.

9814 {
9815  //strat->enterOnePair=enterOnePairNormal;
9817  //strat->chainCrit=chainCritNormal;
9818  strat->chainCrit = chainCritSig;
9819  /******************************************
9820  * rewCrit1 and rewCrit2 are already set in
9821  * kSba() in kstd1.cc
9822  *****************************************/
9823  //strat->rewCrit1 = faugereRewCriterion;
9824  if (strat->sbaOrder == 1)
9825  {
9826  strat->syzCrit = syzCriterionInc;
9827  }
9828  else
9829  {
9830  strat->syzCrit = syzCriterion;
9831  }
9832 #ifdef HAVE_RINGS
9833  if (rField_is_Ring(currRing))
9834  {
9836  strat->chainCrit=chainCritRing;
9837  }
9838 #endif
9839 #ifdef HAVE_RATGRING
9840  if (rIsRatGRing(currRing))
9841  {
9842  strat->chainCrit=chainCritPart;
9843  /* enterOnePairNormal get rational part in it */
9844  }
9845 #endif
9846 
9847  strat->sugarCrit = TEST_OPT_SUGARCRIT;
9848  strat->Gebauer = strat->homog || strat->sugarCrit;
9849  strat->honey = !strat->homog || strat->sugarCrit || TEST_OPT_WEIGHTM;
9850  if (TEST_OPT_NOT_SUGAR) strat->honey = FALSE;
9851  strat->pairtest = NULL;
9852  /* alway use tailreduction, except:
9853  * - in local rings, - in lex order case, -in ring over extensions */
9856 
9857 #ifdef HAVE_PLURAL
9858  // and r is plural_ring
9859  // hence this holds for r a rational_plural_ring
9860  if( rIsPluralRing(currRing) || (rIsSCA(currRing) && !strat->z2homog) )
9861  { //or it has non-quasi-comm type... later
9862  strat->sugarCrit = FALSE;
9863  strat->Gebauer = FALSE;
9864  strat->honey = FALSE;
9865  }
9866 #endif
9867 
9868  // Coefficient ring?
9869  if (rField_is_Ring(currRing))
9870  {
9871  strat->sugarCrit = FALSE;
9872  strat->Gebauer = FALSE ;
9873  strat->honey = FALSE;
9874  }
9875  #ifdef KDEBUG
9876  if (TEST_OPT_DEBUG)
9877  {
9878  if (strat->homog) PrintS("ideal/module is homogeneous\n");
9879  else PrintS("ideal/module is not homogeneous\n");
9880  }
9881  #endif
9882 }
BOOLEAN syzCriterionInc(poly sig, unsigned long not_sevSig, kStrategy strat)
Definition: kutil.cc:6821
void chainCritSig(poly p, int, kStrategy strat)
Definition: kutil.cc:3554
BOOLEAN syzCriterion(poly sig, unsigned long not_sevSig, kStrategy strat)
Definition: kutil.cc:6786

◆ initSbaPos()

void initSbaPos ( kStrategy  strat)

Definition at line 10184 of file kutil.cc.

10185 {
10187  {
10188  if (strat->honey)
10189  {
10190  strat->posInL = posInL15;
10191  // ok -- here is the deal: from my experiments for Singular-2-0
10192  // I conclude that that posInT_EcartpLength is the best of
10193  // posInT15, posInT_EcartFDegpLength, posInT_FDegLength, posInT_pLength
10194  // see the table at the end of this file
10195  if (TEST_OPT_OLDSTD)
10196  strat->posInT = posInT15;
10197  else
10198  strat->posInT = posInT_EcartpLength;
10199  }
10200  else if (currRing->pLexOrder && !TEST_OPT_INTSTRATEGY)
10201  {
10202  strat->posInL = posInL11;
10203  strat->posInT = posInT11;
10204  }
10205  else if (TEST_OPT_INTSTRATEGY)
10206  {
10207  strat->posInL = posInL11;
10208  strat->posInT = posInT11;
10209  }
10210  else
10211  {
10212  strat->posInL = posInL0;
10213  strat->posInT = posInT0;
10214  }
10215  //if (strat->minim>0) strat->posInL =posInLSpecial;
10216  if (strat->homog)
10217  {
10218  strat->posInL = posInL110;
10219  strat->posInT = posInT110;
10220  }
10221  }
10222  else
10223  {
10224  if (strat->homog)
10225  {
10226  strat->posInL = posInL11;
10227  strat->posInT = posInT11;
10228  }
10229  else
10230  {
10231  if ((currRing->order[0]==ringorder_c)
10232  ||(currRing->order[0]==ringorder_C))
10233  {
10234  strat->posInL = posInL17_c;
10235  strat->posInT = posInT17_c;
10236  }
10237  else
10238  {
10239  strat->posInL = posInL17;
10240  strat->posInT = posInT17;
10241  }
10242  }
10243  }
10244  if (strat->minim>0) strat->posInL =posInLSpecial;
10245  // for further tests only
10246  if ((BTEST1(11)) || (BTEST1(12)))
10247  strat->posInL = posInL11;
10248  else if ((BTEST1(13)) || (BTEST1(14)))
10249  strat->posInL = posInL13;
10250  else if ((BTEST1(15)) || (BTEST1(16)))
10251  strat->posInL = posInL15;
10252  else if ((BTEST1(17)) || (BTEST1(18)))
10253  strat->posInL = posInL17;
10254  if (BTEST1(11))
10255  strat->posInT = posInT11;
10256  else if (BTEST1(13))
10257  strat->posInT = posInT13;
10258  else if (BTEST1(15))
10259  strat->posInT = posInT15;
10260  else if ((BTEST1(17)))
10261  strat->posInT = posInT17;
10262  else if ((BTEST1(19)))
10263  strat->posInT = posInT19;
10264  else if (BTEST1(12) || BTEST1(14) || BTEST1(16) || BTEST1(18))
10265  strat->posInT = posInT1;
10266  if (rField_is_Ring(currRing))
10267  {
10268  strat->posInL = posInL11Ring;
10269  if(rHasLocalOrMixedOrdering(currRing) && currRing->pLexOrder == TRUE)
10270  strat->posInL = posInL11Ringls;
10271  strat->posInT = posInT11;
10272  }
10273  strat->posInLDependsOnLength = FALSE;
10274  strat->posInLSba = posInLSig;
10275  //strat->posInL = posInLSig;
10276  strat->posInL = posInLF5C;
10277  /*
10278  if (rField_is_Ring(currRing))
10279  {
10280  strat->posInLSba = posInLSigRing;
10281  strat->posInL = posInL11Ring;
10282  }*/
10283  //strat->posInT = posInTSig;
10284 }
int posInLSig(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:5857
int posInLF5C(const LSet, const int, LObject *, const kStrategy strat)
Definition: kutil.cc:6047

◆ initsevS()

static unsigned long* initsevS ( const int  maxnr)
inlinestatic

Definition at line 539 of file kutil.cc.

540 {
541  return (unsigned long*)omAlloc0(maxnr*sizeof(unsigned long));
542 }

◆ initSL()

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

Definition at line 8001 of file kutil.cc.

8002 {
8003  int i,pos;
8004 
8005  if (Q!=NULL) i=((IDELEMS(Q)+(setmaxTinc-1))/setmaxTinc)*setmaxTinc;
8006  else i=setmaxT;
8007  strat->ecartS=initec(i);
8008  strat->sevS=initsevS(i);
8009  strat->S_2_R=initS_2_R(i);
8010  strat->fromQ=NULL;
8011  strat->Shdl=idInit(i,F->rank);
8012  strat->S=strat->Shdl->m;
8013  /*- put polys into S -*/
8014  if (Q!=NULL)
8015  {
8016  strat->fromQ=initec(i);
8017  memset(strat->fromQ,0,i*sizeof(int));
8018  for (i=0; i<IDELEMS(Q); i++)
8019  {
8020  if (Q->m[i]!=NULL)
8021  {
8022  LObject h;
8023  h.p = pCopy(Q->m[i]);
8025  {
8026  deleteHC(&h,strat);
8027  }
8029  {
8030  h.pCleardenom(); // also does remove Content
8031  }
8032  else
8033  {
8034  h.pNorm();
8035  }
8036  if (h.p!=NULL)
8037  {
8038  strat->initEcart(&h);
8039  if (strat->sl==-1)
8040  pos =0;
8041  else
8042  {
8043  pos = posInS(strat,strat->sl,h.p,h.ecart);
8044  }
8045  h.sev = pGetShortExpVector(h.p);
8046  strat->enterS(h,pos,strat,-1);
8047  strat->fromQ[pos]=1;
8048  }
8049  }
8050  }
8051  }
8052  for (i=0; i<IDELEMS(F); i++)
8053  {
8054  if (F->m[i]!=NULL)
8055  {
8056  LObject h;
8057  h.p = pCopy(F->m[i]);
8058  if (h.p!=NULL)
8059  {
8061  {
8062  cancelunit(&h); /*- tries to cancel a unit -*/
8063  deleteHC(&h, strat);
8064  }
8065  if (h.p!=NULL)
8066  {
8068  {
8069  h.pCleardenom(); // also does remove Content
8070  }
8071  else
8072  {
8073  h.pNorm();
8074  }
8075  strat->initEcart(&h);
8076  if (strat->Ll==-1)
8077  pos =0;
8078  else
8079  pos = strat->posInL(strat->L,strat->Ll,&h,strat);
8080  h.sev = pGetShortExpVector(h.p);
8081  enterL(&strat->L,&strat->Ll,&strat->Lmax,h,pos);
8082  }
8083  }
8084  }
8085  }
8086  /*- test, if a unit is in F -*/
8087 
8088  if ((strat->Ll>=0)
8089 #ifdef HAVE_RINGS
8090  && n_IsUnit(pGetCoeff(strat->L[strat->Ll].p), currRing->cf)
8091 #endif
8092  && pIsConstant(strat->L[strat->Ll].p))
8093  {
8094  while (strat->Ll>0) deleteInL(strat->L,&strat->Ll,strat->Ll-1,strat);
8095  }
8096 }

◆ initSLSba()

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

Definition at line 8098 of file kutil.cc.

8099 {
8100  int i,pos;
8101  if (Q!=NULL) i=((IDELEMS(Q)+(setmaxTinc-1))/setmaxTinc)*setmaxTinc;
8102  else i=setmaxT;
8103  strat->ecartS = initec(i);
8104  strat->sevS = initsevS(i);
8105  strat->sevSig = initsevS(i);
8106  strat->S_2_R = initS_2_R(i);
8107  strat->fromQ = NULL;
8108  strat->Shdl = idInit(i,F->rank);
8109  strat->S = strat->Shdl->m;
8110  strat->sig = (poly *)omAlloc0(i*sizeof(poly));
8111  if (strat->sbaOrder != 1)
8112  {
8113  strat->syz = (poly *)omAlloc0(i*sizeof(poly));
8114  strat->sevSyz = initsevS(i);
8115  strat->syzmax = i;
8116  strat->syzl = 0;
8117  }
8118  /*- put polys into S -*/
8119  if (Q!=NULL)
8120  {
8121  strat->fromQ=initec(i);
8122  memset(strat->fromQ,0,i*sizeof(int));
8123  for (i=0; i<IDELEMS(Q); i++)
8124  {
8125  if (Q->m[i]!=NULL)
8126  {
8127  LObject h;
8128  h.p = pCopy(Q->m[i]);
8130  {
8131  deleteHC(&h,strat);
8132  }
8134  {
8135  h.pCleardenom(); // also does remove Content
8136  }
8137  else
8138  {
8139  h.pNorm();
8140  }
8141  if (h.p!=NULL)
8142  {
8143  strat->initEcart(&h);
8144  if (strat->sl==-1)
8145  pos =0;
8146  else
8147  {
8148  pos = posInS(strat,strat->sl,h.p,h.ecart);
8149  }
8150  h.sev = pGetShortExpVector(h.p);
8151  strat->enterS(h,pos,strat,-1);
8152  strat->fromQ[pos]=1;
8153  }
8154  }
8155  }
8156  }
8157  for (i=0; i<IDELEMS(F); i++)
8158  {
8159  if (F->m[i]!=NULL)
8160  {
8161  LObject h;
8162  h.p = pCopy(F->m[i]);
8163  h.sig = pOne();
8164  //h.sig = pInit();
8165  //p_SetCoeff(h.sig,nInit(1),currRing);
8166  p_SetComp(h.sig,i+1,currRing);
8167  // if we are working with the Schreyer order we generate it
8168  // by multiplying the initial signatures with the leading monomial
8169  // of the corresponding initial polynomials generating the ideal
8170  // => we can keep the underlying monomial order and get a Schreyer
8171  // order without any bigger overhead
8172  if (strat->sbaOrder == 0 || strat->sbaOrder == 3)
8173  {
8174  p_ExpVectorAdd (h.sig,F->m[i],currRing);
8175  }
8176  h.sevSig = pGetShortExpVector(h.sig);
8177 #ifdef DEBUGF5
8178  pWrite(h.p);
8179  pWrite(h.sig);
8180 #endif
8181  if (h.p!=NULL)
8182  {
8184  {
8185  cancelunit(&h); /*- tries to cancel a unit -*/
8186  deleteHC(&h, strat);
8187  }
8188  if (h.p!=NULL)
8189  {
8191  {
8192  h.pCleardenom(); // also does remove Content
8193  }
8194  else
8195  {
8196  h.pNorm();
8197  }
8198  strat->initEcart(&h);
8199  if (strat->Ll==-1)
8200  pos =0;
8201  else
8202  pos = strat->posInLSba(strat->L,strat->Ll,&h,strat);
8203  h.sev = pGetShortExpVector(h.p);
8204  enterL(&strat->L,&strat->Ll,&strat->Lmax,h,pos);
8205  }
8206  }
8207  /*
8208  if (strat->sbaOrder != 1)
8209  {
8210  for(j=0;j<i;j++)
8211  {
8212  strat->syz[ctr] = pCopy(F->m[j]);
8213  p_SetCompP(strat->syz[ctr],i+1,currRing);
8214  // add LM(F->m[i]) to the signature to get a Schreyer order
8215  // without changing the underlying polynomial ring at all
8216  p_ExpVectorAdd (strat->syz[ctr],F->m[i],currRing);
8217  // since p_Add_q() destroys all input
8218  // data we need to recreate help
8219  // each time
8220  poly help = pCopy(F->m[i]);
8221  p_SetCompP(help,j+1,currRing);
8222  pWrite(strat->syz[ctr]);
8223  pWrite(help);
8224  printf("%d\n",pLmCmp(strat->syz[ctr],help));
8225  strat->syz[ctr] = p_Add_q(strat->syz[ctr],help,currRing);
8226  printf("%d. SYZ ",ctr);
8227  pWrite(strat->syz[ctr]);
8228  strat->sevSyz[ctr] = p_GetShortExpVector(strat->syz[ctr],currRing);
8229  ctr++;
8230  }
8231  strat->syzl = ps;
8232  }
8233  */
8234  }
8235  }
8236  /*- test, if a unit is in F -*/
8237 
8238  if ((strat->Ll>=0)
8239 #ifdef HAVE_RINGS
8240  && n_IsUnit(pGetCoeff(strat->L[strat->Ll].p), currRing->cf)
8241 #endif
8242  && pIsConstant(strat->L[strat->Ll].p))
8243  {
8244  while (strat->Ll>0) deleteInL(strat->L,&strat->Ll,strat->Ll-1,strat);
8245  }
8246 }
static void p_ExpVectorAdd(poly p1, poly p2, const ring r)
Definition: p_polys.h:1413

◆ initSSpecial()

void initSSpecial ( ideal  F,
ideal  Q,
ideal  P,
kStrategy  strat 
)

Definition at line 8403 of file kutil.cc.

8404 {
8405  int i,pos;
8406 
8407  if (Q!=NULL) i=((IDELEMS(Q)+(setmaxTinc-1))/setmaxTinc)*setmaxTinc;
8408  else i=setmaxT;
8409  i=((i+IDELEMS(F)+IDELEMS(P)+setmax-1)/setmax)*setmax;
8410  strat->ecartS=initec(i);
8411  strat->sevS=initsevS(i);
8412  strat->S_2_R=initS_2_R(i);
8413  strat->fromQ=NULL;
8414  strat->Shdl=idInit(i,F->rank);
8415  strat->S=strat->Shdl->m;
8416 
8417  /*- put polys into S -*/
8418  if (Q!=NULL)
8419  {
8420  strat->fromQ=initec(i);
8421  memset(strat->fromQ,0,i*sizeof(int));
8422  for (i=0; i<IDELEMS(Q); i++)
8423  {
8424  if (Q->m[i]!=NULL)
8425  {
8426  LObject h;
8427  h.p = pCopy(Q->m[i]);
8428  //if (TEST_OPT_INTSTRATEGY)
8429  //{
8430  // h.pCleardenom(); // also does remove Content
8431  //}
8432  //else
8433  //{
8434  // h.pNorm();
8435  //}
8437  {
8438  deleteHC(&h,strat);
8439  }
8440  if (h.p!=NULL)
8441  {
8442  strat->initEcart(&h);
8443  if (strat->sl==-1)
8444  pos =0;
8445  else
8446  {
8447  pos = posInS(strat,strat->sl,h.p,h.ecart);
8448  }
8449  h.sev = pGetShortExpVector(h.p);
8450  strat->enterS(h,pos,strat, strat->tl+1);
8451  enterT(h, strat);
8452  strat->fromQ[pos]=1;
8453  }
8454  }
8455  }
8456  }
8457  /*- put polys into S -*/
8458  for (i=0; i<IDELEMS(F); i++)
8459  {
8460  if (F->m[i]!=NULL)
8461  {
8462  LObject h;
8463  h.p = pCopy(F->m[i]);
8465  {
8466  deleteHC(&h,strat);
8467  }
8468  else if (TEST_OPT_REDTAIL || TEST_OPT_REDSB)
8469  {
8470  h.p=redtailBba(h.p,strat->sl,strat);
8471  }
8472  if (h.p!=NULL)
8473  {
8474  strat->initEcart(&h);
8475  if (strat->sl==-1)
8476  pos =0;
8477  else
8478  pos = posInS(strat,strat->sl,h.p,h.ecart);
8479  h.sev = pGetShortExpVector(h.p);
8480  strat->enterS(h,pos,strat, strat->tl+1);
8481  enterT(h,strat);
8482  }
8483  }
8484  }
8485  for (i=0; i<IDELEMS(P); i++)
8486  {
8487  if (P->m[i]!=NULL)
8488  {
8489  LObject h;
8490  h.p=pCopy(P->m[i]);
8492  {
8493  h.pCleardenom();
8494  }
8495  else
8496  {
8497  h.pNorm();
8498  }
8499  if(strat->sl>=0)
8500  {
8502  {
8503  h.p=redBba(h.p,strat->sl,strat);
8504  if ((h.p!=NULL)&&(TEST_OPT_REDTAIL || TEST_OPT_REDSB))
8505  {
8506  h.p=redtailBba(h.p,strat->sl,strat);
8507  }
8508  }
8509  else
8510  {
8511  h.p=redMora(h.p,strat->sl,strat);
8512  }
8513  if(h.p!=NULL)
8514  {
8515  strat->initEcart(&h);
8517  {
8518  h.pCleardenom();
8519  }
8520  else
8521  {
8522  h.is_normalized = 0;
8523  h.pNorm();
8524  }
8525  h.sev = pGetShortExpVector(h.p);
8526  h.SetpFDeg();
8527  pos = posInS(strat,strat->sl,h.p,h.ecart);
8528  enterpairsSpecial(h.p,strat->sl,h.ecart,pos,strat,strat->tl+1);
8529  strat->enterS(h,pos,strat, strat->tl+1);
8530  enterT(h,strat);
8531  }
8532  }
8533  else
8534  {
8535  h.sev = pGetShortExpVector(h.p);
8536  strat->initEcart(&h);
8537  strat->enterS(h,0,strat, strat->tl+1);
8538  enterT(h,strat);
8539  }
8540  }
8541  }
8542 }
static poly redMora(poly h, int maxIndex, kStrategy strat)
Definition: kutil.cc:8821
static poly redBba(poly h, int maxIndex, kStrategy strat)
Definition: kutil.cc:8797
void enterpairsSpecial(poly h, int k, int ecart, int pos, kStrategy strat, int atR=-1)
Definition: kutil.cc:4636
#define TEST_OPT_REDSB
Definition: options.h:105

◆ initSSpecialSba()

void initSSpecialSba ( ideal  F,
ideal  Q,
ideal  P,
kStrategy  strat 
)

Definition at line 8547 of file kutil.cc.

8548 {
8549  int i,pos;
8550 
8551  if (Q!=NULL) i=((IDELEMS(Q)+(setmaxTinc-1))/setmaxTinc)*setmaxTinc;
8552  else i=setmaxT;
8553  i=((i+IDELEMS(F)+IDELEMS(P)+setmax-1)/setmax)*setmax;
8554  strat->sevS=initsevS(i);
8555  strat->sevSig=initsevS(i);
8556  strat->S_2_R=initS_2_R(i);
8557  strat->fromQ=NULL;
8558  strat->Shdl=idInit(i,F->rank);
8559  strat->S=strat->Shdl->m;
8560  strat->sig=(poly *)omAlloc0(i*sizeof(poly));
8561  /*- put polys into S -*/
8562  if (Q!=NULL)
8563  {
8564  strat->fromQ=initec(i);
8565  memset(strat->fromQ,0,i*sizeof(int));
8566  for (i=0; i<IDELEMS(Q); i++)
8567  {
8568  if (Q->m[i]!=NULL)
8569  {
8570  LObject h;
8571  h.p = pCopy(Q->m[i]);
8572  //if (TEST_OPT_INTSTRATEGY)
8573  //{
8574  // h.pCleardenom(); // also does remove Content
8575  //}
8576  //else
8577  //{
8578  // h.pNorm();
8579  //}
8581  {
8582  deleteHC(&h,strat);
8583  }
8584  if (h.p!=NULL)
8585  {
8586  strat->initEcart(&h);
8587  if (strat->sl==-1)
8588  pos =0;
8589  else
8590  {
8591  pos = posInS(strat,strat->sl,h.p,h.ecart);
8592  }
8593  h.sev = pGetShortExpVector(h.p);
8594  strat->enterS(h,pos,strat, strat->tl+1);
8595  enterT(h, strat);
8596  strat->fromQ[pos]=1;
8597  }
8598  }
8599  }
8600  }
8601  /*- put polys into S -*/
8602  for (i=0; i<IDELEMS(F); i++)
8603  {
8604  if (F->m[i]!=NULL)
8605  {
8606  LObject h;
8607  h.p = pCopy(F->m[i]);
8609  {
8610  deleteHC(&h,strat);
8611  }
8612  else if (TEST_OPT_REDTAIL || TEST_OPT_REDSB)
8613  {
8614  h.p=redtailBba(h.p,strat->sl,strat);
8615  }
8616  if (h.p!=NULL)
8617  {
8618  strat->initEcart(&h);
8619  if (strat->sl==-1)
8620  pos =0;
8621  else
8622  pos = posInS(strat,strat->sl,h.p,h.ecart);
8623  h.sev = pGetShortExpVector(h.p);
8624  strat->enterS(h,pos,strat, strat->tl+1);
8625  enterT(h,strat);
8626  }
8627  }
8628  }
8629  for (i=0; i<IDELEMS(P); i++)
8630  {
8631  if (P->m[i]!=NULL)
8632  {
8633  LObject h;
8634  h.p=pCopy(P->m[i]);
8636  {
8637  h.pCleardenom();
8638  }
8639  else
8640  {
8641  h.pNorm();
8642  }
8643  if(strat->sl>=0)
8644  {
8646  {
8647  h.p=redBba(h.p,strat->sl,strat);
8648  if ((h.p!=NULL)&&(TEST_OPT_REDTAIL || TEST_OPT_REDSB))
8649  {
8650  h.p=redtailBba(h.p,strat->sl,strat);
8651  }
8652  }
8653  else
8654  {
8655  h.p=redMora(h.p,strat->sl,strat);
8656  }
8657  if(h.p!=NULL)
8658  {
8659  strat->initEcart(&h);
8661  {
8662  h.pCleardenom();
8663  }
8664  else
8665  {
8666  h.is_normalized = 0;
8667  h.pNorm();
8668  }
8669  h.sev = pGetShortExpVector(h.p);
8670  h.SetpFDeg();
8671  pos = posInS(strat,strat->sl,h.p,h.ecart);
8672  enterpairsSpecial(h.p,strat->sl,h.ecart,pos,strat,strat->tl+1);
8673  strat->enterS(h,pos,strat, strat->tl+1);
8674  enterT(h,strat);
8675  }
8676  }
8677  else
8678  {
8679  h.sev = pGetShortExpVector(h.p);
8680  strat->initEcart(&h);
8681  strat->enterS(h,0,strat, strat->tl+1);
8682  enterT(h,strat);
8683  }
8684  }
8685  }
8686 }

◆ initSyzRules()

void initSyzRules ( kStrategy  strat)

Definition at line 8248 of file kutil.cc.

8249 {
8250  if( strat->S[0] )
8251  {
8252  if( strat->S[1] && !rField_is_Ring(currRing))
8253  {
8254  omFreeSize(strat->syzIdx,(strat->syzidxmax)*sizeof(int));
8255  omFreeSize(strat->sevSyz,(strat->syzmax)*sizeof(unsigned long));
8256  omFreeSize(strat->syz,(strat->syzmax)*sizeof(poly));
8257  }
8258  int i, j, k, diff, comp, comp_old, ps=0, ctr=0;
8259  /************************************************************
8260  * computing the length of the syzygy array needed
8261  ***********************************************************/
8262  for(i=1; i<=strat->sl; i++)
8263  {
8264  if (pGetComp(strat->sig[i-1]) != pGetComp(strat->sig[i]))
8265  {
8266  ps += i;
8267  }
8268  }
8269  ps += strat->sl+1;
8270  //comp = pGetComp (strat->P.sig);
8271  comp = strat->currIdx;
8272  strat->syzIdx = initec(comp);
8273  strat->sevSyz = initsevS(ps);
8274  strat->syz = (poly *)omAlloc(ps*sizeof(poly));
8275  strat->syzmax = ps;
8276  strat->syzl = 0;
8277  strat->syzidxmax = comp;
8278 #if defined(DEBUGF5) || defined(DEBUGF51)
8279  PrintS("------------- GENERATING SYZ RULES NEW ---------------\n");
8280 #endif
8281  i = 1;
8282  j = 0;
8283  /************************************************************
8284  * generating the leading terms of the principal syzygies
8285  ***********************************************************/
8286  while (i <= strat->sl)
8287  {
8288  /**********************************************************
8289  * principal syzygies start with component index 2
8290  * the array syzIdx starts with index 0
8291  * => the rules for a signature with component comp start
8292  * at strat->syz[strat->syzIdx[comp-2]] !
8293  *********************************************************/
8294  if (pGetComp(strat->sig[i-1]) != pGetComp(strat->sig[i]))
8295  {
8296  comp = pGetComp(strat->sig[i]);
8297  comp_old = pGetComp(strat->sig[i-1]);
8298  diff = comp - comp_old - 1;
8299  // diff should be zero, but sometimes also the initial generating
8300  // elements of the input ideal reduce to zero. then there is an
8301  // index-gap between the signatures. for these inbetween signatures we
8302  // can safely set syzIdx[j] = 0 as no such element will be ever computed
8303  // in the following.
8304  // doing this, we keep the relation "j = comp - 2" alive, which makes
8305  // jumps way easier when checking criteria
8306  while (diff>0)
8307  {
8308  strat->syzIdx[j] = 0;
8309  diff--;
8310  j++;
8311  }
8312  strat->syzIdx[j] = ctr;
8313  j++;
8314  LObject Q;
8315  int pos;
8316  for (k = 0; k<i; k++)
8317  {
8318  Q.sig = pOne();
8320  p_SetCoeff(Q.sig,nCopy(p_GetCoeff(strat->S[k],currRing)),currRing);
8321  p_ExpVectorCopy(Q.sig,strat->S[k],currRing);
8322  p_SetCompP (Q.sig, comp, currRing);
8323  poly q = p_One(currRing);
8326  p_ExpVectorCopy(q,strat->S[i],currRing);
8327  q = p_Neg (q, currRing);
8328  p_SetCompP (q, __p_GetComp(strat->sig[k], currRing), currRing);
8329  Q.sig = p_Add_q (Q.sig, q, currRing);
8330  Q.sevSig = p_GetShortExpVector(Q.sig,currRing);
8331  pos = posInSyz(strat, Q.sig);
8332  enterSyz(Q, strat, pos);
8333  ctr++;
8334  }
8335  }
8336  i++;
8337  }
8338  /**************************************************************
8339  * add syzygies for upcoming first element of new iteration step
8340  **************************************************************/
8341  comp = strat->currIdx;
8342  comp_old = pGetComp(strat->sig[i-1]);
8343  diff = comp - comp_old - 1;
8344  // diff should be zero, but sometimes also the initial generating
8345  // elements of the input ideal reduce to zero. then there is an
8346  // index-gap between the signatures. for these inbetween signatures we
8347  // can safely set syzIdx[j] = 0 as no such element will be ever computed
8348  // in the following.
8349  // doing this, we keep the relation "j = comp - 2" alive, which makes
8350  // jumps way easier when checking criteria
8351  while (diff>0)
8352  {
8353  strat->syzIdx[j] = 0;
8354  diff--;
8355  j++;
8356  }
8357  strat->syzIdx[j] = ctr;
8358  LObject Q;
8359  int pos;
8360  for (k = 0; k<strat->sl+1; k++)
8361  {
8362  Q.sig = pOne();
8364  p_SetCoeff(Q.sig,nCopy(p_GetCoeff(strat->S[k],currRing)),currRing);
8365  p_ExpVectorCopy(Q.sig,strat->S[k],currRing);
8366  p_SetCompP (Q.sig, comp, currRing);
8367  poly q = p_One(currRing);
8369  p_SetCoeff(q,nCopy(p_GetCoeff(strat->L[strat->Ll].p,currRing)),currRing);
8370  p_ExpVectorCopy(q,strat->L[strat->Ll].p,currRing);
8371  q = p_Neg (q, currRing);
8372  p_SetCompP (q, __p_GetComp(strat->sig[k], currRing), currRing);
8373  Q.sig = p_Add_q (Q.sig, q, currRing);
8374  Q.sevSig = p_GetShortExpVector(Q.sig,currRing);
8375  pos = posInSyz(strat, Q.sig);
8376  enterSyz(Q, strat, pos);
8377  ctr++;
8378  }
8379 //#if 1
8380 #ifdef DEBUGF5
8381  PrintS("Principal syzygies:\n");
8382  Print("syzl %d\n",strat->syzl);
8383  Print("syzmax %d\n",strat->syzmax);
8384  Print("ps %d\n",ps);
8385  PrintS("--------------------------------\n");
8386  for(i=0;i<=strat->syzl-1;i++)
8387  {
8388  Print("%d - ",i);
8389  pWrite(strat->syz[i]);
8390  }
8391  for(i=0;i<strat->currIdx;i++)
8392  {
8393  Print("%d - %d\n",i,strat->syzIdx[i]);
8394  }
8395  PrintS("--------------------------------\n");
8396 #endif
8397  }
8398 }
int currIdx
Definition: kutil.h:317
int comp(const CanonicalForm &A, const CanonicalForm &B)
compare polynomials
#define p_GetCoeff(p, r)
Definition: monomials.h:50
STATIC_VAR gmp_float * diff
Definition: mpr_complex.cc:45
poly p_One(const ring r)
Definition: p_polys.cc:1313
static poly p_Neg(poly p, const ring r)
Definition: p_polys.h:1109
static void p_ExpVectorCopy(poly d_p, poly s_p, const ring r)
Definition: p_polys.h:1315

◆ is_shifted_p1()

static BOOLEAN is_shifted_p1 ( const poly  p,
const kStrategy  strat 
)
static

Definition at line 1268 of file kutil.cc.

1269 {
1270  if (rIsLPRing(currRing)
1271  && (strat->P.p1!=NULL))
1272  {
1273  // clean up strat->P.p1: may be shifted
1274  poly p=strat->P.p1;
1275  int lv=currRing->isLPring;
1276  BOOLEAN is_shifted=TRUE;
1277  for (int i=lv;i>0;i--)
1278  {
1279  if (pGetExp(p,i)!=0) { is_shifted=FALSE; break;}
1280  }
1281  if (is_shifted
1282  && (kFindInL1(p, strat)<0)
1283  && (kFindInT(p, strat->T, strat->tl) < 0)
1284  )
1285  {
1286  return TRUE;
1287  }
1288  }
1289  return FALSE;
1290 }
static int kFindInL1(const poly p, const kStrategy strat)
Definition: kutil.h:851
#define pGetExp(p, i)
Exponent.
Definition: polys.h:41

◆ isInPairsetB()

BOOLEAN isInPairsetB ( poly  q,
int *  k,
kStrategy  strat 
)

Definition at line 727 of file kutil.cc.

728 {
729  LObject *p=&(strat->B[strat->Bl]);
730 
731  *k = strat->Bl;
732  loop
733  {
734  if ((*k) < 0) return FALSE;
735  if (q == (*p).p1)
736  return TRUE;
737  (*k)--;
738  p--;
739  }
740 }

◆ isInPairsetL()

BOOLEAN isInPairsetL ( int  length,
poly  p1,
poly  p2,
int *  k,
kStrategy  strat 
)

Definition at line 706 of file kutil.cc.

707 {
708  LObject *p=&(strat->L[length]);
709 
710  *k = length;
711  loop
712  {
713  if ((*k) < 0) return FALSE;
714  if (((p1 == (*p).p1) && (p2 == (*p).p2))
715  || ((p1 == (*p).p2) && (p2 == (*p).p1)))
716  return TRUE;
717  (*k)--;
718  p--;
719  }
720 }

◆ kCheckSpolyCreation()

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

Definition at line 10807 of file kutil.cc.

10808 {
10809  if (strat->overflow) return FALSE;
10810  assume(L->p1 != NULL && L->p2 != NULL);
10811  // shift changes: from 0 to -1
10812  assume(L->i_r1 >= -1 && L->i_r1 <= strat->tl);
10813  assume(L->i_r2 >= -1 && L->i_r2 <= strat->tl);
10814 
10815  if (! k_GetLeadTerms(L->p1, L->p2, currRing, m1, m2, strat->tailRing))
10816  return FALSE;
10817  // shift changes: extra case inserted
10818  if ((L->i_r1 == -1) || (L->i_r2 == -1) )
10819  {
10820  return TRUE;
10821  }
10822  poly p1_max=NULL;
10823  if ((L->i_r1>=0)&&(strat->R[L->i_r1]!=NULL)) p1_max = (strat->R[L->i_r1])->max_exp;
10824  poly p2_max=NULL;
10825  if ((L->i_r2>=0)&&(strat->R[L->i_r2]!=NULL)) p2_max = (strat->R[L->i_r2])->max_exp;
10826 
10827  if (((p1_max != NULL) && !p_LmExpVectorAddIsOk(m1, p1_max, strat->tailRing)) ||
10828  ((p2_max != NULL) && !p_LmExpVectorAddIsOk(m2, p2_max, strat->tailRing)))
10829  {
10830  p_LmFree(m1, strat->tailRing);
10831  p_LmFree(m2, strat->tailRing);
10832  m1 = NULL;
10833  m2 = NULL;
10834  return FALSE;
10835  }
10836  return TRUE;
10837 }
char overflow
Definition: kutil.h:404
static BOOLEAN p_LmExpVectorAddIsOk(const poly p1, const poly p2, const ring r)
Definition: p_polys.h:2040

◆ kCheckStrongCreation()

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

Definition at line 10846 of file kutil.cc.

10847 {
10848  assume(strat->S_2_R[atS] >= -1 && strat->S_2_R[atS] <= strat->tl);
10849  //assume(strat->tailRing != currRing);
10850 
10851  poly p1_max = (strat->R[atR])->max_exp;
10852  poly p2_max = (strat->R[strat->S_2_R[atS]])->max_exp;
10853 
10854  if (((p1_max != NULL) && !p_LmExpVectorAddIsOk(m1, p1_max, strat->tailRing)) ||
10855  ((p2_max != NULL) && !p_LmExpVectorAddIsOk(m2, p2_max, strat->tailRing)))
10856  {
10857  return FALSE;
10858  }
10859  return TRUE;
10860 }

◆ kDebugPrint()

void kDebugPrint ( kStrategy  strat)

Output some debug info about a given strategy.

Definition at line 11833 of file kutil.cc.

11834 {
11835  PrintS("red: ");
11836  if (strat->red==redFirst) PrintS("redFirst\n");
11837  else if (strat->red==redHoney) PrintS("redHoney\n");
11838  else if (strat->red==redEcart) PrintS("redEcart\n");
11839  else if (strat->red==redHomog) PrintS("redHomog\n");
11840  else if (strat->red==redLazy) PrintS("redLazy\n");
11841  else if (strat->red==redLiftstd) PrintS("redLiftstd\n");
11842  else Print("%p\n",(void*)strat->red);
11843  PrintS("posInT: ");
11844  if (strat->posInT==posInT0) PrintS("posInT0\n");
11845  else if (strat->posInT==posInT1) PrintS("posInT1\n");
11846  else if (strat->posInT==posInT11) PrintS("posInT11\n");
11847  else if (strat->posInT==posInT110) PrintS("posInT110\n");
11848  else if (strat->posInT==posInT13) PrintS("posInT13\n");
11849  else if (strat->posInT==posInT15) PrintS("posInT15\n");
11850  else if (strat->posInT==posInT17) PrintS("posInT17\n");
11851  else if (strat->posInT==posInT17_c) PrintS("posInT17_c\n");
11852  else if (strat->posInT==posInT19) PrintS("posInT19\n");
11853  else if (strat->posInT==posInT2) PrintS("posInT2\n");
11854  #ifdef HAVE_RINGS
11855  else if (strat->posInT==posInT11Ring) PrintS("posInT11Ring\n");
11856  else if (strat->posInT==posInT110Ring) PrintS("posInT110Ring\n");
11857  else if (strat->posInT==posInT15Ring) PrintS("posInT15Ring\n");
11858  else if (strat->posInT==posInT17Ring) PrintS("posInT17Ring\n");
11859  else if (strat->posInT==posInT17_cRing) PrintS("posInT17_cRing\n");
11860  #endif
11861 #ifdef HAVE_MORE_POS_IN_T
11862  else if (strat->posInT==posInT_EcartFDegpLength) PrintS("posInT_EcartFDegpLength\n");
11863  else if (strat->posInT==posInT_FDegpLength) PrintS("posInT_FDegpLength\n");
11864  else if (strat->posInT==posInT_pLength) PrintS("posInT_pLength\n");
11865 #endif
11866  else if (strat->posInT==posInT_EcartpLength) PrintS("posInT_EcartpLength\n");
11867  else if (strat->posInT==posInTrg0) PrintS("posInTrg0\n");
11868  else Print("%p\n",(void*)strat->posInT);
11869  PrintS("posInL: ");
11870  if (strat->posInL==posInL0) PrintS("posInL0\n");
11871  else if (strat->posInL==posInL10) PrintS("posInL10\n");
11872  else if (strat->posInL==posInL11) PrintS("posInL11\n");
11873  else if (strat->posInL==posInL110) PrintS("posInL110\n");
11874  else if (strat->posInL==posInL13) PrintS("posInL13\n");
11875  else if (strat->posInL==posInL15) PrintS("posInL15\n");
11876  else if (strat->posInL==posInL17) PrintS("posInL17\n");
11877  else if (strat->posInL==posInL17_c) PrintS("posInL17_c\n");
11878  #ifdef HAVE_RINGS
11879  else if (strat->posInL==posInL0) PrintS("posInL0Ring\n");
11880  else if (strat->posInL==posInL11Ring) PrintS("posInL11Ring\n");
11881  else if (strat->posInL==posInL11Ringls) PrintS("posInL11Ringls\n");
11882  else if (strat->posInL==posInL110Ring) PrintS("posInL110Ring\n");
11883  else if (strat->posInL==posInL15Ring) PrintS("posInL15Ring\n");
11884  else if (strat->posInL==posInL17Ring) PrintS("posInL17Ring\n");
11885  else if (strat->posInL==posInL17_cRing) PrintS("posInL17_cRing\n");
11886  #endif
11887  else if (strat->posInL==posInLSpecial) PrintS("posInLSpecial\n");
11888  else if (strat->posInL==posInLrg0) PrintS("posInLrg0\n");
11889  else Print("%p\n",(void*)strat->posInL);
11890  PrintS("enterS: ");
11891  if (strat->enterS==enterSBba) PrintS("enterSBba\n");
11892  else if (strat->enterS==enterSMora) PrintS("enterSMora\n");
11893  else if (strat->enterS==enterSMoraNF) PrintS("enterSMoraNF\n");
11894  else Print("%p\n",(void*)strat->enterS);
11895  PrintS("initEcart: ");
11896  if (strat->initEcart==initEcartBBA) PrintS("initEcartBBA\n");
11897  else if (strat->initEcart==initEcartNormal) PrintS("initEcartNormal\n");
11898  else Print("%p\n",(void*)strat->initEcart);
11899  PrintS("initEcartPair: ");
11900  if (strat->initEcartPair==initEcartPairBba) PrintS("initEcartPairBba\n");
11901  else if (strat->initEcartPair==initEcartPairMora) PrintS("initEcartPairMora\n");
11902  else Print("%p\n",(void*)strat->initEcartPair);
11903  Print("homog=%d, LazyDegree=%d, LazyPass=%d, ak=%d,\n",
11904  strat->homog, strat->LazyDegree,strat->LazyPass, strat->ak);
11905  Print("honey=%d, sugarCrit=%d, Gebauer=%d, noTailReduction=%d, use_buckets=%d\n",
11906  strat->honey,strat->sugarCrit,strat->Gebauer,strat->noTailReduction,strat->use_buckets);
11907  PrintS("chainCrit: ");
11908  if (strat->chainCrit==chainCritNormal) PrintS("chainCritNormal\n");
11909  else if (strat->chainCrit==chainCritOpt_1) PrintS("chainCritOpt_1\n");
11910  else Print("%p\n",(void*)strat->chainCrit);
11911  Print("posInLDependsOnLength=%d\n",
11912  strat->posInLDependsOnLength);
11913  PrintS(showOption());PrintLn();
11914  PrintS("LDeg: ");
11915  if (currRing->pLDeg==pLDeg0) PrintS("pLDeg0");
11916  else if (currRing->pLDeg==pLDeg0c) PrintS("pLDeg0c");
11917  else if (currRing->pLDeg==pLDegb) PrintS("pLDegb");
11918  else if (currRing->pLDeg==pLDeg1) PrintS("pLDeg1");
11919  else if (currRing->pLDeg==pLDeg1c) PrintS("pLDeg1c");
11920  else if (currRing->pLDeg==pLDeg1_Deg) PrintS("pLDeg1_Deg");
11921  else if (currRing->pLDeg==pLDeg1c_Deg) PrintS("pLDeg1c_Deg");
11922  else if (currRing->pLDeg==pLDeg1_Totaldegree) PrintS("pLDeg1_Totaldegree");
11923  else if (currRing->pLDeg==pLDeg1c_Totaldegree) PrintS("pLDeg1c_Totaldegree");
11924  else if (currRing->pLDeg==pLDeg1_WFirstTotalDegree) PrintS("pLDeg1_WFirstTotalDegree");
11925  else if (currRing->pLDeg==pLDeg1c_WFirstTotalDegree) PrintS("pLDeg1c_WFirstTotalDegree");
11926  else if (currRing->pLDeg==maxdegreeWecart) PrintS("maxdegreeWecart");
11927  else Print("? (%lx)", (long)currRing->pLDeg);
11928  PrintS(" / ");
11929  if (strat->tailRing->pLDeg==pLDeg0) PrintS("pLDeg0");
11930  else if (strat->tailRing->pLDeg==pLDeg0c) PrintS("pLDeg0c");
11931  else if (strat->tailRing->pLDeg==pLDegb) PrintS("pLDegb");
11932  else if (strat->tailRing->pLDeg==pLDeg1) PrintS("pLDeg1");
11933  else if (strat->tailRing->pLDeg==pLDeg1c) PrintS("pLDeg1c");
11934  else if (strat->tailRing->pLDeg==pLDeg1_Deg) PrintS("pLDeg1_Deg");
11935  else if (strat->tailRing->pLDeg==pLDeg1c_Deg) PrintS("pLDeg1c_Deg");
11936  else if (strat->tailRing->pLDeg==pLDeg1_Totaldegree) PrintS("pLDeg1_Totaldegree");
11937  else if (strat->tailRing->pLDeg==pLDeg1c_Totaldegree) PrintS("pLDeg1c_Totaldegree");
11938  else if (strat->tailRing->pLDeg==pLDeg1_WFirstTotalDegree) PrintS("pLDeg1_WFirstTotalDegree");
11939  else if (strat->tailRing->pLDeg==pLDeg1c_WFirstTotalDegree) PrintS("pLDeg1c_WFirstTotalDegree");
11940  else if (strat->tailRing->pLDeg==maxdegreeWecart) PrintS("maxdegreeWecart");
11941  else Print("? (%lx)", (long)strat->tailRing->pLDeg);
11942  PrintLn();
11943  PrintS("currRing->pFDeg: ");
11944  if (currRing->pFDeg==p_Totaldegree) PrintS("p_Totaldegree");
11945  else if (currRing->pFDeg==p_WFirstTotalDegree) PrintS("pWFirstTotalDegree");
11946  else if (currRing->pFDeg==p_Deg) PrintS("p_Deg");
11947  else if (currRing->pFDeg==kHomModDeg) PrintS("kHomModDeg");
11948  else if (currRing->pFDeg==totaldegreeWecart) PrintS("totaldegreeWecart");
11949  else if (currRing->pFDeg==p_WTotaldegree) PrintS("p_WTotaldegree");
11950  else Print("? (%lx)", (long)currRing->pFDeg);
11951  PrintLn();
11952  Print(" syzring:%d, syzComp(strat):%d limit:%d\n",rIsSyzIndexRing(currRing),strat->syzComp,rGetCurrSyzLimit(currRing));
11953  if(TEST_OPT_DEGBOUND)
11954  Print(" degBound: %d\n", Kstd1_deg);
11955 
11956  if( ecartWeights != NULL )
11957  {
11958  PrintS("ecartWeights: ");
11959  for (int i = rVar(currRing); i > 0; i--)
11960  Print("%hd ", ecartWeights[i]);
11961  PrintLn();
11963  }
11964 
11965 #ifndef SING_NDEBUG
11967 #endif
11968 }
char use_buckets
Definition: kutil.h:383
int LazyPass
Definition: kutil.h:353
int(* red)(LObject *L, kStrategy strat)
Definition: kutil.h:278
int LazyDegree
Definition: kutil.h:353
int redLiftstd(LObject *h, kStrategy strat)
Definition: kLiftstd.cc:167
long kHomModDeg(poly p, ring r)
Definition: kstd1.cc:2420
int redHoney(LObject *h, kStrategy strat)
Definition: kstd2.cc:1905
int redHomog(LObject *h, kStrategy strat)
Definition: kstd2.cc:938
int redLazy(LObject *h, kStrategy strat)
Definition: kstd2.cc:1698
int posInTrg0(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5131
int redFirst(LObject *h, kStrategy strat)
Definition: kstd1.cc:797
int redEcart(LObject *h, kStrategy strat)
Definition: kstd1.cc:169
void enterSMoraNF(LObject &p, int atS, kStrategy strat, int atR=-1)
Definition: kstd1.cc:1668
int posInT2(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5025
int posInT_pLength(const TSet set, const int length, LObject &p)
Definition: kutil.cc:11799
void initEcartPairMora(LObject *Lp, poly, poly, int ecartF, int ecartG)
Definition: kutil.cc:1406
int posInT_EcartFDegpLength(const TSet set, const int length, LObject &p)
Definition: kutil.cc:11708
VAR int Kstd1_deg
Definition: kutil.cc:247
void initEcartNormal(TObject *h)
Definition: kutil.cc:1384
char * showOption()
Definition: misc_ip.cc:709
int posInLrg0(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:6274
void enterSMora(LObject &p, int atS, kStrategy strat, int atR=-1)
Definition: kstd1.cc:1615
int posInT_FDegpLength(const TSet set, const int length, LObject &p)
Definition: kutil.cc:11762
void initEcartBBA(TObject *h)
Definition: kutil.cc:1392
void initEcartPairBba(LObject *Lp, poly, poly, int, int)
Definition: kutil.cc:1399
#define TEST_OPT_DEGBOUND
Definition: options.h:114
long pLDegb(poly p, int *l, const ring r)
Definition: p_polys.cc:811
long pLDeg1_Totaldegree(poly p, int *l, const ring r)
Definition: p_polys.cc:975
long p_WFirstTotalDegree(poly p, const ring r)
Definition: p_polys.cc:596
long pLDeg1_WFirstTotalDegree(poly p, int *l, const ring r)
Definition: p_polys.cc:1038
long pLDeg1c_WFirstTotalDegree(poly p, int *l, const ring r)
Definition: p_polys.cc:1068
long pLDeg1c_Deg(poly p, int *l, const ring r)
Definition: p_polys.cc:941
long pLDeg1(poly p, int *l, const ring r)
Definition: p_polys.cc:841
long pLDeg1_Deg(poly p, int *l, const ring r)
Definition: p_polys.cc:910
long p_WTotaldegree(poly p, const ring r)
Definition: p_polys.cc:613
long pLDeg1c(poly p, int *l, const ring r)
Definition: p_polys.cc:877
long pLDeg1c_Totaldegree(poly p, int *l, const ring r)
Definition: p_polys.cc:1005
long pLDeg0c(poly p, int *l, const ring r)
Definition: p_polys.cc:770
long pLDeg0(poly p, int *l, const ring r)
Definition: p_polys.cc:739
long p_Deg(poly a, const ring r)
Definition: p_polys.cc:587
static long p_Totaldegree(poly p, const ring r)
Definition: p_polys.h:1509
void rDebugPrint(const ring r)
Definition: ring.cc:4164
static int rGetCurrSyzLimit(const ring r)
Definition: ring.h:724
long totaldegreeWecart(poly p, ring r)
Definition: weight.cc:217
long maxdegreeWecart(poly p, int *l, ring r)
Definition: weight.cc:247
EXTERN_VAR short * ecartWeights
Definition: weight.h:12

◆ kFindDivisibleByInS_T()

TObject* kFindDivisibleByInS_T ( kStrategy  strat,
int  end_pos,
LObject L,
TObject T,
long  ecart 
)

Definition at line 7005 of file kutil.cc.

7006 {
7007  int j = 0;
7008  const unsigned long not_sev = ~L->sev;
7009  const unsigned long* sev = strat->sevS;
7010  poly p;
7011  ring r;
7012  L->GetLm(p, r);
7013 
7014  assume(~not_sev == p_GetShortExpVector(p, r));
7015 
7016  if (r == currRing)
7017  {
7018  if(!rField_is_Ring(r))
7019  {
7020  loop
7021  {
7022  if (j > end_pos) return NULL;
7023  #if defined(PDEBUG) || defined(PDIV_DEBUG)
7024  if (strat->S[j]!= NULL && p_LmShortDivisibleBy(strat->S[j], sev[j], p, not_sev, r) &&
7025  (ecart== LONG_MAX || ecart>= strat->ecartS[j]))
7026  {
7027  break;
7028  }
7029  #else
7030  if (!(sev[j] & not_sev) &&
7031  (ecart== LONG_MAX || ecart>= strat->ecartS[j]) &&
7032  p_LmDivisibleBy(strat->S[j], p, r))
7033  {
7034  break;
7035  }
7036  #endif
7037  j++;
7038  }
7039  }
7040  #ifdef HAVE_RINGS
7041  else
7042  {
7043  loop
7044  {
7045  if (j > end_pos) return NULL;
7046  #if defined(PDEBUG) || defined(PDIV_DEBUG)
7047  if (strat->S[j]!= NULL && p_LmShortDivisibleBy(strat->S[j], sev[j], p, not_sev, r) &&
7048  (ecart== LONG_MAX || ecart>= strat->ecartS[j]) && n_DivBy(pGetCoeff(p), pGetCoeff(strat->S[j]), r->cf))
7049  {
7050  break;
7051  }
7052  #else
7053  if (!(sev[j] & not_sev) &&
7054  (ecart== LONG_MAX || ecart>= strat->ecartS[j]) &&
7055  p_LmDivisibleBy(strat->S[j], p, r) && n_DivBy(pGetCoeff(p), pGetCoeff(strat->S[j]), r->cf))
7056  {
7057  break;
7058  }
7059  #endif
7060  j++;
7061  }
7062  }
7063  #endif
7064  // if called from NF, T objects do not exist:
7065  if (strat->tl < 0 || strat->S_2_R[j] == -1)
7066  {
7067  T->Set(strat->S[j], r, strat->tailRing);
7068  assume(T->GetpLength()==pLength(T->p != __null ? T->p : T->t_p));
7069  return T;
7070  }
7071  else
7072  {
7073 ///// assume (j >= 0 && j <= strat->tl && strat->S_2_T(j) != NULL
7074 ///// && strat->S_2_T(j)->p == strat->S[j]); // wrong?
7075 // assume (j >= 0 && j <= strat->sl && strat->S_2_T(j) != NULL && strat->S_2_T(j)->p == strat->S[j]);
7076  return strat->S_2_T(j);
7077  }
7078  }
7079  else
7080  {
7081  TObject* t;
7082  if(!rField_is_Ring(r))
7083  {
7084  loop
7085  {
7086  if (j > end_pos) return NULL;
7087  assume(strat->S_2_R[j] != -1);
7088  #if defined(PDEBUG) || defined(PDIV_DEBUG)
7089  t = strat->S_2_T(j);
7090  assume(t != NULL && t->t_p != NULL && t->tailRing == r);
7091  if (p_LmShortDivisibleBy(t->t_p, sev[j], p, not_sev, r) &&
7092  (ecart== LONG_MAX || ecart>= strat->ecartS[j]))
7093  {
7094  t->pLength=pLength(t->t_p);
7095  return t;
7096  }
7097  #else
7098  if (! (sev[j] & not_sev) && (ecart== LONG_MAX || ecart>= strat->ecartS[j]))
7099  {
7100  t = strat->S_2_T(j);
7101  assume(t != NULL && t->t_p != NULL && t->tailRing == r && t->p == strat->S[j]);
7102  if (p_LmDivisibleBy(t->t_p, p, r))
7103  {
7104  t->pLength=pLength(t->t_p);
7105  return t;
7106  }
7107  }
7108  #endif
7109  j++;
7110  }
7111  }
7112  #ifdef HAVE_RINGS
7113  else
7114  {
7115  loop
7116  {
7117  if (j > end_pos) return NULL;
7118  assume(strat->S_2_R[j] != -1);
7119  #if defined(PDEBUG) || defined(PDIV_DEBUG)
7120  t = strat->S_2_T(j);
7121  assume(t != NULL && t->t_p != NULL && t->tailRing == r);
7122  if (p_LmShortDivisibleBy(t->t_p, sev[j], p, not_sev, r) &&
7123  (ecart== LONG_MAX || ecart>= strat->ecartS[j]) && n_DivBy(pGetCoeff(p), pGetCoeff(t->t_p), r->cf))
7124  {
7125  t->pLength=pLength(t->t_p);
7126  return t;
7127  }
7128  #else
7129  if (! (sev[j] & not_sev) && (ecart== LONG_MAX || ecart>= strat->ecartS[j]))
7130  {
7131  t = strat->S_2_T(j);
7132  assume(t != NULL && t->t_p != NULL && t->tailRing == r && t->p == strat->S[j]);
7133  if (p_LmDivisibleBy(t->t_p, p, r) && n_DivBy(pGetCoeff(p), pGetCoeff(t->t_p), r->cf))
7134  {
7135  t->pLength=pLength(t->t_p);
7136  return t;
7137  }
7138  }
7139  #endif
7140  j++;
7141  }
7142  }
7143  #endif
7144  }
7145 }
KINLINE TObject * S_2_T(int i)
Definition: kInline.h:38

◆ kFindInT() [1/2]

int kFindInT ( poly  p,
kStrategy  strat 
)

Definition at line 753 of file kutil.cc.

754 {
755  int i;
756  do
757  {
758  i = kFindInT(p, strat->T, strat->tl);
759  if (i >= 0) return i;
760  strat = strat->next;
761  }
762  while (strat != NULL);
763  return -1;
764 }
kStrategy next
Definition: kutil.h:277

◆ kFindInT() [2/2]

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

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

Definition at line 742 of file kutil.cc.

743 {
744  int i;
745 
746  for (i=0; i<=tlength; i++)
747  {
748  if (T[i].p == p) return i;
749  }
750  return -1;
751 }

◆ kFindInTShift() [1/2]

int kFindInTShift ( poly  p,
kStrategy  strat 
)

Definition at line 781 of file kutil.cc.

782 {
783  int i;
784  do
785  {
786  i = kFindInTShift(p, strat->T, strat->tl);
787  if (i >= 0) return i;
788  strat = strat->next;
789  }
790  while (strat != NULL);
791  return -1;
792 }
int kFindInTShift(poly p, TSet T, int tlength)
Definition: kutil.cc:767

◆ kFindInTShift() [2/2]

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

Definition at line 767 of file kutil.cc.

768 {
769  int i;
770 
771  for (i=0; i<=tlength; i++)
772  {
773  // in the Letterplace ring the LMs in T and L are copies thus we have to use pEqualPolys() instead of ==
774  if (pEqualPolys(T[i].p, p)) return i;
775  }
776  return -1;
777 }
#define pEqualPolys(p1, p2)
Definition: polys.h:400

◆ kMergeBintoL()

void kMergeBintoL ( kStrategy  strat)

Definition at line 3254 of file kutil.cc.

3255 {
3256  int j=strat->Ll+strat->Bl+1;
3257  if (j>strat->Lmax)
3258  {
3259  j=((j+setmaxLinc-1)/setmaxLinc)*setmaxLinc-strat->Lmax;
3260  enlargeL(&(strat->L),&(strat->Lmax),j);
3261  }
3262  j = strat->Ll;
3263  int i;
3264  for (i=strat->Bl; i>=0; i--)
3265  {
3266  j = strat->posInL(strat->L,j,&(strat->B[i]),strat);
3267  enterL(&strat->L,&strat->Ll,&strat->Lmax,strat->B[i],j);
3268  }
3269  strat->Bl = -1;
3270 }

◆ kMergeBintoLSba()

void kMergeBintoLSba ( kStrategy  strat)

Definition at line 3275 of file kutil.cc.

3276 {
3277  int j=strat->Ll+strat->Bl+1;
3278  if (j>strat->Lmax)
3279  {
3280  j=((j+setmaxLinc-1)/setmaxLinc)*setmaxLinc-strat->Lmax;
3281  enlargeL(&(strat->L),&(strat->Lmax),j);
3282  }
3283  j = strat->Ll;
3284  int i;
3285  for (i=strat->Bl; i>=0; i--)
3286  {
3287  j = strat->posInLSba(strat->L,j,&(strat->B[i]),strat);
3288  enterL(&strat->L,&strat->Ll,&strat->Lmax,strat->B[i],j);
3289  }
3290  strat->Bl = -1;
3291 }

◆ kPosInLDependsOnLength()

BOOLEAN kPosInLDependsOnLength ( int(*)(const LSet set, const int length, LObject *L, const kStrategy strat)  pos_in_l)

Definition at line 9884 of file kutil.cc.

9887 {
9888  if (pos_in_l == posInL110
9889  || pos_in_l == posInL10
9890  #ifdef HAVE_RINGS
9891  || pos_in_l == posInL110Ring
9892  || pos_in_l == posInLRing
9893  #endif
9894  )
9895  return TRUE;
9896 
9897  return FALSE;
9898 }
int posInLRing(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:5945

◆ kStratChangeTailRing()

BOOLEAN kStratChangeTailRing ( kStrategy  strat,
LObject L,
TObject T,
unsigned long  expbound 
)

Definition at line 11294 of file kutil.cc.

11295 {
11296  assume((strat->tailRing == currRing) || (strat->tailRing->bitmask <= currRing->bitmask));
11297  /* initial setup or extending */
11298 
11299  if (rIsLPRing(currRing)) return TRUE;
11300  if (expbound == 0) expbound = strat->tailRing->bitmask << 1;
11301  if (expbound >= currRing->bitmask) return FALSE;
11302  strat->overflow=FALSE;
11303  ring new_tailRing = rModifyRing(currRing,
11304  // Hmmm .. the condition pFDeg == p_Deg
11305  // might be too strong
11306  (strat->homog && currRing->pFDeg == p_Deg && !(rField_is_Ring(currRing))), // omit degree
11307  (strat->ak==0), // omit_comp if the input is an ideal
11308  expbound); // exp_limit
11309 
11310  if (new_tailRing == currRing) return TRUE;
11311 
11312  strat->pOrigFDeg_TailRing = new_tailRing->pFDeg;
11313  strat->pOrigLDeg_TailRing = new_tailRing->pLDeg;
11314 
11315  if (currRing->pFDeg != currRing->pFDegOrig)
11316  {
11317  new_tailRing->pFDeg = currRing->pFDeg;
11318  new_tailRing->pLDeg = currRing->pLDeg;
11319  }
11320 
11321  if (TEST_OPT_PROT)
11322  Print("[%lu:%d", (unsigned long) new_tailRing->bitmask, new_tailRing->ExpL_Size);
11323  kTest_TS(strat);
11324  assume(new_tailRing != strat->tailRing);
11325  pShallowCopyDeleteProc p_shallow_copy_delete
11326  = pGetShallowCopyDeleteProc(strat->tailRing, new_tailRing);
11327 
11328  omBin new_tailBin = omGetStickyBinOfBin(new_tailRing->PolyBin);
11329 
11330  int i;
11331  for (i=0; i<=strat->tl; i++)
11332  {
11333  strat->T[i].ShallowCopyDelete(new_tailRing, new_tailBin,
11334  p_shallow_copy_delete);
11335  }
11336  for (i=0; i<=strat->Ll; i++)
11337  {
11338  assume(strat->L[i].p != NULL);
11339  if (pNext(strat->L[i].p) != strat->tail)
11340  strat->L[i].ShallowCopyDelete(new_tailRing, p_shallow_copy_delete);
11341  }
11342  if ((strat->P.t_p != NULL) ||
11343  ((strat->P.p != NULL) && pNext(strat->P.p) != strat->tail))
11344  strat->P.ShallowCopyDelete(new_tailRing, p_shallow_copy_delete);
11345 
11346  if ((L != NULL) && (L->tailRing != new_tailRing))
11347  {
11348  if (L->i_r < 0)
11349  L->ShallowCopyDelete(new_tailRing, p_shallow_copy_delete);
11350  else
11351  {
11352  assume(L->i_r <= strat->tl);
11353  TObject* t_l = strat->R[L->i_r];
11354  assume(t_l != NULL);
11355  L->tailRing = new_tailRing;
11356  L->p = t_l->p;
11357  L->t_p = t_l->t_p;
11358  L->max_exp = t_l->max_exp;
11359  }
11360  }
11361 
11362  if ((T != NULL) && (T->tailRing != new_tailRing && T->i_r < 0))
11363  T->ShallowCopyDelete(new_tailRing, new_tailBin, p_shallow_copy_delete);
11364 
11365  omMergeStickyBinIntoBin(strat->tailBin, strat->tailRing->PolyBin);
11366  if (strat->tailRing != currRing)
11367  rKillModifiedRing(strat->tailRing);
11368 
11369  strat->tailRing = new_tailRing;
11370  strat->tailBin = new_tailBin;
11371  strat->p_shallow_copy_delete
11372  = pGetShallowCopyDeleteProc(currRing, new_tailRing);
11373 
11374  if (strat->kNoether != NULL)
11375  {
11376  if (strat->t_kNoether != NULL)
11377  p_LmFree(strat->t_kNoether, strat->tailRing);
11378  strat->t_kNoether=k_LmInit_currRing_2_tailRing(strat->kNoether, new_tailRing);
11379  }
11380 
11381  kTest_TS(strat);
11382  if (TEST_OPT_PROT)
11383  PrintS("]");
11384  return TRUE;
11385 }
poly t_kNoether
Definition: kutil.h:330
pFDegProc pOrigFDeg_TailRing
Definition: kutil.h:298
pShallowCopyDeleteProc p_shallow_copy_delete
Definition: kutil.h:338
pLDegProc pOrigLDeg_TailRing
Definition: kutil.h:299
omBin_t * omBin
Definition: omStructs.h:12
void rKillModifiedRing(ring r)
Definition: ring.cc:3101
ring rModifyRing(ring r, BOOLEAN omit_degree, BOOLEAN try_omit_comp, unsigned long exp_limit)
Definition: ring.cc:2740
#define omGetStickyBinOfBin(B)
Definition: xalloc.h:247
#define omMergeStickyBinIntoBin(A, B)
Definition: xalloc.h:275

◆ kStratInitChangeTailRing()

void kStratInitChangeTailRing ( kStrategy  strat)

Definition at line 11387 of file kutil.cc.

11388 {
11389  unsigned long l = 0;
11390  int i;
11391  long e;
11392 
11393  assume(strat->tailRing == currRing);
11394 
11395  for (i=0; i<= strat->Ll; i++)
11396  {
11397  l = p_GetMaxExpL(strat->L[i].p, currRing, l);
11398  }
11399  for (i=0; i<=strat->tl; i++)
11400  {
11401  // Hmm ... this we could do in one Step
11402  l = p_GetMaxExpL(strat->T[i].p, currRing, l);
11403  }
11404  if (rField_is_Ring(currRing))
11405  {
11406  l *= 2;
11407  }
11408  e = p_GetMaxExp(l, currRing);
11409  if (e <= 1) e = 2;
11410  if (rIsLPRing(currRing)) e = 1;
11411 
11412  kStratChangeTailRing(strat, NULL, NULL, e);
11413 }
BOOLEAN kStratChangeTailRing(kStrategy strat, LObject *L, TObject *T, unsigned long expbound)
Definition: kutil.cc:11294
unsigned long p_GetMaxExpL(poly p, const ring r, unsigned long l_max)
return the maximal exponent of p in form of the maximal long var
Definition: p_polys.cc:1175
static unsigned long p_GetMaxExp(const unsigned long l, const ring r)
Definition: p_polys.h:783

◆ kTest()

BOOLEAN kTest ( kStrategy  strat)

Definition at line 1036 of file kutil.cc.

1037 {
1038  int i;
1039  // test P
1040  kFalseReturn(kTest_L(&(strat->P), strat,
1041  (strat->P.p != NULL && pNext(strat->P.p)!=strat->tail),
1042  -1, strat->T, strat->tl));
1043 
1044  // test T
1045  if (strat->T != NULL)
1046  {
1047  for (i=0; i<=strat->tl; i++)
1048  {
1049  kFalseReturn(kTest_T(&(strat->T[i]), strat, i, 'T'));
1050  if (strat->sevT[i] != pGetShortExpVector(strat->T[i].p))
1051  return dReportError("strat->sevT[%d] out of sync", i);
1052  }
1053  }
1054 
1055  // test L
1056  if (strat->L != NULL)
1057  {
1058  for (i=0; i<=strat->Ll; i++)
1059  {
1060  kFalseReturn(kTest_L(&(strat->L[i]), strat,
1061  strat->L[i].Next() != strat->tail, i,
1062  strat->T, strat->tl));
1063  // may be unused
1064  //if (strat->use_buckets && strat->L[i].Next() != strat->tail &&
1065  // strat->L[i].Next() != NULL && strat->L[i].p1 != NULL)
1066  //{
1067  // assume(strat->L[i].bucket != NULL);
1068  //}
1069  }
1070  }
1071 
1072  // test S
1073  if (strat->S != NULL)
1074  kFalseReturn(kTest_S(strat));
1075 
1076  return TRUE;
1077 }
#define kFalseReturn(x)
Definition: kutil.cc:804
BOOLEAN kTest_S(kStrategy strat)
Definition: kutil.cc:1079
int dReportError(const char *fmt,...)
Definition: dError.cc:44

◆ kTest_L()

BOOLEAN kTest_L ( LObject L,
kStrategy  strat,
BOOLEAN  testp,
int  lpos,
TSet  T,
int  tlength 
)

Definition at line 950 of file kutil.cc.

952 {
953  ring strat_tailRing=strat->tailRing;
954  if (L->p!=NULL)
955  {
956  if ((L->t_p==NULL)
957  &&(pNext(L->p)!=NULL)
958  &&(pGetCoeff(pNext(L->p))!=NULL)) /* !=strat->tail*/
959  {
960  p_Test(pNext(L->p),currRing);
961  nTest(pGetCoeff(L->p));
962  }
963  }
964  if (L->t_p!=NULL)
965  {
966  if ((pNext(L->t_p)!=NULL)
967  &&(pGetCoeff(pNext(L->t_p))!=NULL)) /* !=strat->tail*/
968  {
969  p_Test(pNext(L->t_p),strat_tailRing);
970  nTest(pGetCoeff(L->t_p));
971  }
972  }
973  if ((L->p!=NULL)&&(L->t_p!=NULL)) assume(pGetCoeff(L->p)==pGetCoeff(L->t_p));
974 
975  if (testp)
976  {
977  poly pn = NULL;
978  if (L->bucket != NULL)
979  {
980  kFalseReturn(kbTest(L->bucket));
981  r_assume(L->bucket->bucket_ring == L->tailRing);
982  if (L->p != NULL && pNext(L->p) != NULL)
983  {
984  pn = pNext(L->p);
985  pNext(L->p) = NULL;
986  }
987  }
988  kFalseReturn(kTest_T(L, strat, lpos, 'L'));
989  if (pn != NULL)
990  pNext(L->p) = pn;
991 
992  ring r;
993  poly p;
994  L->GetLm(p, r);
995  if (L->sev != 0L)
996  {
997  if (p_GetShortExpVector(p, r) != L->sev)
998  {
999  return dReportError("L[%d] wrong sev: has %lo, specified to have %lo",
1000  lpos, p_GetShortExpVector(p, r), L->sev);
1001  }
1002  }
1003  }
1004  if (L->p1 == NULL)
1005  {
1006  // L->p2 either NULL or "normal" poly
1007  pFalseReturn(pp_Test(L->p2, currRing, L->tailRing));
1008  }
1009  else if (tlength > 0 && T != NULL && (lpos >=0))
1010  {
1011  // now p1 and p2 must be != NULL and must be contained in T
1012  int i;
1013 #ifdef HAVE_SHIFTBBA
1014  if (rIsLPRing(currRing))
1015  i = kFindInTShift(L->p1, T, tlength);
1016  else
1017 #endif
1018  i = kFindInT(L->p1, T, tlength);
1019  if (i < 0)
1020  return dReportError("L[%d].p1 not in T",lpos);
1021 #ifdef HAVE_SHIFTBBA
1022  if (rIsLPRing(currRing))
1023  {
1024  if (rField_is_Ring(currRing)) return TRUE; // m*shift(q) is not in T
1025  i = kFindInTShift(L->p2, T, tlength);
1026  }
1027  else
1028 #endif
1029  i = kFindInT(L->p2, T, tlength);
1030  if (i < 0)
1031  return dReportError("L[%d].p2 not in T",lpos);
1032  }
1033  return TRUE;
1034 }
BOOLEAN kbTest(kBucket_pt bucket)
Tests.
Definition: kbuckets.cc:197
#define r_assume(x)
Definition: mod2.h:390
#define pFalseReturn(cond)
Definition: monomials.h:139
#define nTest(a)
Definition: numbers.h:35

◆ kTest_LmEqual()

static const char* kTest_LmEqual ( poly  p,
poly  t_p,
ring  tailRing 
)
static

Definition at line 807 of file kutil.cc.

808 {
809  int i;
810  for (i=1; i<=tailRing->N; i++)
811  {
812  if (p_GetExp(p, i, currRing) != p_GetExp(t_p, i, tailRing))
813  return "Lm[i] different";
814  }
815  if (p_GetComp(p, currRing) != p_GetComp(t_p, tailRing))
816  return "Lm[0] different";
817  if (pNext(p) != pNext(t_p))
818  return "Lm.next different";
819  if (pGetCoeff(p) != pGetCoeff(t_p))
820  return "Lm.coeff different";
821  return NULL;
822 }

◆ kTest_S()

BOOLEAN kTest_S ( kStrategy  strat)

Definition at line 1079 of file kutil.cc.

1080 {
1081  int i;
1082  BOOLEAN ret = TRUE;
1083  for (i=0; i<=strat->sl; i++)
1084  {
1085  if (strat->S[i] != NULL &&
1086  strat->sevS[i] != pGetShortExpVector(strat->S[i]))
1087  {
1088  return dReportError("S[%d] wrong sev: has %o, specified to have %o",
1089  i , pGetShortExpVector(strat->S[i]), strat->sevS[i]);
1090  }
1091  }
1092  return ret;
1093 }

◆ kTest_T()

BOOLEAN kTest_T ( TObject T,
kStrategy  strat,
int  i,
char  TN 
)

Definition at line 825 of file kutil.cc.

826 {
827  ring tailRing = T->tailRing;
828  ring strat_tailRing = strat->tailRing;
829  if (strat_tailRing == NULL) strat_tailRing = tailRing;
830  r_assume(strat_tailRing == tailRing);
831 
832  poly p = T->p;
833  // ring r = currRing;
834 
835  if (T->p == NULL && T->t_p == NULL && i >= 0)
836  return dReportError("%c[%d].poly is NULL", TN, i);
837 
838  if (T->p!=NULL)
839  {
840  nTest(pGetCoeff(T->p));
841  if ((T->t_p==NULL)&&(pNext(T->p)!=NULL)) p_Test(pNext(T->p),currRing);
842  }
843  if (T->t_p!=NULL)
844  {
845  nTest(pGetCoeff(T->t_p));
846  if (pNext(T->t_p)!=NULL) p_Test(pNext(T->t_p),strat_tailRing);
847  }
848  if ((T->p!=NULL)&&(T->t_p!=NULL)) assume(pGetCoeff(T->p)==pGetCoeff(T->t_p));
849 
850  if (T->tailRing != currRing)
851  {
852  if (T->t_p == NULL && i > 0)
853  return dReportError("%c[%d].t_p is NULL", TN, i);
854  pFalseReturn(p_Test(T->t_p, T->tailRing));
855  if (T->p != NULL) pFalseReturn(p_LmTest(T->p, currRing));
856  if ((T->p != NULL) && (T->t_p != NULL))
857  {
858  const char* msg = kTest_LmEqual(T->p, T->t_p, T->tailRing);
859  if (msg != NULL)
860  return dReportError("%c[%d] %s", TN, i, msg);
861  // r = T->tailRing;
862  p = T->t_p;
863  }
864  if (T->p == NULL)
865  {
866  p = T->t_p;
867  // r = T->tailRing;
868  }
869  if (T->t_p != NULL && i >= 0 && TN == 'T')
870  {
871  if (pNext(T->t_p) == NULL)
872  {
873  if (T->max_exp != NULL)
874  return dReportError("%c[%d].max_exp is not NULL as it should be", TN, i);
875  }
876  else
877  {
878  if (T->max_exp == NULL)
879  return dReportError("%c[%d].max_exp is NULL", TN, i);
880  if (pNext(T->max_exp) != NULL)
881  return dReportError("pNext(%c[%d].max_exp) != NULL", TN, i);
882 
883  pFalseReturn(p_CheckPolyRing(T->max_exp, tailRing));
884  omCheckBinAddrSize(T->max_exp, (omSizeWOfBin(tailRing->PolyBin))*SIZEOF_LONG);
885 #if KDEBUG > 0
886  if (! sloppy_max)
887  {
888  poly test_max = p_GetMaxExpP(pNext(T->t_p), tailRing);
889  p_Setm(T->max_exp, tailRing);
890  p_Setm(test_max, tailRing);
891  BOOLEAN equal = p_ExpVectorEqual(T->max_exp, test_max, tailRing);
892  if (! equal)
893  return dReportError("%c[%d].max out of sync", TN, i);
894  p_LmFree(test_max, tailRing);
895  }
896 #endif
897  }
898  }
899  }
900  else
901  {
902  if (T->p == NULL && i > 0)
903  return dReportError("%c[%d].p is NULL", TN, i);
904 #ifdef HAVE_SHIFTBBA
905  if (currRing->isLPring && T->shift > 0)
906  {
907  // in this case, the order is not correct. test LM and tail separately
910  }
911  else
912 #endif
913  {
915  }
916  }
917 
918  if ((i >= 0) && (T->pLength != 0)
919  && (! rIsSyzIndexRing(currRing)) && (T->pLength != pLength(p)))
920  {
921  int l=T->pLength;
922  T->pLength=pLength(p);
923  return dReportError("%c[%d] pLength error: has %d, specified to have %d",
924  TN, i , pLength(p), l);
925  }
926 
927  // check FDeg, for elements in L and T
928  if (i >= 0 && (TN == 'T' || TN == 'L'))
929  {
930  // FDeg has ir element from T of L set
931  if (strat->homog && (T->FDeg != T->pFDeg()))
932  {
933  int d=T->FDeg;
934  T->FDeg=T->pFDeg();
935  return dReportError("%c[%d] FDeg error: has %d, specified to have %d",
936  TN, i , T->pFDeg(), d);
937  }
938  }
939 
940  // check is_normalized for elements in T
941  if (i >= 0 && TN == 'T')
942  {
943  if (T->is_normalized && ! nIsOne(pGetCoeff(p)))
944  return dReportError("T[%d] is_normalized error", i);
945 
946  }
947  return TRUE;
948 }
bool equal
Definition: cfModGcd.cc:4126
static const char * kTest_LmEqual(poly p, poly t_p, ring tailRing)
Definition: kutil.cc:807
#define omCheckBinAddrSize(addr, size)
Definition: omAllocDecl.h:326
#define omSizeWOfBin(bin_ptr)
static BOOLEAN p_ExpVectorEqual(poly p1, poly p2, const ring r1, const ring r2)
Definition: p_polys.cc:4642
BOOLEAN p_CheckPolyRing(poly p, ring r)
Definition: pDebug.cc:112

◆ kTest_TS()

BOOLEAN kTest_TS ( kStrategy  strat)

Definition at line 1097 of file kutil.cc.

1098 {
1099  int i, j;
1100  // BOOLEAN ret = TRUE;
1101  kFalseReturn(kTest(strat));
1102 
1103  // test strat->R, strat->T[i].i_r
1104  for (i=0; i<=strat->tl; i++)
1105  {
1106  if (strat->T[i].i_r < 0 || strat->T[i].i_r > strat->tl)
1107  return dReportError("strat->T[%d].i_r == %d out of bounds", i,
1108  strat->T[i].i_r);
1109  if (strat->R[strat->T[i].i_r] != &(strat->T[i]))
1110  return dReportError("T[%d].i_r with R out of sync", i);
1111  }
1112  // test containment of S inT
1113  if ((strat->S != NULL)&&(strat->tl>=0))
1114  {
1115  for (i=0; i<=strat->sl; i++)
1116  {
1117  j = kFindInT(strat->S[i], strat->T, strat->tl);
1118  if (j < 0)
1119  return dReportError("S[%d] not in T", i);
1120  if (strat->S_2_R[i] != strat->T[j].i_r)
1121  return dReportError("S_2_R[%d]=%d != T[%d].i_r=%d\n",
1122  i, strat->S_2_R[i], j, strat->T[j].i_r);
1123  }
1124  }
1125  // test strat->L[i].i_r1
1126  #ifdef HAVE_SHIFTBBA
1127  if (!rIsLPRing(currRing)) // in the Letterplace ring we currently don't set/use i_r1 and i_r2
1128  #endif
1129  if (strat->L!=NULL)
1130  {
1131  for (i=0; i<=strat->Ll; i++)
1132  {
1133  if (strat->L[i].p1 != NULL && strat->L[i].p2)
1134  {
1135  if (strat->L[i].i_r1 < 0 ||
1136  strat->L[i].i_r1 > strat->tl ||
1137  strat->L[i].T_1(strat)->p != strat->L[i].p1)
1138  return dReportError("L[%d].i_r1 out of sync", i);
1139  if (strat->L[i].i_r2 < 0 ||
1140  strat->L[i].i_r2 > strat->tl ||
1141  strat->L[i].T_2(strat)->p != strat->L[i].p2)
1142  return dReportError("L[%d].i_r2 out of sync", i);
1143  }
1144  else
1145  {
1146  if (strat->L[i].i_r1 != -1)
1147  return dReportError("L[%d].i_r1 out of sync", i);
1148  if (strat->L[i].i_r2 != -1)
1149  return dReportError("L[%d].i_r2 out of sync", i);
1150  }
1151  if (strat->L[i].i_r != -1)
1152  return dReportError("L[%d].i_r out of sync", i);
1153  }
1154  }
1155  return TRUE;
1156 }
BOOLEAN kTest(kStrategy strat)
Definition: kutil.cc:1036

◆ message()

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

Definition at line 7784 of file kutil.cc.

7785 {
7786  if (i != *olddeg)
7787  {
7788  Print("%d",i);
7789  *olddeg = i;
7790  }
7791  if (TEST_OPT_OLDSTD)
7792  {
7793  if (strat->Ll != *reduc)
7794  {
7795  if (strat->Ll != *reduc-1)
7796  Print("(%d)",strat->Ll+1);
7797  else
7798  PrintS("-");
7799  *reduc = strat->Ll;
7800  }
7801  else
7802  PrintS(".");
7803  mflush();
7804  }
7805  else
7806  {
7807  if (red_result == 0)
7808  PrintS("-");
7809  else if (red_result < 0)
7810  PrintS(".");
7811  if ((red_result > 0) || ((strat->Ll % 100)==99))
7812  {
7813  if (strat->Ll != *reduc && strat->Ll > 0)
7814  {
7815  Print("(%d)",strat->Ll+1);
7816  *reduc = strat->Ll;
7817  }
7818  }
7819  }
7820 }

◆ messageSets()

void messageSets ( kStrategy  strat)

Definition at line 7857 of file kutil.cc.

7858 {
7859  int i;
7860  if (strat->news)
7861  {
7862  PrintS("set S");
7863  for (i=0; i<=strat->sl; i++)
7864  {
7865  Print("\n %d:",i);
7866  p_wrp(strat->S[i], currRing, strat->tailRing);
7867  if (strat->fromQ!=NULL && strat->fromQ[i])
7868  Print(" (from Q)");
7869  }
7870  strat->news = FALSE;
7871  }
7872  if (strat->newt)
7873  {
7874  PrintS("\nset T");
7875  for (i=0; i<=strat->tl; i++)
7876  {
7877  Print("\n %d:",i);
7878  strat->T[i].wrp();
7879  if (strat->T[i].length==0) strat->T[i].length=pLength(strat->T[i].p);
7880  Print(" o:%ld e:%d l:%d",
7881  strat->T[i].pFDeg(),strat->T[i].ecart,strat->T[i].length);
7882  }
7883  strat->newt = FALSE;
7884  }
7885  PrintS("\nset L");
7886  for (i=strat->Ll; i>=0; i--)
7887  {
7888  Print("\n%d:",i);
7889  p_wrp(strat->L[i].p1, currRing, strat->tailRing);
7890  PrintS(" ");
7891  p_wrp(strat->L[i].p2, currRing, strat->tailRing);
7892  PrintS(" lcm: ");p_wrp(strat->L[i].lcm, currRing);
7893  PrintS("\n p : ");
7894  strat->L[i].wrp();
7895  Print(" o:%ld e:%d l:%d",
7896  strat->L[i].pFDeg(),strat->L[i].ecart,strat->L[i].length);
7897  }
7898  PrintLn();
7899 }

◆ messageStat()

void messageStat ( int  hilbcount,
kStrategy  strat 
)

Definition at line 7825 of file kutil.cc.

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

◆ messageStatSBA()

void messageStatSBA ( int  hilbcount,
kStrategy  strat 
)

Definition at line 7838 of file kutil.cc.

7839 {
7840  //PrintS("\nUsage/Allocation of temporary storage:\n");
7841  //Print("%d/%d polynomials in standard base\n",srmax,IDELEMS(Shdl));
7842  //Print("%d/%d polynomials in set L (for lazy alg.)",lrmax+1,strat->Lmax);
7843  Print("syz criterion:%d rew criterion:%d\n",strat->nrsyzcrit,strat->nrrewcrit);
7844  //Print("product criterion:%d chain criterion:%d\n",strat->cp,strat->c3);
7845  if (hilbcount!=0) Print("hilbert series criterion:%d\n",hilbcount);
7846  #ifdef HAVE_SHIFTBBA
7847  /* in usual case strat->cv is 0, it gets changed only in shift routines */
7848  if (strat->cv!=0) Print("shift V criterion:%d\n",strat->cv);
7849  #endif
7850 }
int nrsyzcrit
Definition: kutil.h:360

◆ newHEdge()

BOOLEAN newHEdge ( kStrategy  strat)

Definition at line 10735 of file kutil.cc.

10736 {
10737  if (currRing->pLexOrder || rHasMixedOrdering(currRing))
10738  return FALSE;
10739  int i,j;
10740  poly newNoether;
10741 
10742 #if 0
10743  if (currRing->weight_all_1)
10744  scComputeHC(strat->Shdl,NULL,strat->ak,strat->kNoether);
10745  else
10746  scComputeHCw(strat->Shdl,NULL,strat->ak,strat->kNoether);
10747 #else
10748  scComputeHC(strat->Shdl,NULL,strat->ak,strat->kNoether);
10749 #endif
10750  if (strat->kNoether==NULL) return FALSE;
10751  if (strat->t_kNoether != NULL)
10752  {
10753  p_LmFree(strat->t_kNoether, strat->tailRing);
10754  strat->t_kNoether=NULL;
10755  }
10756  if (strat->tailRing != currRing)
10757  strat->t_kNoether = k_LmInit_currRing_2_tailRing(strat->kNoether, strat->tailRing);
10758  /* compare old and new noether*/
10759  newNoether = pLmInit(strat->kNoether);
10760  pSetCoeff0(newNoether,nInit(1));
10761  j = p_FDeg(newNoether,currRing);
10762  for (i=1; i<=(currRing->N); i++)
10763  {
10764  if (pGetExp(newNoether, i) > 0) pDecrExp(newNoether,i);
10765  }
10766  pSetm(newNoether);
10767  if (j < HCord) /*- statistics -*/
10768  {
10769  if (TEST_OPT_PROT)
10770  {
10771  Print("H(%d)",j);
10772  mflush();
10773  }
10774  HCord=j;
10775  #ifdef KDEBUG
10776  if (TEST_OPT_DEBUG)
10777  {
10778  Print("H(%d):",j);
10779  wrp(strat->kNoether);
10780  PrintLn();
10781  }
10782  #endif
10783  }
10784  if (pCmp(strat->kNoether,newNoether)!=1)
10785  {
10786  if (strat->kNoether!=NULL) p_LmDelete0(strat->kNoether,currRing);
10787  strat->kNoether=newNoether;
10788  if (strat->t_kNoether != NULL)
10789  {
10790  p_LmFree(strat->t_kNoether, strat->tailRing);
10791  strat->t_kNoether=NULL;
10792  }
10793  if (strat->tailRing != currRing)
10794  strat->t_kNoether = k_LmInit_currRing_2_tailRing(strat->kNoether, strat->tailRing);
10795 
10796  return TRUE;
10797  }
10798  pLmDelete(newNoether);
10799  return FALSE;
10800 }
void scComputeHC(ideal S, ideal Q, int ak, poly &hEdge)
Definition: hdegree.cc:1101
VAR int HCord
Definition: kutil.cc:246
static void p_LmDelete0(poly p, const ring r)
Definition: p_polys.h:735
#define pCmp(p1, p2)
pCmp: args may be NULL returns: (p2==NULL ? 1 : (p1 == NULL ? -1 : p_LmCmp(p1, p2)))
Definition: polys.h:115
#define pLmInit(p)
like pInit, except that expvector is initialized to that of p, p must be != NULL
Definition: polys.h:64
#define pDecrExp(p, i)
Definition: polys.h:44

◆ p_HasNotCF_Lift()

static BOOLEAN p_HasNotCF_Lift ( poly  p1,
poly  p2,
const ring  r 
)
inlinestatic

p_HasNotCF for the IDLIFT case and syzComp==1: ignore component

Definition at line 2295 of file kutil.cc.

2296 {
2297  int i = rVar(r);
2298  loop
2299  {
2300  if ((p_GetExp(p1, i, r) > 0) && (p_GetExp(p2, i, r) > 0))
2301  return FALSE;
2302  i--;
2303  if (i == 0)
2304  return TRUE;
2305  }
2306 }

◆ pCopyL2p()

poly pCopyL2p ( LObject  H,
kStrategy  strat 
)

Definition at line 12002 of file kutil.cc.

12003 {
12004  /* restores a poly in currRing from LObject */
12005  LObject h = H;
12006  h.Copy();
12007  poly p;
12008  if (h.p == NULL)
12009  {
12010  if (h.t_p != NULL)
12011  {
12012  p = prMoveR(h.t_p, /* source ring: */ strat->tailRing, /* dest. ring: */ currRing);
12013  return(p);
12014  }
12015  else
12016  {
12017  /* h.tp == NULL -> the object is NULL */
12018  return(NULL);
12019  }
12020  }
12021  /* we're here if h.p != NULL */
12022  if (h.t_p == NULL)
12023  {
12024  /* then h.p is the whole poly in currRing */
12025  p = h.p;
12026  return(p);
12027  }
12028  /* we're here if h.p != NULL and h.t_p != NULL */
12029  // clean h.p, get poly from t_p
12030  pNext(h.p)=NULL;
12031  pLmDelete(&h.p);
12032  p = prMoveR(h.t_p, /* source ring: */ strat->tailRing,
12033  /* dest. ring: */ currRing);
12034  // no need to clean h: we re-used the polys
12035  return(p);
12036 }
CanonicalForm H
Definition: facAbsFact.cc:60
poly prMoveR(poly &p, ring src_r, ring dest_r)
Definition: prCopy.cc:90

◆ pDivComp()

static int pDivComp ( poly  p,
poly  q 
)
inlinestatic

Definition at line 183 of file kutil.cc.

184 {
185  if ((currRing->pCompIndex < 0)
187  {
188 #ifdef HAVE_RATGRING
189  if (rIsRatGRing(currRing))
190  {
192  q,currRing,
193  currRing->real_var_start, currRing->real_var_end))
194  return 0;
195  return pLmCmp(q,p); // ONLY FOR GLOBAL ORDER!
196  }
197 #endif
198  BOOLEAN a=FALSE, b=FALSE;
199  int i;
200  unsigned long la, lb;
201  unsigned long divmask = currRing->divmask;
202  for (i=0; i<currRing->VarL_Size; i++)
203  {
204  la = p->exp[currRing->VarL_Offset[i]];
205  lb = q->exp[currRing->VarL_Offset[i]];
206  if (la != lb)
207  {
208  if (la < lb)
209  {
210  if (b) return 0;
211  if (((la & divmask) ^ (lb & divmask)) != ((lb - la) & divmask))
212  return 0;
213  a = TRUE;
214  }
215  else
216  {
217  if (a) return 0;
218  if (((la & divmask) ^ (lb & divmask)) != ((la - lb) & divmask))
219  return 0;
220  b = TRUE;
221  }
222  }
223  }
224  if (a) { /*assume(pLmCmp(q,p)==1);*/ return 1; }
225  if (b) { /*assume(pLmCmp(q,p)==-1);*/return -1; }
226  /*assume(pLmCmp(q,p)==0);*/
227  }
228  return 0;
229 }
CanonicalForm b
Definition: cfModGcd.cc:4103

◆ pDivCompRing()

static int pDivCompRing ( poly  p,
poly  q 
)
inlinestatic

Definition at line 144 of file kutil.cc.

145 {
146  if ((currRing->pCompIndex < 0)
148  {
149  BOOLEAN a=FALSE, b=FALSE;
150  int i;
151  unsigned long la, lb;
152  unsigned long divmask = currRing->divmask;
153  for (i=0; i<currRing->VarL_Size; i++)
154  {
155  la = p->exp[currRing->VarL_Offset[i]];
156  lb = q->exp[currRing->VarL_Offset[i]];
157  if (la != lb)
158  {
159  if (la < lb)
160  {
161  if (b) return pDivComp_INCOMP;
162  if (((la & divmask) ^ (lb & divmask)) != ((lb - la) & divmask))
163  return pDivComp_INCOMP;
164  a = TRUE;
165  }
166  else
167  {
168  if (a) return pDivComp_INCOMP;
169  if (((la & divmask) ^ (lb & divmask)) != ((la - lb) & divmask))
170  return pDivComp_INCOMP;
171  b = TRUE;
172  }
173  }
174  }
175  if (a) return pDivComp_LESS;
176  if (b) return pDivComp_GREATER;
177  if (!a & !b) return pDivComp_EQUAL;
178  }
179  return pDivComp_INCOMP;
180 }
#define pDivComp_INCOMP
Definition: kutil.cc:138

◆ pLPDivComp()

static int pLPDivComp ( poly  p,
poly  q 
)
inlinestatic

Definition at line 232 of file kutil.cc.

233 {
234  if ((currRing->pCompIndex < 0) || (__p_GetComp(p,currRing) == __p_GetComp(q,currRing)))
235  {
236  // maybe there is a more performant way to do this? This will get called quite often in bba.
237  if (_p_LPLmDivisibleByNoComp(p, q, currRing)) return 1;
238  if (_p_LPLmDivisibleByNoComp(q, p, currRing)) return -1;
239  }
240 
241  return 0;
242 }
BOOLEAN _p_LPLmDivisibleByNoComp(poly a, poly b, const ring r)
Definition: shiftop.cc:796

◆ pMove2CurrTail()

poly pMove2CurrTail ( poly  p,
kStrategy  strat 
)

Definition at line 11971 of file kutil.cc.

11972 {
11973  /* assume: p is completely in currRing */
11974  /* produces an object with LM in curring
11975  and TAIL in tailring */
11976  if (pNext(p)!=NULL)
11977  {
11978  pNext(p) = prMoveR(pNext(p), /* src */ currRing, /* dest */ strat->tailRing);
11979  }
11980  return(p);
11981 }

◆ pMoveCurrTail2poly()

poly pMoveCurrTail2poly ( poly  p,
kStrategy  strat 
)

Definition at line 11985 of file kutil.cc.

11986 {
11987  /* assume: p has LM in curring and TAIL in tailring */
11988  /* convert it to complete currRing */
11989 
11990  /* check that LM is in currRing */
11992 
11993  if (pNext(p)!=NULL)
11994  {
11995  pNext(p) = prMoveR(pNext(p), /* src */ strat->tailRing, /* dest */currRing);
11996  }
11997  return(p);
11998 }

◆ posInIdealMonFirst()

int posInIdealMonFirst ( const ideal  F,
const poly  p,
int  start,
int  end 
)

Definition at line 4941 of file kutil.cc.

4942 {
4943  if(end < 0 || end >= IDELEMS(F))
4944  end = IDELEMS(F);
4945  if (end<0) return 0;
4946  if(pNext(p) == NULL) return start;
4947  polyset set=F->m;
4948  int o = p_Deg(p,currRing);
4949  int op;
4950  int i;
4951  int an = start;
4952  for(i=start;i<end;i++)
4953  if(set[i] != NULL && pNext(set[i]) == NULL)
4954  an++;
4955  if(an == end-1)
4956  return end;
4957  int en= end;
4958  loop
4959  {
4960  if(an>=en)
4961  return en;
4962  if (an == en-1)
4963  {
4964  op = p_Deg(set[an],currRing);
4965  if ((op < o)
4966  || ((op == o) && (pLtCmp(set[an],p) == -1)))
4967  return en;
4968  return an;
4969  }
4970  i=(an+en) / 2;
4971  op = p_Deg(set[i],currRing);
4972  if ((op < o)
4973  || ((op == o) && (pLtCmp(set[i],p) == -1)))
4974  an=i;
4975  else
4976  en=i;
4977  }
4978 }
poly * polyset
Definition: polys.h:259

◆ posInL0()

int posInL0 ( const LSet  set,
const int  length,
LObject p,
const  kStrategy 
)

Definition at line 5797 of file kutil.cc.

5799 {
5800  if (length<0) return 0;
5801 
5802  int cmp_int=currRing->OrdSgn;
5803 
5804  if (pLmCmp(set[length].p,p->p)== cmp_int)
5805  return length+1;
5806 
5807  int i;
5808  int an = 0;
5809  int en= length;
5810  loop
5811  {
5812  if (an >= en-1)
5813  {
5814  if (pLmCmp(set[an].p,p->p) == cmp_int) return en;
5815  return an;
5816  }
5817  i=(an+en) / 2;
5818  if (pLmCmp(set[i].p,p->p) == cmp_int) an=i;
5819  else en=i;
5820  /*aend. fuer lazy == in !=- machen */
5821  }
5822 }

◆ posInL0Ring()

int posInL0Ring ( const LSet  set,
const int  length,
LObject p,
const  kStrategy 
)

Definition at line 5825 of file kutil.cc.

5827 {
5828  if (length<0) return 0;
5829 
5830  if (pLtCmpOrdSgnEqP(set[length].p,p->p))
5831  return length+1;
5832 
5833  int i;
5834  int an = 0;
5835  int en= length;
5836  loop
5837  {
5838  if (an >= en-1)
5839  {
5840  if (pLtCmpOrdSgnEqP(set[an].p,p->p)) return en;
5841  return an;
5842  }
5843  i=(an+en) / 2;
5844  if (pLtCmpOrdSgnEqP(set[i].p,p->p)) an=i;
5845  else en=i;
5846  /*aend. fuer lazy == in !=- machen */
5847  }
5848 }
#define pLtCmpOrdSgnEqP(p, q)
Definition: polys.h:128

◆ posInL11()

int posInL11 ( const LSet  set,
const int  length,
LObject p,
const  kStrategy 
)

Definition at line 6059 of file kutil.cc.

6061 {
6062  if (length<0) return 0;
6063 
6064  int o = p->GetpFDeg();
6065  int op = set[length].GetpFDeg();
6066  int cmp_int= -currRing->OrdSgn;
6067 
6068  if ((op > o)
6069  || ((op == o) && (pLmCmp(set[length].p,p->p) != cmp_int)))
6070  return length+1;
6071  int i;
6072  int an = 0;
6073  int en= length;
6074  loop
6075  {
6076  if (an >= en-1)
6077  {
6078  op = set[an].GetpFDeg();
6079  if ((op > o)
6080  || ((op == o) && (pLmCmp(set[an].p,p->p) != cmp_int)))
6081  return en;
6082  return an;
6083  }
6084  i=(an+en) / 2;
6085  op = set[i].GetpFDeg();
6086  if ((op > o)
6087  || ((op == o) && (pLmCmp(set[i].p,p->p) != cmp_int)))
6088  an=i;
6089  else
6090  en=i;
6091  }
6092 }

◆ posInL110()

int posInL110 ( const LSet  set,
const int  length,
LObject p,
const  kStrategy 
)

Definition at line 6358 of file kutil.cc.

6360 {
6361  if (length<0) return 0;
6362 
6363  int o = p->GetpFDeg();
6364  int op = set[length].GetpFDeg();
6365  int cmp_int= -currRing->OrdSgn;
6366 
6367  if ((op > o)
6368  || ((op == o) && (set[length].length >p->length))
6369  || ((op == o) && (set[length].length <= p->length)
6370  && (pLmCmp(set[length].p,p->p) != cmp_int)))
6371  return length+1;
6372  int i;
6373  int an = 0;
6374  int en= length;
6375  loop
6376  {
6377  if (an >= en-1)
6378  {
6379  op = set[an].GetpFDeg();
6380  if ((op > o)
6381  || ((op == o) && (set[an].length >p->length))
6382  || ((op == o) && (set[an].length <=p->length)
6383  && (pLmCmp(set[an].p,p->p) != cmp_int)))
6384  return en;
6385  return an;
6386  }
6387  i=(an+en) / 2;
6388  op = set[i].GetpFDeg();
6389  if ((op > o)
6390  || ((op == o) && (set[i].length > p->length))
6391  || ((op == o) && (set[i].length <= p->length)
6392  && (pLmCmp(set[i].p,p->p) != cmp_int)))
6393  an=i;
6394  else
6395  en=i;
6396  }
6397 }

◆ posInL110Ring()

int posInL110Ring ( const LSet  set,
const int  length,
LObject p,
const  kStrategy 
)

Definition at line 6400 of file kutil.cc.

6402 {
6403  if (length<0) return 0;
6404 
6405  int o = p->GetpFDeg();
6406  int op = set[length].GetpFDeg();
6407 
6408  if ((op > o)
6409  || ((op == o) && (set[length].length >p->length))
6410  || ((op == o) && (set[length].length <= p->length)
6411  && (pLtCmpOrdSgnDiffM(set[length].p,p->p))))
6412  return length+1;
6413  int i;
6414  int an = 0;
6415  int en= length;
6416  loop
6417  {
6418  if (an >= en-1)
6419  {
6420  op = set[an].GetpFDeg();
6421  if ((op > o)
6422  || ((op == o) && (set[an].length >p->length))
6423  || ((op == o) && (set[an].length <=p->length)
6424  && (pLtCmpOrdSgnDiffM(set[an].p,p->p))))
6425  return en;
6426  return an;
6427  }
6428  i=(an+en) / 2;
6429  op = set[i].GetpFDeg();
6430  if ((op > o)
6431  || ((op == o) && (set[i].length > p->length))
6432  || ((op == o) && (set[i].length <= p->length)
6433  && (pLtCmpOrdSgnDiffM(set[i].p,p->p))))
6434  an=i;
6435  else
6436  en=i;
6437  }
6438 }
#define pLtCmpOrdSgnDiffM(p, q)
Definition: polys.h:125

◆ posInL11Ring()

int posInL11Ring ( const LSet  set,
const int  length,
LObject p,
const  kStrategy 
)

Definition at line 6102 of file kutil.cc.

6104 {
6105  if (length<0) return 0;
6106 
6107  int o = p->GetpFDeg();
6108  int op = set[length].GetpFDeg();
6109 
6110  if ((op > o)
6111  || ((op == o) && (pLtCmpOrdSgnDiffM(set[length].p,p->p))))
6112  return length+1;
6113  int i;
6114  int an = 0;
6115  int en= length;
6116  loop
6117  {
6118  if (an >= en-1)
6119  {
6120  op = set[an].GetpFDeg();
6121  if ((op > o)
6122  || ((op == o) && (pLtCmpOrdSgnDiffM(set[an].p,p->p))))
6123  return en;
6124  return an;
6125  }
6126  i=(an+en) / 2;
6127  op = set[i].GetpFDeg();
6128  if ((op > o)
6129  || ((op == o) && (pLtCmpOrdSgnDiffM(set[i].p,p->p))))
6130  an=i;
6131  else
6132  en=i;
6133  }
6134 }

◆ posInL11Ringls()

int posInL11Ringls ( const LSet  set,
const int  length,
LObject p,
const  kStrategy 
)

Definition at line 6172 of file kutil.cc.

6174 {
6175  if (length < 0) return 0;
6176  int an,en,i;
6177  an = 0;
6178  en = length+1;
6179  loop
6180  {
6181  if (an >= en-1)
6182  {
6183  if(an == en)
6184  return en;
6185  if (set[an].FDeg > p->FDeg)
6186  return en;
6187  if (set[an].FDeg < p->FDeg)
6188  return an;
6189  if (set[an].FDeg == p->FDeg)
6190  {
6191  number lcset,lcp;
6192  lcset = pGetCoeff(set[an].p);
6193  lcp = pGetCoeff(p->p);
6194  if(!nGreaterZero(lcset))
6195  {
6196  set[an].p=p_Neg(set[an].p,currRing);
6197  if (set[an].t_p!=NULL)
6198  pSetCoeff0(set[an].t_p,pGetCoeff(set[an].p));
6199  lcset=pGetCoeff(set[an].p);
6200  }
6201  if(!nGreaterZero(lcp))
6202  {
6203  p->p=p_Neg(p->p,currRing);
6204  if (p->t_p!=NULL)
6205  pSetCoeff0(p->t_p,pGetCoeff(p->p));
6206  lcp=pGetCoeff(p->p);
6207  }
6208  if(nGreater(lcset, lcp))
6209  {
6210  return en;
6211  }
6212  else
6213  {
6214  return an;
6215  }
6216  }
6217  }
6218  i=(an+en) / 2;
6219  if (set[i].FDeg > p->FDeg)
6220  an=i;
6221  if (set[i].FDeg < p->FDeg)
6222  en=i;
6223  if (set[i].FDeg == p->FDeg)
6224  {
6225  number lcset,lcp;
6226  lcset = pGetCoeff(set[i].p);
6227  lcp = pGetCoeff(p->p);
6228  if(!nGreaterZero(lcset))
6229  {
6230  set[i].p=p_Neg(set[i].p,currRing);
6231  if (set[i].t_p!=NULL)
6232  pSetCoeff0(set[i].t_p,pGetCoeff(set[i].p));
6233  lcset=pGetCoeff(set[i].p);
6234  }
6235  if(!nGreaterZero(lcp))
6236  {
6237  p->p=p_Neg(p->p,currRing);
6238  if (p->t_p!=NULL)
6239  pSetCoeff0(p->t_p,pGetCoeff(p->p));
6240  lcp=pGetCoeff(p->p);
6241  }
6242  if(nGreater(lcset, lcp))
6243  {
6244  an = i;
6245  }
6246  else
6247  {
6248  en = i;
6249  }
6250  }
6251  }
6252 }
#define nGreater(a, b)
Definition: numbers.h:28

◆ posInL13()

int posInL13 ( const LSet  set,
const int  length,
LObject p,
const  kStrategy 
)

Definition at line 6447 of file kutil.cc.

6449 {
6450  if (length<0) return 0;
6451 
6452  int o = p->GetpFDeg();
6453 
6454  if (set[length].GetpFDeg() > o)
6455  return length+1;
6456 
6457  int i;
6458  int an = 0;
6459  int en= length;
6460  loop
6461  {
6462  if (an >= en-1)
6463  {
6464  if (set[an].GetpFDeg() >= o)
6465  return en;
6466  return an;
6467  }
6468  i=(an+en) / 2;
6469  if (set[i].GetpFDeg() >= o)
6470  an=i;
6471  else
6472  en=i;
6473  }
6474 }

◆ posInL15()

int posInL15 ( const LSet  set,
const int  length,
LObject p,
const  kStrategy 
)

Definition at line 6482 of file kutil.cc.

6484 {
6485  if (length<0) return 0;
6486 
6487  int o = p->GetpFDeg() + p->ecart;
6488  int op = set[length].GetpFDeg() + set[length].ecart;
6489  int cmp_int= -currRing->OrdSgn;
6490 
6491  if ((op > o)
6492  || ((op == o) && (pLmCmp(set[length].p,p->p) != cmp_int)))
6493  return length+1;
6494  int i;
6495  int an = 0;
6496  int en= length;
6497  loop
6498  {
6499  if (an >= en-1)
6500  {
6501  op = set[an].GetpFDeg() + set[an].ecart;
6502  if ((op > o)
6503  || ((op == o) && (pLmCmp(set[an].p,p->p) != cmp_int)))
6504  return en;
6505  return an;
6506  }
6507  i=(an+en) / 2;
6508  op = set[i].GetpFDeg() + set[i].ecart;
6509  if ((op > o)
6510  || ((op == o) && (pLmCmp(set[i].p,p->p) != cmp_int)))
6511  an=i;
6512  else
6513  en=i;
6514  }
6515 }

◆ posInL15Ring()

int posInL15Ring ( const LSet  set,
const int  length,
LObject p,
const  kStrategy 
)

Definition at line 6518 of file kutil.cc.

6520 {
6521  if (length<0) return 0;
6522 
6523  int o = p->GetpFDeg() + p->ecart;
6524  int op = set[length].GetpFDeg() + set[length].ecart;
6525 
6526  if ((op > o)
6527  || ((op == o) && (pLtCmpOrdSgnDiffM(set[length].p,p->p))))
6528  return length+1;
6529  int i;
6530  int an = 0;
6531  int en= length;
6532  loop
6533  {
6534  if (an >= en-1)
6535  {
6536  op = set[an].GetpFDeg() + set[an].ecart;
6537  if ((op > o)
6538  || ((op == o) && (pLtCmpOrdSgnDiffM(set[an].p,p->p))))
6539  return en;
6540  return an;
6541  }
6542  i=(an+en) / 2;
6543  op = set[i].GetpFDeg() + set[i].ecart;
6544  if ((op > o)
6545  || ((op == o) && (pLtCmpOrdSgnDiffM(set[i].p,p->p))))
6546  an=i;
6547  else
6548  en=i;
6549  }
6550 }

◆ posInL17()

int posInL17 ( const LSet  set,
const int  length,
LObject p,
const  kStrategy 
)

Definition at line 6559 of file kutil.cc.

6561 {
6562  if (length<0) return 0;
6563 
6564  int o = p->GetpFDeg() + p->ecart;
6565  int cmp_int= -currRing->OrdSgn;
6566 
6567  if ((set[length].GetpFDeg() + set[length].ecart > o)
6568  || ((set[length].GetpFDeg() + set[length].ecart == o)
6569  && (set[length].ecart > p->ecart))
6570  || ((set[length].GetpFDeg() + set[length].ecart == o)
6571  && (set[length].ecart == p->ecart)
6572  && (pLmCmp(set[length].p,p->p) != cmp_int)))
6573  return length+1;
6574  int i;
6575  int an = 0;
6576  int en= length;
6577  loop
6578  {
6579  if (an >= en-1)
6580  {
6581  if ((set[an].GetpFDeg() + set[an].ecart > o)
6582  || ((set[an].GetpFDeg() + set[an].ecart == o)
6583  && (set[an].ecart > p->ecart))
6584  || ((set[an].GetpFDeg() + set[an].ecart == o)
6585  && (set[an].ecart == p->ecart)
6586  && (pLmCmp(set[an].p,p->p) != cmp_int)))
6587  return en;
6588  return an;
6589  }
6590  i=(an+en) / 2;
6591  if ((set[i].GetpFDeg() + set[i].ecart > o)
6592  || ((set[i].GetpFDeg() + set[i].ecart == o)
6593  && (set[i].ecart > p->ecart))
6594  || ((set[i].GetpFDeg() +set[i].ecart == o)
6595  && (set[i].ecart == p->ecart)
6596  && (pLmCmp(set[i].p,p->p) != cmp_int)))
6597  an=i;
6598  else
6599  en=i;
6600  }
6601 }

◆ posInL17_c()

int posInL17_c ( const LSet  set,
const int  length,
LObject p,
const  kStrategy 
)

Definition at line 6654 of file kutil.cc.

6656 {
6657  if (length<0) return 0;
6658 
6659  int cc = (-1+2*currRing->order[0]==ringorder_c);
6660  /* cc==1 for (c,..), cc==-1 for (C,..) */
6661  long c = pGetComp(p->p)*cc;
6662  int o = p->GetpFDeg() + p->ecart;
6663  int cmp_int= -currRing->OrdSgn;
6664 
6665  if (pGetComp(set[length].p)*cc > c)
6666  return length+1;
6667  if (pGetComp(set[length].p)*cc == c)
6668  {
6669  if ((set[length].GetpFDeg() + set[length].ecart > o)
6670  || ((set[length].GetpFDeg() + set[length].ecart == o)
6671  && (set[length].ecart > p->ecart))
6672  || ((set[length].GetpFDeg() + set[length].ecart == o)
6673  && (set[length].ecart == p->ecart)
6674  && (pLmCmp(set[length].p,p->p) != cmp_int)))
6675  return length+1;
6676  }
6677  int i;
6678  int an = 0;
6679  int en= length;
6680  loop
6681  {
6682  if (an >= en-1)
6683  {
6684  if (pGetComp(set[an].p)*cc > c)
6685  return en;
6686  if (pGetComp(set[an].p)*cc == c)
6687  {
6688  if ((set[an].GetpFDeg() + set[an].ecart > o)
6689  || ((set[an].GetpFDeg() + set[an].ecart == o)
6690  && (set[an].ecart > p->ecart))
6691  || ((set[an].GetpFDeg() + set[an].ecart == o)
6692  && (set[an].ecart == p->ecart)
6693  && (pLmCmp(set[an].p,p->p) != cmp_int)))
6694  return en;
6695  }
6696  return an;
6697  }
6698  i=(an+en) / 2;
6699  if (pGetComp(set[i].p)*cc > c)
6700  an=i;
6701  else if (pGetComp(set[i].p)*cc == c)
6702  {
6703  if ((set[i].GetpFDeg() + set[i].ecart > o)
6704  || ((set[i].GetpFDeg() + set[i].ecart == o)
6705  && (set[i].ecart > p->ecart))
6706  || ((set[i].GetpFDeg() +set[i].ecart == o)
6707  && (set[i].ecart == p->ecart)
6708  && (pLmCmp(set[i].p,p->p) != cmp_int)))
6709  an=i;
6710  else
6711  en=i;
6712  }
6713  else
6714  en=i;
6715  }
6716 }

◆ posInL17_cRing()

int posInL17_cRing ( const LSet  set,
const int  length,
LObject p,
const  kStrategy 
)

Definition at line 6719 of file kutil.cc.

6721 {
6722  if (length<0) return 0;
6723 
6724  int cc = (-1+2*currRing->order[0]==ringorder_c);
6725  /* cc==1 for (c,..), cc==-1 for (C,..) */
6726  unsigned long c = pGetComp(p->p)*cc;
6727  int o = p->GetpFDeg() + p->ecart;
6728 
6729  if (pGetComp(set[length].p)*cc > c)
6730  return length+1;
6731  if (pGetComp(set[length].p)*cc == c)
6732  {
6733  if ((set[length].GetpFDeg() + set[length].ecart > o)
6734  || ((set[length].GetpFDeg() + set[length].ecart == o)
6735  && (set[length].ecart > p->ecart))
6736  || ((set[length].GetpFDeg() + set[length].ecart == o)
6737  && (set[length].ecart == p->ecart)
6738  && (pLtCmpOrdSgnDiffM(set[length].p,p->p))))
6739  return length+1;
6740  }
6741  int i;
6742  int an = 0;
6743  int en= length;
6744  loop
6745  {
6746  if (an >= en-1)
6747  {
6748  if (pGetComp(set[an].p)*cc > c)
6749  return en;
6750  if (pGetComp(set[an].p)*cc == c)
6751  {
6752  if ((set[an].GetpFDeg() + set[an].ecart > o)
6753  || ((set[an].GetpFDeg() + set[an].ecart == o)
6754  && (set[an].ecart > p->ecart))
6755  || ((set[an].GetpFDeg() + set[an].ecart == o)
6756  && (set[an].ecart == p->ecart)
6757  && (pLtCmpOrdSgnDiffM(set[an].p,p->p))))
6758  return en;
6759  }
6760  return an;
6761  }
6762  i=(an+en) / 2;
6763  if (pGetComp(set[i].p)*cc > c)
6764  an=i;
6765  else if (pGetComp(set[i].p)*cc == c)
6766  {
6767  if ((set[i].GetpFDeg() + set[i].ecart > o)
6768  || ((set[i].GetpFDeg() + set[i].ecart == o)
6769  && (set[i].ecart > p->ecart))
6770  || ((set[i].GetpFDeg() +set[i].ecart == o)
6771  && (set[i].ecart == p->ecart)
6772  && (pLtCmpOrdSgnDiffM(set[i].p,p->p))))
6773  an=i;
6774  else
6775  en=i;
6776  }
6777  else
6778  en=i;
6779  }
6780 }

◆ posInL17Ring()

int posInL17Ring ( const LSet  set,
const int  length,
LObject p,
const  kStrategy 
)

Definition at line 6604 of file kutil.cc.

6606 {
6607  if (length<0) return 0;
6608 
6609  int o = p->GetpFDeg() + p->ecart;
6610 
6611  if ((set[length].GetpFDeg() + set[length].ecart > o)
6612  || ((set[length].GetpFDeg() + set[length].ecart == o)
6613  && (set[length].ecart > p->ecart))
6614  || ((set[length].GetpFDeg() + set[length].ecart == o)
6615  && (set[length].ecart == p->ecart)
6616  && (pLtCmpOrdSgnDiffM(set[length].p,p->p))))
6617  return length+1;
6618  int i;
6619  int an = 0;
6620  int en= length;
6621  loop
6622  {
6623  if (an >= en-1)
6624  {
6625  if ((set[an].GetpFDeg() + set[an].ecart > o)
6626  || ((set[an].GetpFDeg() + set[an].ecart == o)
6627  && (set[an].ecart > p->ecart))
6628  || ((set[an].GetpFDeg() + set[an].ecart == o)
6629  && (set[an].ecart == p->ecart)
6630  && (pLtCmpOrdSgnDiffM(set[an].p,p->p))))
6631  return en;
6632  return an;
6633  }
6634  i=(an+en) / 2;
6635  if ((set[i].GetpFDeg() + set[i].ecart > o)
6636  || ((set[i].GetpFDeg() + set[i].ecart == o)
6637  && (set[i].ecart > p->ecart))
6638  || ((set[i].GetpFDeg() +set[i].ecart == o)
6639  && (set[i].ecart == p->ecart)
6640  && (pLtCmpOrdSgnDiffM(set[i].p,p->p))))
6641  an=i;
6642  else
6643  en=i;
6644  }
6645 }

◆ posInLF5C()

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

Definition at line 6047 of file kutil.cc.

6049 {
6050  return strat->Ll+1;
6051 }

◆ posInLF5CRing()

int posInLF5CRing ( const LSet  set,
int  start,
const int  length,
LObject p,
const  kStrategy 
)

Definition at line 6136 of file kutil.cc.

6138 {
6139  if (length<0) return 0;
6140  if(start == (length +1)) return (length+1);
6141  int o = p->GetpFDeg();
6142  int op = set[length].GetpFDeg();
6143 
6144  if ((op > o)
6145  || ((op == o) && (pLtCmpOrdSgnDiffM(set[length].p,p->p))))
6146  return length+1;
6147  int i;
6148  int an = start;
6149  int en= length;
6150  loop
6151  {
6152  if (an >= en-1)
6153  {
6154  op = set[an].GetpFDeg();
6155  if ((op > o)
6156  || ((op == o) && (pLtCmpOrdSgnDiffM(set[an].p,p->p))))
6157  return en;
6158  return an;
6159  }
6160  i=(an+en) / 2;
6161  op = set[i].GetpFDeg();
6162  if ((op > o)
6163  || ((op == o) && (pLtCmpOrdSgnDiffM(set[i].p,p->p))))
6164  an=i;
6165  else
6166  en=i;
6167  }
6168 }

◆ posInLrg0()

int posInLrg0 ( const LSet  set,
const int  length,
LObject p,
const  kStrategy 
)

Definition at line 6274 of file kutil.cc.

6284 {
6285  if (length < 0) return 0;
6286 
6287  int o = p->GetpFDeg();
6288  int op = set[length].GetpFDeg();
6289 
6290  if ((op > o) || ((op == o) && (pLmCmp(set[length].p,p->p) != -currRing->OrdSgn)))
6291  return length + 1;
6292  int i;
6293  int an = 0;
6294  int en = length;
6295  loop
6296  {
6297  if (an >= en - 1)
6298  {
6299  op = set[an].GetpFDeg();
6300  if ((op > o) || ((op == o) && (pLmCmp(set[an].p,p->p) != -currRing->OrdSgn)))
6301  return en;
6302  return an;
6303  }
6304  i = (an+en) / 2;
6305  op = set[i].GetpFDeg();
6306  if ((op > o) || ((op == o) && (pLmCmp(set[i].p,p->p) != -currRing->OrdSgn)))
6307  an = i;
6308  else
6309  en = i;
6310  }
6311 }

◆ posInLRing()

int posInLRing ( const LSet  set,
const int  length,
LObject p,
const  kStrategy 
)

Definition at line 5945 of file kutil.cc.

5947 {
5948  if (length < 0) return 0;
5949  if (set[length].FDeg > p->FDeg)
5950  return length+1;
5951  if (set[length].FDeg == p->FDeg)
5952  if(set[length].GetpLength() > p->GetpLength())
5953  return length+1;
5954  int i;
5955  int an = 0;
5956  int en= length+1;
5957  loop
5958  {
5959  if (an >= en-1)
5960  {
5961  if(an == en)
5962  return en;
5963  if (set[an].FDeg > p->FDeg)
5964  return en;
5965  if(set[an].FDeg == p->FDeg)
5966  {
5967  if(set[an].GetpLength() > p->GetpLength())
5968  return en;
5969  else
5970  {
5971  if(set[an].GetpLength() == p->GetpLength())
5972  {
5973  if(nGreater(set[an].p->coef, p->p->coef))
5974  return en;
5975  else
5976  return an;
5977  }
5978  else
5979  {
5980  return an;
5981  }
5982  }
5983  }
5984  else
5985  return an;
5986  }
5987  i=(an+en) / 2;
5988  if (set[i].FDeg > p->FDeg)
5989  an=i;
5990  else
5991  {
5992  if(set[i].FDeg == p->FDeg)
5993  {
5994  if(set[i].GetpLength() > p->GetpLength())
5995  an=i;
5996  else
5997  {
5998  if(set[i].GetpLength() == p->GetpLength())
5999  {
6000  if(nGreater(set[i].p->coef, p->p->coef))
6001  an = i;
6002  else
6003  en = i;
6004  }
6005  else
6006  {
6007  en=i;
6008  }
6009  }
6010  }
6011  else
6012  en=i;
6013  }
6014  }
6015 }

◆ posInLSig()

int posInLSig ( const LSet  set,
const int  length,
LObject p,
const  kStrategy 
)

Definition at line 5857 of file kutil.cc.

5859 {
5860  if (length<0) return 0;
5861  int cmp_int=currRing->OrdSgn;
5862  if (pLtCmp(set[length].sig,p->sig)==cmp_int)
5863  return length+1;
5864 
5865  int i;
5866  int an = 0;
5867  int en= length;
5868  loop
5869  {
5870  if (an >= en-1)
5871  {
5872  if (pLtCmp(set[an].sig,p->sig) == cmp_int) return en;
5873  return an;
5874  }
5875  i=(an+en) / 2;
5876  if (pLtCmp(set[i].sig,p->sig) == cmp_int) an=i;
5877  else en=i;
5878  /*aend. fuer lazy == in !=- machen */
5879  }
5880 }

◆ posInLSigRing()

int posInLSigRing ( const LSet  set,
const int  length,
LObject p,
const  kStrategy 
)

Definition at line 5882 of file kutil.cc.

5884 {
5885  assume(currRing->OrdSgn == 1 && rField_is_Ring(currRing));
5886  if (length<0) return 0;
5887  if (pLtCmp(set[length].sig,p->sig)== 1)
5888  return length+1;
5889 
5890  int an,en,i;
5891  an = 0;
5892  en = length+1;
5893  int cmp;
5894  loop
5895  {
5896  if (an >= en-1)
5897  {
5898  if(an == en)
5899  return en;
5900  cmp = pLtCmp(set[an].sig,p->sig);
5901  if (cmp == 1)
5902  return en;
5903  if (cmp == -1)
5904  return an;
5905  if (cmp == 0)
5906  {
5907  if (set[an].FDeg > p->FDeg)
5908  return en;
5909  if (set[an].FDeg < p->FDeg)
5910  return an;
5911  if (set[an].FDeg == p->FDeg)
5912  {
5913  cmp = pLtCmp(set[an].p,p->p);
5914  if(cmp == 1)
5915  return en;
5916  else
5917  return an;
5918  }
5919  }
5920  }
5921  i=(an+en) / 2;
5922  cmp = pLtCmp(set[i].sig,p->sig);
5923  if (cmp == 1)
5924  an = i;
5925  if (cmp == -1)
5926  en = i;
5927  if (cmp == 0)
5928  {
5929  if (set[i].FDeg > p->FDeg)
5930  an = i;
5931  if (set[i].FDeg < p->FDeg)
5932  en = i;
5933  if (set[i].FDeg == p->FDeg)
5934  {
5935  cmp = pLtCmp(set[i].p,p->p);
5936  if(cmp == 1)
5937  an = i;
5938  else
5939  en = i;
5940  }
5941  }
5942  }
5943 }

◆ posInLSpecial()

int posInLSpecial ( const LSet  set,
const int  length,
LObject p,
const  kStrategy 
)

Definition at line 5753 of file kutil.cc.

5755 {
5756  if (length<0) return 0;
5757 
5758  int d=p->GetpFDeg();
5759  int op=set[length].GetpFDeg();
5760  int cmp_int=currRing->OrdSgn;
5761 
5762  if ((op > d)
5763  || ((op == d) && (p->p1!=NULL)&&(set[length].p1==NULL))
5764  || (pLmCmp(set[length].p,p->p)== cmp_int))
5765  return length+1;
5766 
5767  int i;
5768  int an = 0;
5769  int en= length;
5770  loop
5771  {
5772  if (an >= en-1)
5773  {
5774  op=set[an].GetpFDeg();
5775  if ((op > d)
5776  || ((op == d) && (p->p1!=NULL) && (set[an].p1==NULL))
5777  || (pLmCmp(set[an].p,p->p)== cmp_int))
5778  return en;
5779  return an;
5780  }
5781  i=(an+en) / 2;
5782  op=set[i].GetpFDeg();
5783  if ((op>d)
5784  || ((op==d) && (p->p1!=NULL) && (set[i].p1==NULL))
5785  || (pLmCmp(set[i].p,p->p) == cmp_int))
5786  an=i;
5787  else
5788  en=i;
5789  }
5790 }

◆ posInS()

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

Definition at line 4763 of file kutil.cc.

4765 {
4766  if(length==-1) return 0;
4767  polyset set=strat->S;
4768  int i;
4769  int an = 0;
4770  int en = length;
4771  int cmp_int = currRing->OrdSgn;
4773 #ifdef HAVE_PLURAL
4774  && (currRing->real_var_start==0)
4775 #endif
4776 #if 0
4777  || ((strat->ak>0) && ((currRing->order[0]==ringorder_c)||((currRing->order[0]==ringorder_C))))
4778 #endif
4779  )
4780  {
4781  int o=p_Deg(p,currRing);
4782  int oo=p_Deg(set[length],currRing);
4783 
4784  if ((oo<o)
4785  || ((o==oo) && (pLmCmp(set[length],p)!= cmp_int)))
4786  return length+1;
4787 
4788  loop
4789  {
4790  if (an >= en-1)
4791  {
4792  if ((p_Deg(set[an],currRing)>=o) && (pLmCmp(set[an],p) == cmp_int))
4793  {
4794  return an;
4795  }
4796  return en;
4797  }
4798  i=(an+en) / 2;
4799  if ((p_Deg(set[i],currRing)>=o) && (pLmCmp(set[i],p) == cmp_int)) en=i;
4800  else an=i;
4801  }
4802  }
4803  else
4804  {
4805  if (rField_is_Ring(currRing))
4806  {
4807  if (pLmCmp(set[length],p)== -cmp_int)
4808  return length+1;
4809  int cmp;
4810  loop
4811  {
4812  if (an >= en-1)
4813  {
4814  cmp = pLmCmp(set[an],p);
4815  if (cmp == cmp_int) return an;
4816  if (cmp == -cmp_int) return en;
4817  if (n_DivBy(pGetCoeff(p), pGetCoeff(set[an]), currRing->cf)) return en;
4818  return an;
4819  }
4820  i = (an+en) / 2;
4821  cmp = pLmCmp(set[i],p);
4822  if (cmp == cmp_int) en = i;
4823  else if (cmp == -cmp_int) an = i;
4824  else
4825  {
4826  if (n_DivBy(pGetCoeff(p), pGetCoeff(set[i]), currRing->cf)) an = i;
4827  else en = i;
4828  }
4829  }
4830  }
4831  else
4832  if (pLmCmp(set[length],p)== -cmp_int)
4833  return length+1;
4834 
4835  loop
4836  {
4837  if (an >= en-1)
4838  {
4839  if (pLmCmp(set[an],p) == cmp_int) return an;
4840  if (pLmCmp(set[an],p) == -cmp_int) return en;
4841  if ((cmp_int!=1)
4842  && ((strat->ecartS[an])>ecart_p))
4843  return an;
4844  return en;
4845  }
4846  i=(an+en) / 2;
4847  if (pLmCmp(set[i],p) == cmp_int) en=i;
4848  else if (pLmCmp(set[i],p) == -cmp_int) an=i;
4849  else
4850  {
4851  if ((cmp_int!=1)
4852  &&((strat->ecartS[i])<ecart_p))
4853  en=i;
4854  else
4855  an=i;
4856  }
4857  }
4858  }
4859 }

◆ posInSMonFirst()

int posInSMonFirst ( const kStrategy  strat,
const int  length,
const poly  p 
)

Definition at line 4864 of file kutil.cc.

4865 {
4866  if (length<0) return 0;
4867  polyset set=strat->S;
4868  if(pNext(p) == NULL)
4869  {
4870  int mon = 0;
4871  for(int i = 0;i<=length;i++)
4872  {
4873  if(set[i] != NULL && pNext(set[i]) == NULL)
4874  mon++;
4875  }
4876  int o = p_Deg(p,currRing);
4877  int op = p_Deg(set[mon],currRing);
4878 
4879  if ((op < o)
4880  || ((op == o) && (pLtCmp(set[mon],p) == -1)))
4881  return length+1;
4882  int i;
4883  int an = 0;
4884  int en= mon;
4885  loop
4886  {
4887  if (an >= en-1)
4888  {
4889  op = p_Deg(set[an],currRing);
4890  if ((op < o)
4891  || ((op == o) && (pLtCmp(set[an],p) == -1)))
4892  return en;
4893  return an;
4894  }
4895  i=(an+en) / 2;
4896  op = p_Deg(set[i],currRing);
4897  if ((op < o)
4898  || ((op == o) && (pLtCmp(set[i],p) == -1)))
4899  an=i;
4900  else
4901  en=i;
4902  }
4903  }
4904  else /*if(pNext(p) != NULL)*/
4905  {
4906  int o = p_Deg(p,currRing);
4907  int op = p_Deg(set[length],currRing);
4908 
4909  if ((op < o)
4910  || ((op == o) && (pLtCmp(set[length],p) == -1)))
4911  return length+1;
4912  int i;
4913  int an = 0;
4914  for(i=0;i<=length;i++)
4915  if(set[i] != NULL && pNext(set[i]) == NULL)
4916  an++;
4917  int en= length;
4918  loop
4919  {
4920  if (an >= en-1)
4921  {
4922  op = p_Deg(set[an],currRing);
4923  if ((op < o)
4924  || ((op == o) && (pLtCmp(set[an],p) == -1)))
4925  return en;
4926  return an;
4927  }
4928  i=(an+en) / 2;
4929  op = p_Deg(set[i],currRing);
4930  if ((op < o)
4931  || ((op == o) && (pLtCmp(set[i],p) == -1)))
4932  an=i;
4933  else
4934  en=i;
4935  }
4936  }
4937 }

◆ posInSyz()

int posInSyz ( const kStrategy  strat,
poly  sig 
)

Definition at line 6018 of file kutil.cc.

6019 {
6020  if (strat->syzl==0) return 0;
6021  int cmp_int=currRing->OrdSgn;
6022  if (pLtCmp(strat->syz[strat->syzl-1],sig) != cmp_int)
6023  return strat->syzl;
6024  int i;
6025  int an = 0;
6026  int en= strat->syzl-1;
6027  loop
6028  {
6029  if (an >= en-1)
6030  {
6031  if (pLtCmp(strat->syz[an],sig) != cmp_int) return en;
6032  return an;
6033  }
6034  i=(an+en) / 2;
6035  if (pLtCmp(strat->syz[i],sig) != cmp_int) an=i;
6036  else en=i;
6037  /*aend. fuer lazy == in !=- machen */
6038  }
6039 }

◆ posInT0()

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

Definition at line 4985 of file kutil.cc.

4986 {
4987  return (length+1);
4988 }

◆ posInT1()

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

Definition at line 4996 of file kutil.cc.

4997 {
4998  if (length==-1) return 0;
4999 
5000  if (pLmCmp(set[length].p,p.p)!= currRing->OrdSgn) return length+1;
5001 
5002  int i;
5003  int an = 0;
5004  int en= length;
5005  int cmp_int=currRing->OrdSgn;
5006 
5007  loop
5008  {
5009  if (an >= en-1)
5010  {
5011  if (pLmCmp(set[an].p,p.p) == cmp_int) return an;
5012  return en;
5013  }
5014  i=(an+en) / 2;
5015  if (pLmCmp(set[i].p,p.p) == cmp_int) en=i;
5016  else an=i;
5017  }
5018 }

◆ posInT11()

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

Definition at line 5053 of file kutil.cc.

5054 {
5055  if (length==-1) return 0;
5056 
5057  int o = p.GetpFDeg();
5058  int op = set[length].GetpFDeg();
5059  int cmp_int=currRing->OrdSgn;
5060 
5061  if ((op < o)
5062  || ((op == o) && (pLmCmp(set[length].p,p.p) != cmp_int)))
5063  return length+1;
5064 
5065  int i;
5066  int an = 0;
5067  int en= length;
5068 
5069  loop
5070  {
5071  if (an >= en-1)
5072  {
5073  op= set[an].GetpFDeg();
5074  if ((op > o)
5075  || (( op == o) && (pLmCmp(set[an].p,p.p) == cmp_int)))
5076  return an;
5077  return en;
5078  }
5079  i=(an+en) / 2;
5080  op = set[i].GetpFDeg();
5081  if (( op > o)
5082  || (( op == o) && (pLmCmp(set[i].p,p.p) == cmp_int)))
5083  en=i;
5084  else
5085  an=i;
5086  }
5087 }

◆ posInT110()

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

Definition at line 5207 of file kutil.cc.

5208 {
5209  if (length==-1) return 0;
5210  p.GetpLength();
5211 
5212  int o = p.GetpFDeg();
5213  int op = set[length].GetpFDeg();
5214  int cmp_int=currRing->OrdSgn;
5215 
5216  if (( op < o)
5217  || (( op == o) && (set[length].length<p.length))
5218  || (( op == o) && (set[length].length == p.length)
5219  && (pLmCmp(set[length].p,p.p) != cmp_int)))
5220  return length+1;
5221 
5222  int i;
5223  int an = 0;
5224  int en= length;
5225  loop
5226  {
5227  if (an >= en-1)
5228  {
5229  op = set[an].GetpFDeg();
5230  if (( op > o)
5231  || (( op == o) && (set[an].length > p.length))
5232  || (( op == o) && (set[an].length == p.length)
5233  && (pLmCmp(set[an].p,p.p) == cmp_int)))
5234  return an;
5235  return en;
5236  }
5237  i=(an+en) / 2;
5238  op = set[i].GetpFDeg();
5239  if (( op > o)
5240  || (( op == o) && (set[i].length > p.length))
5241  || (( op == o) && (set[i].length == p.length)
5242  && (pLmCmp(set[i].p,p.p) == cmp_int)))
5243  en=i;
5244  else
5245  an=i;
5246  }
5247 }

◆ posInT110Ring()

int posInT110Ring ( const TSet  set,
const int  length,
LObject p 
)

Definition at line 5250 of file kutil.cc.

5251 {
5252  if (length==-1) return 0;
5253  p.GetpLength();
5254 
5255  int o = p.GetpFDeg();
5256  int op = set[length].GetpFDeg();
5257 
5258  if (( op < o)
5259  || (( op == o) && (set[length].length<p.length))
5260  || (( op == o) && (set[length].length == p.length)
5261  && (pLtCmpOrdSgnDiffP(set[length].p,p.p))))
5262  return length+1;
5263 
5264  int i;
5265  int an = 0;
5266  int en= length;
5267  loop
5268  {
5269  if (an >= en-1)
5270  {
5271  op = set[an].GetpFDeg();
5272  if (( op > o)
5273  || (( op == o) && (set[an].length > p.length))
5274  || (( op == o) && (set[an].length == p.length)
5275  && (pLtCmpOrdSgnEqP(set[an].p,p.p))))
5276  return an;
5277  return en;
5278  }
5279  i=(an+en) / 2;
5280  op = set[i].GetpFDeg();
5281  if (( op > o)
5282  || (( op == o) && (set[i].length > p.length))
5283  || (( op == o) && (set[i].length == p.length)
5284  && (pLtCmpOrdSgnEqP(set[i].p,p.p))))
5285  en=i;
5286  else
5287  an=i;
5288  }
5289 }
#define pLtCmpOrdSgnDiffP(p, q)
Definition: polys.h:126

◆ posInT11Ring()

int posInT11Ring ( const TSet  set,
const int  length,
LObject p 
)

Definition at line 5090 of file kutil.cc.

5091 {
5092  if (length==-1) return 0;
5093 
5094  int o = p.GetpFDeg();
5095  int op = set[length].GetpFDeg();
5096 
5097  if ((op < o)
5098  || ((op == o) && (pLtCmpOrdSgnDiffP(set[length].p,p.p))))
5099  return length+1;
5100 
5101  int i;
5102  int an = 0;
5103  int en= length;
5104 
5105  loop
5106  {
5107  if (an >= en-1)
5108  {
5109  op= set[an].GetpFDeg();
5110  if ((op > o)
5111  || (( op == o) && (pLtCmpOrdSgnEqP(set[an].p,p.p))))
5112  return an;
5113  return en;
5114  }
5115  i=(an+en) / 2;
5116  op = set[i].GetpFDeg();
5117  if (( op > o)
5118  || (( op == o) && (pLtCmpOrdSgnEqP(set[i].p,p.p))))
5119  en=i;
5120  else
5121  an=i;
5122  }
5123 }

◆ posInT13()

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

Definition at line 5297 of file kutil.cc.

5298 {
5299  if (length==-1) return 0;
5300 
5301  int o = p.GetpFDeg();
5302 
5303  if (set[length].GetpFDeg() <= o)
5304  return length+1;
5305 
5306  int i;
5307  int an = 0;
5308  int en= length;
5309  loop
5310  {
5311  if (an >= en-1)
5312  {
5313  if (set[an].GetpFDeg() > o)
5314  return an;
5315  return en;
5316  }
5317  i=(an+en) / 2;
5318  if (set[i].GetpFDeg() > o)
5319  en=i;
5320  else
5321  an=i;
5322  }
5323 }

◆ posInT15()

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

Definition at line 5364 of file kutil.cc.

5383 {
5384  if (length==-1) return 0;
5385 
5386  int o = p.GetpFDeg() + p.ecart;
5387  int op = set[length].GetpFDeg()+set[length].ecart;
5388  int cmp_int=currRing->OrdSgn;
5389 
5390  if ((op < o)
5391  || ((op == o)
5392  && (pLmCmp(set[length].p,p.p) != cmp_int)))
5393  return length+1;
5394 
5395  int i;
5396  int an = 0;
5397  int en= length;
5398  loop
5399  {
5400  if (an >= en-1)
5401  {
5402  op = set[an].GetpFDeg()+set[an].ecart;
5403  if (( op > o)
5404  || (( op == o) && (pLmCmp(set[an].p,p.p) == cmp_int)))
5405  return an;
5406  return en;
5407  }
5408  i=(an+en) / 2;
5409  op = set[i].GetpFDeg()+set[i].ecart;
5410  if (( op > o)
5411  || (( op == o) && (pLmCmp(set[i].p,p.p) == cmp_int)))
5412  en=i;
5413  else
5414  an=i;
5415  }
5416 }

◆ posInT15Ring()

int posInT15Ring ( const TSet  set,
const int  length,
LObject p 
)

Definition at line 5419 of file kutil.cc.

5420 {
5421  if (length==-1) return 0;
5422 
5423  int o = p.GetpFDeg() + p.ecart;
5424  int op = set[length].GetpFDeg()+set[length].ecart;
5425 
5426  if ((op < o)
5427  || ((op == o)
5428  && (pLtCmpOrdSgnDiffP(set[length].p,p.p))))
5429  return length+1;
5430 
5431  int i;
5432  int an = 0;
5433  int en= length;
5434  loop
5435  {
5436  if (an >= en-1)
5437  {
5438  op = set[an].GetpFDeg()+set[an].ecart;
5439  if (( op > o)
5440  || (( op == o) && (pLtCmpOrdSgnEqP(set[an].p,p.p))))
5441  return an;
5442  return en;
5443  }
5444  i=(an+en) / 2;
5445  op = set[i].GetpFDeg()+set[i].ecart;
5446  if (( op > o)
5447  || (( op == o) && (pLtCmpOrdSgnEqP(set[i].p,p.p))))
5448  en=i;
5449  else
5450  an=i;
5451  }
5452 }

◆ posInT17()

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

Definition at line 5460 of file kutil.cc.

5481 {
5482  if (length==-1) return 0;
5483 
5484  int o = p.GetpFDeg() + p.ecart;
5485  int op = set[length].GetpFDeg()+set[length].ecart;
5486  int cmp_int=currRing->OrdSgn;
5487 
5488  if ((op < o)
5489  || (( op == o) && (set[length].ecart > p.ecart))
5490  || (( op == o) && (set[length].ecart==p.ecart)
5491  && (pLmCmp(set[length].p,p.p) != cmp_int)))
5492  return length+1;
5493 
5494  int i;
5495  int an = 0;
5496  int en= length;
5497  loop
5498  {
5499  if (an >= en-1)
5500  {
5501  op = set[an].GetpFDeg()+set[an].ecart;
5502  if (( op > o)
5503  || (( op == o) && (set[an].ecart < p.ecart))
5504  || (( op == o) && (set[an].ecart==p.ecart)
5505  && (pLmCmp(set[an].p,p.p) == cmp_int)))
5506  return an;
5507  return en;
5508  }
5509  i=(an+en) / 2;
5510  op = set[i].GetpFDeg()+set[i].ecart;
5511  if ((op > o)
5512  || (( op == o) && (set[i].ecart < p.ecart))
5513  || (( op == o) && (set[i].ecart == p.ecart)
5514  && (pLmCmp(set[i].p,p.p) == cmp_int)))
5515  en=i;
5516  else
5517  an=i;
5518  }
5519 }

◆ posInT17_c()

int posInT17_c ( const TSet  set,
const int  length,
LObject p 
)

Definition at line 5568 of file kutil.cc.

5569 {
5570  if (length==-1) return 0;
5571 
5572  int cc = (-1+2*currRing->order[0]==ringorder_c);
5573  /* cc==1 for (c,..), cc==-1 for (C,..) */
5574  int o = p.GetpFDeg() + p.ecart;
5575  int c = pGetComp(p.p)*cc;
5576  int cmp_int=currRing->OrdSgn;
5577 
5578  if (pGetComp(set[length].p)*cc < c)
5579  return length+1;
5580  if (pGetComp(set[length].p)*cc == c)
5581  {
5582  int op = set[length].GetpFDeg()+set[length].ecart;
5583  if ((op < o)
5584  || ((op == o) && (set[length].ecart > p.ecart))
5585  || ((op == o) && (set[length].ecart==p.ecart)
5586  && (pLmCmp(set[length].p,p.p) != cmp_int)))
5587  return length+1;
5588  }
5589 
5590  int i;
5591  int an = 0;
5592  int en= length;
5593  loop
5594  {
5595  if (an >= en-1)
5596  {
5597  if (pGetComp(set[an].p)*cc < c)
5598  return en;
5599  if (pGetComp(set[an].p)*cc == c)
5600  {
5601  int op = set[an].GetpFDeg()+set[an].ecart;
5602  if ((op > o)
5603  || ((op == o) && (set[an].ecart < p.ecart))
5604  || ((op == o) && (set[an].ecart==p.ecart)
5605  && (pLmCmp(set[an].p,p.p) == cmp_int)))
5606  return an;
5607  }
5608  return en;
5609  }
5610  i=(an+en) / 2;
5611  if (pGetComp(set[i].p)*cc > c)
5612  en=i;
5613  else if (pGetComp(set[i].p)*cc == c)
5614  {
5615  int op = set[i].GetpFDeg()+set[i].ecart;
5616  if ((op > o)
5617  || ((op == o) && (set[i].ecart < p.ecart))
5618  || ((op == o) && (set[i].ecart == p.ecart)
5619  && (pLmCmp(set[i].p,p.p) == cmp_int)))
5620  en=i;
5621  else
5622  an=i;
5623  }
5624  else
5625  an=i;
5626  }
5627 }

◆ posInT17_cRing()

int posInT17_cRing ( const TSet  set,
const int  length,
LObject p 
)

Definition at line 5630 of file kutil.cc.

5631 {
5632  if (length==-1) return 0;
5633 
5634  int cc = (-1+2*currRing->order[0]==ringorder_c);
5635  /* cc==1 for (c,..), cc==-1 for (C,..) */
5636  int o = p.GetpFDeg() + p.ecart;
5637  int c = pGetComp(p.p)*cc;
5638 
5639  if (pGetComp(set[length].p)*cc < c)
5640  return length+1;
5641  if (pGetComp(set[length].p)*cc == c)
5642  {
5643  int op = set[length].GetpFDeg()+set[length].ecart;
5644  if ((op < o)
5645  || ((op == o) && (set[length].ecart > p.ecart))
5646  || ((op == o) && (set[length].ecart==p.ecart)
5647  && (pLtCmpOrdSgnDiffP(set[length].p,p.p))))
5648  return length+1;
5649  }
5650 
5651  int i;
5652  int an = 0;
5653  int en= length;
5654  loop
5655  {
5656  if (an >= en-1)
5657  {
5658  if (pGetComp(set[an].p)*cc < c)
5659  return en;
5660  if (pGetComp(set[an].p)*cc == c)
5661  {
5662  int op = set[an].GetpFDeg()+set[an].ecart;
5663  if ((op > o)
5664  || ((op == o) && (set[an].ecart < p.ecart))
5665  || ((op == o) && (set[an].ecart==p.ecart)
5666  && (pLtCmpOrdSgnEqP(set[an].p,p.p))))
5667  return an;
5668  }
5669  return en;
5670  }
5671  i=(an+en) / 2;
5672  if (pGetComp(set[i].p)*cc > c)
5673  en=i;
5674  else if (pGetComp(set[i].p)*cc == c)
5675  {
5676  int op = set[i].GetpFDeg()+set[i].ecart;
5677  if ((op > o)
5678  || ((op == o) && (set[i].ecart < p.ecart))
5679  || ((op == o) && (set[i].ecart == p.ecart)
5680  && (pLtCmpOrdSgnEqP(set[i].p,p.p))))
5681  en=i;
5682  else
5683  an=i;
5684  }
5685  else
5686  an=i;
5687  }
5688 }

◆ posInT17Ring()

int posInT17Ring ( const TSet  set,
const int  length,
LObject p 
)

Definition at line 5522 of file kutil.cc.

5523 {
5524  if (length==-1) return 0;
5525 
5526  int o = p.GetpFDeg() + p.ecart;
5527  int op = set[length].GetpFDeg()+set[length].ecart;
5528 
5529  if ((op < o)
5530  || (( op == o) && (set[length].ecart > p.ecart))
5531  || (( op == o) && (set[length].ecart==p.ecart)
5532  && (pLtCmpOrdSgnDiffP(set[length].p,p.p))))
5533  return length+1;
5534 
5535  int i;
5536  int an = 0;
5537  int en= length;
5538  loop
5539  {
5540  if (an >= en-1)
5541  {
5542  op = set[an].GetpFDeg()+set[an].ecart;
5543  if (( op > o)
5544  || (( op == o) && (set[an].ecart < p.ecart))
5545  || (( op == o) && (set[an].ecart==p.ecart)
5546  && (pLtCmpOrdSgnEqP(set[an].p,p.p))))
5547  return an;
5548  return en;
5549  }
5550  i=(an+en) / 2;
5551  op = set[i].GetpFDeg()+set[i].ecart;
5552  if ((op > o)
5553  || (( op == o) && (set[i].ecart < p.ecart))
5554  || (( op == o) && (set[i].ecart == p.ecart)
5555  && (pLtCmpOrdSgnEqP(set[i].p,p.p))))
5556  en=i;
5557  else
5558  an=i;
5559  }
5560 }

◆ posInT19()

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

Definition at line 5696 of file kutil.cc.

5697 {
5698  p.GetpLength();
5699  if (length==-1) return 0;
5700 
5701  int o = p.ecart;
5702  int op=p.GetpFDeg();
5703 
5704  if (set[length].ecart < o)
5705  return length+1;
5706  if (set[length].ecart == o)
5707  {
5708  int oo=set[length].GetpFDeg();
5709  if ((oo < op) || ((oo==op) && (set[length].length < p.length)))
5710  return length+1;
5711  }
5712 
5713  int i;
5714  int an = 0;
5715  int en= length;
5716  loop
5717  {
5718  if (an >= en-1)
5719  {
5720  if (set[an].ecart > o)
5721  return an;
5722  if (set[an].ecart == o)
5723  {
5724  int oo=set[an].GetpFDeg();
5725  if((oo > op)
5726  || ((oo==op) && (set[an].length > p.length)))
5727  return an;
5728  }
5729  return en;
5730  }
5731  i=(an+en) / 2;
5732  if (set[i].ecart > o)
5733  en=i;
5734  else if (set[i].ecart == o)
5735  {
5736  int oo=set[i].GetpFDeg();
5737  if ((oo > op)
5738  || ((oo == op) && (set[i].length > p.length)))
5739  en=i;
5740  else
5741  an=i;
5742  }
5743  else
5744  an=i;
5745  }
5746 }

◆ posInT2()

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

Definition at line 5025 of file kutil.cc.

5026 {
5027  if (length==-1) return 0;
5028  p.GetpLength();
5029  if (set[length].length<p.length) return length+1;
5030 
5031  int i;
5032  int an = 0;
5033  int en= length;
5034 
5035  loop
5036  {
5037  if (an >= en-1)
5038  {
5039  if (set[an].length>p.length) return an;
5040  return en;
5041  }
5042  i=(an+en) / 2;
5043  if (set[i].length>p.length) en=i;
5044  else an=i;
5045  }
5046 }

◆ posInT_EcartFDegpLength()

int posInT_EcartFDegpLength ( const TSet  set,
const int  length,
LObject p 
)

Definition at line 11708 of file kutil.cc.

11709 {
11710 
11711  if (length==-1) return 0;
11712 
11713  int o = p.ecart;
11714  int op=p.GetpFDeg();
11715  int ol = p.GetpLength();
11716 
11717  if (set[length].ecart < o)
11718  return length+1;
11719  if (set[length].ecart == o)
11720  {
11721  int oo=set[length].GetpFDeg();
11722  if ((oo < op) || ((oo==op) && (set[length].length < ol)))
11723  return length+1;
11724  }
11725 
11726  int i;
11727  int an = 0;
11728  int en= length;
11729  loop
11730  {
11731  if (an >= en-1)
11732  {
11733  if (set[an].ecart > o)
11734  return an;
11735  if (set[an].ecart == o)
11736  {
11737  int oo=set[an].GetpFDeg();
11738  if((oo > op)
11739  || ((oo==op) && (set[an].pLength > ol)))
11740  return an;
11741  }
11742  return en;
11743  }
11744  i=(an+en) / 2;
11745  if (set[i].ecart > o)
11746  en=i;
11747  else if (set[i].ecart == o)
11748  {
11749  int oo=set[i].GetpFDeg();
11750  if ((oo > op)
11751  || ((oo == op) && (set[i].pLength > ol)))
11752  en=i;
11753  else
11754  an=i;
11755  }
11756  else
11757  an=i;
11758  }
11759 }

◆ posInT_EcartpLength()

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

Definition at line 5326 of file kutil.cc.

5327 {
5328  if (length==-1) return 0;
5329  int ol = p.GetpLength();
5330  int op=p.ecart;
5331  int oo=set[length].ecart;
5332 
5333  if ((oo < op) || ((oo==op) && (set[length].length <= ol)))
5334  return length+1;
5335 
5336  int i;
5337  int an = 0;
5338  int en= length;
5339  loop
5340  {
5341  if (an >= en-1)
5342  {
5343  int oo=set[an].ecart;
5344  if((oo > op)
5345  || ((oo==op) && (set[an].pLength > ol)))
5346  return an;
5347  return en;
5348  }
5349  i=(an+en) / 2;
5350  int oo=set[i].ecart;
5351  if ((oo > op)
5352  || ((oo == op) && (set[i].pLength > ol)))
5353  en=i;
5354  else
5355  an=i;
5356  }
5357 }

◆ posInT_FDegpLength()

int posInT_FDegpLength ( const TSet  set,
const int  length,
LObject p 
)

Definition at line 11762 of file kutil.cc.

11763 {
11764 
11765  if (length==-1) return 0;
11766 
11767  int op=p.GetpFDeg();
11768  int ol = p.GetpLength();
11769 
11770  int oo=set[length].GetpFDeg();
11771  if ((oo < op) || ((oo==op) && (set[length].length < ol)))
11772  return length+1;
11773 
11774  int i;
11775  int an = 0;
11776  int en= length;
11777  loop
11778  {
11779  if (an >= en-1)
11780  {
11781  int oo=set[an].GetpFDeg();
11782  if((oo > op)
11783  || ((oo==op) && (set[an].pLength > ol)))
11784  return an;
11785  return en;
11786  }
11787  i=(an+en) / 2;
11788  int oo=set[i].GetpFDeg();
11789  if ((oo > op)
11790  || ((oo == op) && (set[i].pLength > ol)))
11791  en=i;
11792  else
11793  an=i;
11794  }
11795 }

◆ posInT_pLength()

int posInT_pLength ( const TSet  set,
const int  length,
LObject p 
)

Definition at line 11799 of file kutil.cc.

11800 {
11801  int ol = p.GetpLength();
11802  if (length==-1)
11803  return 0;
11804  if (set[length].length<p.length)
11805  return length+1;
11806 
11807  int i;
11808  int an = 0;
11809  int en= length;
11810 
11811  loop
11812  {
11813  if (an >= en-1)
11814  {
11815  if (set[an].pLength>ol) return an;
11816  return en;
11817  }
11818  i=(an+en) / 2;
11819  if (set[i].pLength>ol) en=i;
11820  else an=i;
11821  }
11822 }

◆ posInTrg0()

int posInTrg0 ( const TSet  set,
const int  length,
LObject p 
)

Definition at line 5131 of file kutil.cc.

5132 {
5133  if (length==-1) return 0;
5134  int o = p.GetpFDeg();
5135  int op = set[length].GetpFDeg();
5136  int i;
5137  int an = 0;
5138  int en = length;
5139  int cmp_int = currRing->OrdSgn;
5140  if ((op < o) || (pLmCmp(set[length].p,p.p)== -cmp_int))
5141  return length+1;
5142  int cmp;
5143  loop
5144  {
5145  if (an >= en-1)
5146  {
5147  op = set[an].GetpFDeg();
5148  if (op > o) return an;
5149  if (op < 0) return en;
5150  cmp = pLmCmp(set[an].p,p.p);
5151  if (cmp == cmp_int) return an;
5152  if (cmp == -cmp_int) return en;
5153  if (nGreater(pGetCoeff(p.p), pGetCoeff(set[an].p))) return en;
5154  return an;
5155  }
5156  i = (an + en) / 2;
5157  op = set[i].GetpFDeg();
5158  if (op > o) en = i;
5159  else if (op < o) an = i;
5160  else
5161  {
5162  cmp = pLmCmp(set[i].p,p.p);
5163  if (cmp == cmp_int) en = i;
5164  else if (cmp == -cmp_int) an = i;
5165  else if (nGreater(pGetCoeff(p.p), pGetCoeff(set[i].p))) an = i;
5166  else en = i;
5167  }
5168  }
5169 }

◆ postReduceByMon()

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 11036 of file kutil.cc.

11037 {
11038  if(!nCoeff_is_Z(currRing->cf))
11039  return;
11040  poly pH = h->GetP();
11041  poly p,pp;
11042  p = pH;
11043  bool deleted = FALSE, ok = FALSE;
11044  for(int i = 0; i<=strat->sl; i++)
11045  {
11046  p = pH;
11047  if(pNext(strat->S[i]) == NULL)
11048  {
11049  //pWrite(p);
11050  //pWrite(strat->S[i]);
11051  while(ok == FALSE && p != NULL)
11052  {
11053  if(pLmDivisibleBy(strat->S[i], p)
11054 #ifdef HAVE_SHIFTBBA
11055  || (rIsLPRing(currRing) && pLPLmDivisibleBy(strat->S[i], p))
11056 #endif
11057  )
11058  {
11059  number dummy = n_IntMod(p->coef, strat->S[i]->coef, currRing->cf);
11060  p_SetCoeff(p,dummy,currRing);
11061  }
11062  if(nIsZero(p->coef))
11063  {
11064  pLmDelete(&p);
11065  h->p = p;
11066  deleted = TRUE;
11067  }
11068  else
11069  {
11070  ok = TRUE;
11071  }
11072  }
11073  if (p!=NULL)
11074  {
11075  pp = pNext(p);
11076  while(pp != NULL)
11077  {
11078  if(pLmDivisibleBy(strat->S[i], pp)
11079 #ifdef HAVE_SHIFTBBA
11080  || (rIsLPRing(currRing) && pLPLmDivisibleBy(strat->S[i], pp))
11081 #endif
11082  )
11083  {
11084  number dummy = n_IntMod(pp->coef, strat->S[i]->coef, currRing->cf);
11085  p_SetCoeff(pp,dummy,currRing);
11086  if(nIsZero(pp->coef))
11087  {
11088  pLmDelete(&pNext(p));
11089  pp = pNext(p);
11090  deleted = TRUE;
11091  }
11092  else
11093  {
11094  p = pp;
11095  pp = pNext(p);
11096  }
11097  }
11098  else
11099  {
11100  p = pp;
11101  pp = pNext(p);
11102  }
11103  }
11104  }
11105  }
11106  }
11107  h->SetLmCurrRing();
11108  if((deleted)&&(h->p!=NULL))
11109  strat->initEcart(h);
11110 }

◆ postReduceByMonSig()

void postReduceByMonSig ( LObject h,
kStrategy  strat 
)

Definition at line 11112 of file kutil.cc.

11113 {
11114  if(!nCoeff_is_Z(currRing->cf))
11115  return;
11116  poly hSig = h->sig;
11117  poly pH = h->GetP();
11118  poly p,pp;
11119  p = pH;
11120  bool deleted = FALSE, ok = FALSE;
11121  for(int i = 0; i<=strat->sl; i++)
11122  {
11123  p = pH;
11124  if(pNext(strat->S[i]) == NULL)
11125  {
11126  while(ok == FALSE && p!=NULL)
11127  {
11128  if(pLmDivisibleBy(strat->S[i], p))
11129  {
11130  poly sigMult = pDivideM(pHead(p),pHead(strat->S[i]));
11131  sigMult = ppMult_mm(sigMult,pCopy(strat->sig[i]));
11132  if(sigMult!= NULL && pLtCmp(hSig,sigMult) == 1)
11133  {
11134  number dummy = n_IntMod(p->coef, strat->S[i]->coef, currRing->cf);
11135  p_SetCoeff(p,dummy,currRing);
11136  }
11137  pDelete(&sigMult);
11138  }
11139  if(nIsZero(p->coef))
11140  {
11141  pLmDelete(&p);
11142  h->p = p;
11143  deleted = TRUE;
11144  }
11145  else
11146  {
11147  ok = TRUE;
11148  }
11149  }
11150  if(p == NULL)
11151  return;
11152  pp = pNext(p);
11153  while(pp != NULL)
11154  {
11155  if(pLmDivisibleBy(strat->S[i], pp))
11156  {
11157  poly sigMult = pDivideM(pHead(p),pHead(strat->S[i]));
11158  sigMult = ppMult_mm(sigMult,pCopy(strat->sig[i]));
11159  if(sigMult!= NULL && pLtCmp(hSig,sigMult) == 1)
11160  {
11161  number dummy = n_IntMod(pp->coef, strat->S[i]->coef, currRing->cf);
11162  p_SetCoeff(pp,dummy,currRing);
11163  if(nIsZero(pp->coef))
11164  {
11165  pLmDelete(&pNext(p));
11166  pp = pNext(p);
11167  deleted = TRUE;
11168  }
11169  else
11170  {
11171  p = pp;
11172  pp = pNext(p);
11173  }
11174  }
11175  else
11176  {
11177  p = pp;
11178  pp = pNext(p);
11179  }
11180  pDelete(&sigMult);
11181  }
11182  else
11183  {
11184  p = pp;
11185  pp = pNext(p);
11186  }
11187  }
11188  }
11189  }
11190  h->SetLmCurrRing();
11191  if(deleted)
11192  strat->initEcart(h);
11193 
11194 }
#define ppMult_mm(p, m)
Definition: polys.h:201
#define pDivideM(a, b)
Definition: polys.h:294

◆ preIntegerCheck()

poly preIntegerCheck ( const ideal  Forig,
const ideal  Q 
)

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

Definition at line 10869 of file kutil.cc.

10870 {
10871  if(!nCoeff_is_Z(currRing->cf))
10872  return NULL;
10873  ideal F = idCopy(Forig);
10874  idSkipZeroes(F);
10875  poly pmon;
10876  ring origR = currRing;
10877  ideal monred = idInit(1,1);
10878  for(int i=0; i<idElem(F); i++)
10879  {
10880  if(pNext(F->m[i]) == NULL)
10881  idInsertPoly(monred, pCopy(F->m[i]));
10882  }
10883  int posconst = idPosConstant(F);
10884  if((posconst != -1) && (!nIsZero(F->m[posconst]->coef)))
10885  {
10886  idDelete(&F);
10887  idDelete(&monred);
10888  return NULL;
10889  }
10890  int idelemQ = 0;
10891  if(Q!=NULL)
10892  {
10893  idelemQ = IDELEMS(Q);
10894  for(int i=0; i<idelemQ; i++)
10895  {
10896  if(pNext(Q->m[i]) == NULL)
10897  idInsertPoly(monred, pCopy(Q->m[i]));
10898  }
10899  idSkipZeroes(monred);
10900  posconst = idPosConstant(monred);
10901  //the constant, if found, will be from Q
10902  if((posconst != -1) && (!nIsZero(monred->m[posconst]->coef)))
10903  {
10904  pmon = pCopy(monred->m[posconst]);
10905  idDelete(&F);
10906  idDelete(&monred);
10907  return pmon;
10908  }
10909  }
10910  ring QQ_ring = rCopy0(currRing,FALSE);
10911  nKillChar(QQ_ring->cf);
10912  QQ_ring->cf = nInitChar(n_Q, NULL);
10913  rComplete(QQ_ring,1);
10914  QQ_ring = rAssure_c_dp(QQ_ring);
10915  rChangeCurrRing(QQ_ring);
10916  nMapFunc nMap = n_SetMap(origR->cf, QQ_ring->cf);
10917  ideal II = idInit(IDELEMS(F)+idelemQ+2,id_RankFreeModule(F, origR));
10918  for(int i = 0, j = 0; i<IDELEMS(F); i++)
10919  II->m[j++] = prMapR(F->m[i], nMap, origR, QQ_ring);
10920  for(int i = 0, j = IDELEMS(F); i<idelemQ; i++)
10921  II->m[j++] = prMapR(Q->m[i], nMap, origR, QQ_ring);
10922  ideal one = kStd(II, NULL, isNotHomog, NULL);
10923  idSkipZeroes(one);
10924  if(idIsConstant(one))
10925  {
10926  //one should be <1>
10927  for(int i = IDELEMS(II)-1; i>=0; i--)
10928  if(II->m[i] != NULL)
10929  II->m[i+1] = II->m[i];
10930  II->m[0] = pOne();
10931  ideal syz = idSyzygies(II, isNotHomog, NULL);
10932  poly integer = NULL;
10933  for(int i = IDELEMS(syz)-1;i>=0; i--)
10934  {
10935  if(pGetComp(syz->m[i]) == 1)
10936  {
10937  pSetComp(syz->m[i],0);
10938  if(pIsConstant(pHead(syz->m[i])))
10939  {
10940  integer = pHead(syz->m[i]);
10941  break;
10942  }
10943  }
10944  }
10945  rChangeCurrRing(origR);
10946  nMapFunc nMap2 = n_SetMap(QQ_ring->cf, origR->cf);
10947  pmon = prMapR(integer, nMap2, QQ_ring, origR);
10948  idDelete(&monred);
10949  idDelete(&F);
10950  id_Delete(&II,QQ_ring);
10951  id_Delete(&one,QQ_ring);
10952  id_Delete(&syz,QQ_ring);
10953  p_Delete(&integer,QQ_ring);
10954  rDelete(QQ_ring);
10955  return pmon;
10956  }
10957  else
10958  {
10959  if(idIs0(monred))
10960  {
10961  poly mindegmon = NULL;
10962  for(int i = 0; i<IDELEMS(one); i++)
10963  {
10964  if(pNext(one->m[i]) == NULL)
10965  {
10966  if(mindegmon == NULL)
10967  mindegmon = pCopy(one->m[i]);
10968  else
10969  {
10970  if(p_Deg(one->m[i], QQ_ring) < p_Deg(mindegmon, QQ_ring))
10971  mindegmon = pCopy(one->m[i]);
10972  }
10973  }
10974  }
10975  if(mindegmon != NULL)
10976  {
10977  for(int i = IDELEMS(II)-1; i>=0; i--)
10978  if(II->m[i] != NULL)
10979  II->m[i+1] = II->m[i];
10980  II->m[0] = pCopy(mindegmon);
10981  ideal syz = idSyzygies(II, isNotHomog, NULL);
10982  bool found = FALSE;
10983  for(int i = IDELEMS(syz)-1;i>=0; i--)
10984  {
10985  if(pGetComp(syz->m[i]) == 1)
10986  {
10987  pSetComp(syz->m[i],0);
10988  if(pIsConstant(pHead(syz->m[i])))
10989  {
10990  pSetCoeff(mindegmon, nCopy(syz->m[i]->coef));
10991  found = TRUE;
10992  break;
10993  }
10994  }
10995  }
10996  id_Delete(&syz,QQ_ring);
10997  if (found == FALSE)
10998  {
10999  rChangeCurrRing(origR);
11000  idDelete(&monred);
11001  idDelete(&F);
11002  id_Delete(&II,QQ_ring);
11003  id_Delete(&one,QQ_ring);
11004  rDelete(QQ_ring);
11005  return NULL;
11006  }
11007  rChangeCurrRing(origR);
11008  nMapFunc nMap2 = n_SetMap(QQ_ring->cf, origR->cf);
11009  pmon = prMapR(mindegmon, nMap2, QQ_ring, origR);
11010  idDelete(&monred);
11011  idDelete(&F);
11012  id_Delete(&II,QQ_ring);
11013  id_Delete(&one,QQ_ring);
11014  id_Delete(&syz,QQ_ring);
11015  rDelete(QQ_ring);
11016  return pmon;
11017  }
11018  }
11019  }
11020  rChangeCurrRing(origR);
11021  idDelete(&monred);
11022  idDelete(&F);
11023  id_Delete(&II,QQ_ring);
11024  id_Delete(&one,QQ_ring);
11025  rDelete(QQ_ring);
11026  return NULL;
11027 }
@ n_Q
rational (GMP) numbers
Definition: coeffs.h:30
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
Definition: coeffs.h:700
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition: numbers.cc:392
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:73
void nKillChar(coeffs r)
undo all initialisations
Definition: numbers.cc:547
ideal idSyzygies(ideal h1, tHomog h, intvec **w, BOOLEAN setSyzComp, BOOLEAN setRegularity, int *deg, GbVariant alg)
Definition: ideals.cc:830
#define idIsConstant(I)
Definition: ideals.h:40
BOOLEAN idInsertPoly(ideal h1, poly h2)
insert h2 into h1 (if h2 is not the zero polynomial) return TRUE iff h2 was indeed inserted
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
ideal idCopy(ideal A)
Definition: ideals.h:60
#define idPosConstant(I)
index of generator with leading term in ground ring (if any); otherwise -1
Definition: ideals.h:37
ideal kStd(ideal F, ideal Q, tHomog h, intvec **w, intvec *hilb, int syzComp, int newIdeal, intvec *vw, s_poly_proc_t sp)
Definition: kstd1.cc:2433
void rChangeCurrRing(ring r)
Definition: polys.cc:15
poly prMapR(poly src, nMapFunc nMap, ring src_r, ring dest_r)
Definition: prCopy.cc:45
BOOLEAN rComplete(ring r, int force)
this needs to be called whenever a new ring is created: new fields in ring are created (like VarOffse...
Definition: ring.cc:3492
ring rAssure_c_dp(const ring r)
Definition: ring.cc:5070
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
Definition: ring.cc:1421
void rDelete(ring r)
unconditionally deletes fields in r
Definition: ring.cc:450
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
int idElem(const ideal F)
count non-zero elements
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
@ isNotHomog
Definition: structs.h:36

◆ redBba()

static poly redBba ( poly  h,
int  maxIndex,
kStrategy  strat 
)
static

Definition at line 8797 of file kutil.cc.

8798 {
8799  int j = 0;
8800  unsigned long not_sev = ~ pGetShortExpVector(h);
8801 
8802  while (j <= maxIndex)
8803  {
8804  if (pLmShortDivisibleBy(strat->S[j],strat->sevS[j], h, not_sev))
8805  {
8806  h = ksOldSpolyRed(strat->S[j],h,strat->kNoetherTail());
8807  if (h==NULL) return NULL;
8808  j = 0;
8809  not_sev = ~ pGetShortExpVector(h);
8810  }
8811  else j++;
8812  }
8813  return h;
8814 }
KINLINE poly ksOldSpolyRed(poly p1, poly p2, poly spNoether)
Definition: kInline.h:1185
#define pLmShortDivisibleBy(a, sev_a, b, not_sev_b)
Divisibility tests based on Short Exponent vectors sev_a == pGetShortExpVector(a) not_sev_b == ~ pGet...
Definition: polys.h:146

◆ redBba1()

static poly redBba1 ( poly  h,
int  maxIndex,
kStrategy  strat 
)
static

Definition at line 8692 of file kutil.cc.

8693 {
8694  int j = 0;
8695  unsigned long not_sev = ~ pGetShortExpVector(h);
8696 
8697  while (j <= maxIndex)
8698  {
8699  if (pLmShortDivisibleBy(strat->S[j],strat->sevS[j],h, not_sev))
8700  return ksOldSpolyRedNew(strat->S[j],h,strat->kNoetherTail());
8701  else j++;
8702  }
8703  return h;
8704 }
KINLINE poly ksOldSpolyRedNew(poly p1, poly p2, poly spNoether)
Definition: kInline.h:1195

◆ redEcart()

int redEcart ( LObject h,
kStrategy  strat 
)

Definition at line 169 of file kstd1.cc.

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

◆ redFirst()

int redFirst ( LObject h,
kStrategy  strat 
)

Definition at line 797 of file kstd1.cc.

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

◆ redMora()

static poly redMora ( poly  h,
int  maxIndex,
kStrategy  strat 
)
static

Definition at line 8821 of file kutil.cc.

8822 {
8823  int j=0;
8824  int e,l;
8825  unsigned long not_sev = ~ pGetShortExpVector(h);
8826 
8827  if (maxIndex >= 0)
8828  {
8829  e = currRing->pLDeg(h,&l,currRing)-p_FDeg(h,currRing);
8830  do
8831  {
8832  if (pLmShortDivisibleBy(strat->S[j],strat->sevS[j], h, not_sev)
8833  && ((e >= strat->ecartS[j]) || (strat->kNoether!=NULL)))
8834  {
8835 #ifdef KDEBUG
8836  if (TEST_OPT_DEBUG)
8837  {
8838  PrintS("reduce ");wrp(h);Print(" with S[%d] (",j);wrp(strat->S[j]);
8839  }
8840 #endif
8841  h = ksOldSpolyRed(strat->S[j],h,strat->kNoetherTail());
8842 #ifdef KDEBUG
8843  if(TEST_OPT_DEBUG)
8844  {
8845  PrintS(")\nto "); wrp(h); PrintLn();
8846  }
8847 #endif
8848  // pDelete(&h);
8849  if (h == NULL) return NULL;
8850  e = currRing->pLDeg(h,&l,currRing)-p_FDeg(h,currRing);
8851  j = 0;
8852  not_sev = ~ pGetShortExpVector(h);
8853  }
8854  else j++;
8855  }
8856  while (j <= maxIndex);
8857  }
8858  return h;
8859 }

◆ redtail() [1/2]

poly redtail ( LObject L,
int  end_pos,
kStrategy  strat 
)

Definition at line 7147 of file kutil.cc.

7148 {
7149  poly h, hn;
7150  strat->redTailChange=FALSE;
7151 
7152  L->GetP();
7153  poly p = L->p;
7154  if (strat->noTailReduction || pNext(p) == NULL)
7155  return p;
7156 
7157  LObject Ln(strat->tailRing);
7158  TObject* With;
7159  // placeholder in case strat->tl < 0
7160  TObject With_s(strat->tailRing);
7161  h = p;
7162  hn = pNext(h);
7163  long op = strat->tailRing->pFDeg(hn, strat->tailRing);
7164  long e;
7165  int l;
7166  BOOLEAN save_HE=strat->kAllAxis;
7167  strat->kAllAxis |=
7168  ((Kstd1_deg>0) && (op<=Kstd1_deg)) || TEST_OPT_INFREDTAIL;
7169 
7170  while(hn != NULL)
7171  {
7172  op = strat->tailRing->pFDeg(hn, strat->tailRing);
7173  if ((Kstd1_deg>0)&&(op>Kstd1_deg)) goto all_done;
7174  e = strat->tailRing->pLDeg(hn, &l, strat->tailRing) - op;
7175  loop
7176  {
7177  Ln.Set(hn, strat->tailRing);
7178  Ln.sev = p_GetShortExpVector(hn, strat->tailRing);
7179  if (strat->kAllAxis)
7180  With = kFindDivisibleByInS_T(strat, end_pos, &Ln, &With_s);
7181  else
7182  With = kFindDivisibleByInS_T(strat, end_pos, &Ln, &With_s, e);
7183  if (With == NULL) break;
7184  With->length=0;
7185  With->pLength=0;
7186  strat->redTailChange=TRUE;
7187  if (ksReducePolyTail(L, With, h, strat->kNoetherTail()))
7188  {
7189  // reducing the tail would violate the exp bound
7190  if (kStratChangeTailRing(strat, L))
7191  {
7192  strat->kAllAxis = save_HE;
7193  return redtail(L, end_pos, strat);
7194  }
7195  else
7196  return NULL;
7197  }
7198  hn = pNext(h);
7199  if (hn == NULL) goto all_done;
7200  op = strat->tailRing->pFDeg(hn, strat->tailRing);
7201  if ((Kstd1_deg>0)&&(op>Kstd1_deg)) goto all_done;
7202  e = strat->tailRing->pLDeg(hn, &l, strat->tailRing) - op;
7203  }
7204  h = hn;
7205  hn = pNext(h);
7206  }
7207 
7208  all_done:
7209  if (strat->redTailChange)
7210  {
7211  L->pLength = 0;
7212  }
7213  strat->kAllAxis = save_HE;
7214  return p;
7215 }
KINLINE int ksReducePolyTail(LObject *PR, TObject *PW, LObject *Red)
Definition: kInline.h:1158
TObject * kFindDivisibleByInS_T(kStrategy strat, int end_pos, LObject *L, TObject *T, long ecart)
Definition: kutil.cc:7005
#define TEST_OPT_INFREDTAIL
Definition: options.h:119

◆ redtail() [2/2]

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

Definition at line 7217 of file kutil.cc.

7218 {
7219  LObject L(p, currRing);
7220  return redtail(&L, end_pos, strat);
7221 }

◆ redtailBba()

poly redtailBba ( LObject L,
int  end_pos,
kStrategy  strat,
BOOLEAN  withT,
BOOLEAN  normalize 
)

Definition at line 7223 of file kutil.cc.

7224 {
7225  strat->redTailChange=FALSE;
7226  if (strat->noTailReduction) return L->GetLmCurrRing();
7227  poly h, p;
7228  p = h = L->GetLmTailRing();
7229  if ((h==NULL) || (pNext(h)==NULL))
7230  return L->GetLmCurrRing();
7231 
7232  TObject* With;
7233  // placeholder in case strat->tl < 0
7234  TObject With_s(strat->tailRing);
7235 
7236  LObject Ln(pNext(h), strat->tailRing);
7237  Ln.GetpLength();
7238 
7239  pNext(h) = NULL;
7240  if (L->p != NULL)
7241  {
7242  pNext(L->p) = NULL;
7243  if (L->t_p != NULL) pNext(L->t_p) = NULL;
7244  }
7245  L->pLength = 1;
7246 
7247  Ln.PrepareRed(strat->use_buckets);
7248 
7249  int cnt=REDTAIL_CANONICALIZE;
7250  while(!Ln.IsNull())
7251  {
7252  loop
7253  {
7254  if (TEST_OPT_IDLIFT)
7255  {
7256  if (Ln.p!=NULL)
7257  {
7258  if (__p_GetComp(Ln.p,currRing)> strat->syzComp) break;
7259  }
7260  else
7261  {
7262  if (__p_GetComp(Ln.t_p,strat->tailRing)> strat->syzComp) break;
7263  }
7264  }
7265  Ln.SetShortExpVector();
7266  if (withT)
7267  {
7268  int j;
7269  j = kFindDivisibleByInT(strat, &Ln);
7270  if (j < 0) break;
7271  With = &(strat->T[j]);
7272  assume(With->GetpLength()==pLength(With->p != __null ? With->p : With->t_p));
7273  }
7274  else
7275  {
7276  With = kFindDivisibleByInS_T(strat, end_pos, &Ln, &With_s);
7277  if (With == NULL) break;
7278  assume(With->GetpLength()==pLength(With->p != __null ? With->p : With->t_p));
7279  }
7280  cnt--;
7281  if (cnt==0)
7282  {
7284  /*poly tmp=*/Ln.CanonicalizeP();
7285  if (normalize)
7286  {
7287  Ln.Normalize();
7288  //pNormalize(tmp);
7289  //if (TEST_OPT_PROT) { PrintS("n"); mflush(); }
7290  }
7291  }
7292  if (normalize && (!TEST_OPT_INTSTRATEGY) && (!nIsOne(pGetCoeff(With->p))))
7293  {
7294  With->pNorm();
7295  }
7296  strat->redTailChange=TRUE;
7297  if (ksReducePolyTail(L, With, &Ln))
7298  {
7299  // reducing the tail would violate the exp bound
7300  // set a flag and hope for a retry (in bba)
7301  strat->completeReduce_retry=TRUE;
7302  if ((Ln.p != NULL) && (Ln.t_p != NULL)) Ln.p=NULL;
7303  do
7304  {
7305  pNext(h) = Ln.LmExtractAndIter();
7306  pIter(h);
7307  L->pLength++;
7308  } while (!Ln.IsNull());
7309  goto all_done;
7310  }
7311  if (Ln.IsNull()) goto all_done;
7312  if (! withT) With_s.Init(currRing);
7313  }
7314  pNext(h) = Ln.LmExtractAndIter();
7315  pIter(h);
7316  pNormalize(h);
7317  L->pLength++;
7318  }
7319 
7320  all_done:
7321  Ln.Delete();
7322  if (L->p != NULL) pNext(L->p) = pNext(p);
7323 
7324  if (strat->redTailChange)
7325  {
7326  L->length = 0;
7327  L->pLength = 0;
7328  }
7329 
7330  //if (TEST_OPT_PROT) { PrintS("N"); mflush(); }
7331  //L->Normalize(); // HANNES: should have a test
7332  kTest_L(L,strat);
7333  return L->GetLmCurrRing();
7334 }
char completeReduce_retry
Definition: kutil.h:403
#define REDTAIL_CANONICALIZE
Definition: kutil.h:38
#define pNormalize(p)
Definition: polys.h:317
static poly normalize(poly next_p, ideal add_generators, syStrategy syzstr, int *g_l, int *p_l, int crit_comp)
Definition: syz3.cc:1026

◆ redtailBba_Ring()

poly redtailBba_Ring ( LObject L,
int  end_pos,
kStrategy  strat 
)

Definition at line 7695 of file kutil.cc.

7697 {
7698  strat->redTailChange=FALSE;
7699  if (strat->noTailReduction) return L->GetLmCurrRing();
7700  poly h, p;
7701  p = h = L->GetLmTailRing();
7702  if ((h==NULL) || (pNext(h)==NULL))
7703  return L->GetLmCurrRing();
7704 
7705  TObject* With;
7706  // placeholder in case strat->tl < 0
7707  TObject With_s(strat->tailRing);
7708 
7709  LObject Ln(pNext(h), strat->tailRing);
7710  Ln.pLength = L->GetpLength() - 1;
7711 
7712  pNext(h) = NULL;
7713  if (L->p != NULL) pNext(L->p) = NULL;
7714  L->pLength = 1;
7715 
7716  Ln.PrepareRed(strat->use_buckets);
7717 
7718  int cnt=REDTAIL_CANONICALIZE;
7719  while(!Ln.IsNull())
7720  {
7721  loop
7722  {
7723  Ln.SetShortExpVector();
7724  With_s.Init(currRing);
7725  With = kFindDivisibleByInS_T(strat, end_pos, &Ln, &With_s);
7726  if (With == NULL) break;
7727  cnt--;
7728  if (cnt==0)
7729  {
7731  /*poly tmp=*/Ln.CanonicalizeP();
7732  }
7733  // we are in a ring, do not call pNorm
7734  // test divisibility of coefs:
7735  poly p_Ln=Ln.GetLmCurrRing();
7736  poly p_With=With->GetLmCurrRing();
7737  if (n_DivBy(pGetCoeff(p_Ln),pGetCoeff(p_With), currRing->cf))
7738  {
7739  strat->redTailChange=TRUE;
7740 
7741  if (ksReducePolyTail_Z(L, With, &Ln))
7742  {
7743  // reducing the tail would violate the exp bound
7744  // set a flag and hope for a retry (in bba)
7745  strat->completeReduce_retry=TRUE;
7746  if ((Ln.p != NULL) && (Ln.t_p != NULL)) Ln.p=NULL;
7747  do
7748  {
7749  pNext(h) = Ln.LmExtractAndIter();
7750  pIter(h);
7751  L->pLength++;
7752  } while (!Ln.IsNull());
7753  goto all_done;
7754  }
7755  }
7756  else break; /*proceed to next monomial*/
7757  if (Ln.IsNull()) goto all_done;
7758  }
7759  pNext(h) = Ln.LmExtractAndIter();
7760  pIter(h);
7761  pNormalize(h);
7762  L->pLength++;
7763  }
7764 
7765  all_done:
7766  Ln.Delete();
7767  if (L->p != NULL) pNext(L->p) = pNext(p);
7768 
7769  if (strat->redTailChange)
7770  {
7771  L->length = 0;
7772  }
7773 
7774  //if (TEST_OPT_PROT) { PrintS("N"); mflush(); }
7775  //L->Normalize(); // HANNES: should have a test
7776  kTest_L(L,strat);
7777  return L->GetLmCurrRing();
7778 }
KINLINE int ksReducePolyTail_Z(LObject *PR, TObject *PW, LObject *Red)
Definition: kInline.h:1138

◆ redtailBba_Z()

poly redtailBba_Z ( LObject L,
int  end_pos,
kStrategy  strat 
)

Definition at line 7581 of file kutil.cc.

7583 {
7584  strat->redTailChange=FALSE;
7585  if (strat->noTailReduction) return L->GetLmCurrRing();
7586  poly h, p;
7587  p = h = L->GetLmTailRing();
7588  if ((h==NULL) || (pNext(h)==NULL))
7589  return L->GetLmCurrRing();
7590 
7591  TObject* With;
7592  // placeholder in case strat->tl < 0
7593  TObject With_s(strat->tailRing);
7594 
7595  LObject Ln(pNext(h), strat->tailRing);
7596  Ln.pLength = L->GetpLength() - 1;
7597 
7598  pNext(h) = NULL;
7599  if (L->p != NULL) pNext(L->p) = NULL;
7600  L->pLength = 1;
7601 
7602  Ln.PrepareRed(strat->use_buckets);
7603 
7604  int cnt=REDTAIL_CANONICALIZE;
7605  while(!Ln.IsNull())
7606  {
7607  loop
7608  {
7609  Ln.SetShortExpVector();
7610  With = kFindDivisibleByInS_T(strat, end_pos, &Ln, &With_s);
7611  if (With == NULL) break;
7612  cnt--;
7613  if (cnt==0)
7614  {
7616  /*poly tmp=*/Ln.CanonicalizeP();
7617  }
7618  // we are in Z, do not call pNorm
7619  strat->redTailChange=TRUE;
7620  // test divisibility of coefs:
7621  poly p_Ln=Ln.GetLmCurrRing();
7622  poly p_With=With->GetLmCurrRing();
7623  number z=n_IntMod(pGetCoeff(p_Ln),pGetCoeff(p_With), currRing->cf);
7624  if (!nIsZero(z))
7625  {
7626  // subtract z*Ln, add z.Ln to L
7627  poly m=pHead(p_Ln);
7628  pSetCoeff(m,z);
7629  poly mm=pHead(m);
7630  pNext(h) = m;
7631  pIter(h);
7632  L->pLength++;
7633  mm=pNeg(mm);
7634  if (Ln.bucket!=NULL)
7635  {
7636  int dummy=1;
7637  kBucket_Add_q(Ln.bucket,mm,&dummy);
7638  }
7639  else
7640  {
7641  if ((Ln.t_p!=NULL)&&(Ln.p==NULL))
7642  Ln.GetP();
7643  if (Ln.p!=NULL)
7644  {
7645  Ln.p=pAdd(Ln.p,mm);
7646  if (Ln.t_p!=NULL)
7647  {
7648  pNext(Ln.t_p)=NULL;
7649  p_LmDelete(Ln.t_p,strat->tailRing);
7650  }
7651  }
7652  }
7653  }
7654  else
7655  nDelete(&z);
7656 
7657  if (ksReducePolyTail_Z(L, With, &Ln))
7658  {
7659  // reducing the tail would violate the exp bound
7660  // set a flag and hope for a retry (in bba)
7661  strat->completeReduce_retry=TRUE;
7662  if ((Ln.p != NULL) && (Ln.t_p != NULL)) Ln.p=NULL;
7663  do
7664  {
7665  pNext(h) = Ln.LmExtractAndIter();
7666  pIter(h);
7667  L->pLength++;
7668  } while (!Ln.IsNull());
7669  goto all_done;
7670  }
7671  if (Ln.IsNull()) goto all_done;
7672  With_s.Init(currRing);
7673  }
7674  pNext(h) = Ln.LmExtractAndIter();
7675  pIter(h);
7676  pNormalize(h);
7677  L->pLength++;
7678  }
7679 
7680  all_done:
7681  Ln.Delete();
7682  if (L->p != NULL) pNext(L->p) = pNext(p);
7683 
7684  if (strat->redTailChange)
7685  {
7686  L->length = 0;
7687  }
7688 
7689  //if (TEST_OPT_PROT) { PrintS("N"); mflush(); }
7690  //L->Normalize(); // HANNES: should have a test
7691  kTest_L(L,strat);
7692  return L->GetLmCurrRing();
7693 }
int m
Definition: cfEzgcd.cc:128
void kBucket_Add_q(kBucket_pt bucket, poly q, int *l)
Add to Bucket a poly ,i.e. Bpoly == q+Bpoly.
Definition: kbuckets.cc:660
#define pAdd(p, q)
Definition: polys.h:203

◆ redtailBbaAlsoLC_Z()

void redtailBbaAlsoLC_Z ( LObject L,
int  end_pos,
kStrategy  strat 
)

Definition at line 7452 of file kutil.cc.

7454 {
7455  strat->redTailChange=FALSE;
7456 
7457  poly h, p;
7458  p = h = L->GetLmTailRing();
7459  if ((h==NULL) || (pNext(h)==NULL))
7460  return;
7461 
7462  TObject* With;
7463  LObject Ln(pNext(h), strat->tailRing);
7464  Ln.GetpLength();
7465 
7466  pNext(h) = NULL;
7467  if (L->p != NULL)
7468  {
7469  pNext(L->p) = NULL;
7470  if (L->t_p != NULL) pNext(L->t_p) = NULL;
7471  }
7472  L->pLength = 1;
7473 
7474  Ln.PrepareRed(strat->use_buckets);
7475 
7476  int cnt=REDTAIL_CANONICALIZE;
7477 
7478  while(!Ln.IsNull())
7479  {
7480  loop
7481  {
7482  if (TEST_OPT_IDLIFT)
7483  {
7484  if (Ln.p!=NULL)
7485  {
7486  if (__p_GetComp(Ln.p,currRing)> strat->syzComp) break;
7487  }
7488  else
7489  {
7490  if (__p_GetComp(Ln.t_p,strat->tailRing)> strat->syzComp) break;
7491  }
7492  }
7493  Ln.SetShortExpVector();
7494  int j;
7495  j = kFindDivisibleByInT(strat, &Ln);
7496  if (j < 0)
7497  {
7498  j = kFindDivisibleByInT_Z(strat, &Ln);
7499  if (j < 0)
7500  {
7501  break;
7502  }
7503  else
7504  {
7505  /* reduction not cancelling a tail term, but reducing its coefficient */
7506  With = &(strat->T[j]);
7507  assume(With->GetpLength()==pLength(With->p != __null ? With->p : With->t_p));
7508  cnt--;
7509  if (cnt==0)
7510  {
7512  /*poly tmp=*/Ln.CanonicalizeP();
7513  }
7514  strat->redTailChange=TRUE;
7515  /* reduction cancelling a tail term */
7516  if (ksReducePolyTailLC_Z(L, With, &Ln))
7517  {
7518  // reducing the tail would violate the exp bound
7519  // set a flag and hope for a retry (in bba)
7520  strat->completeReduce_retry=TRUE;
7521  if ((Ln.p != NULL) && (Ln.t_p != NULL)) Ln.p=NULL;
7522  do
7523  {
7524  pNext(h) = Ln.LmExtractAndIter();
7525  pIter(h);
7526  L->pLength++;
7527  } while (!Ln.IsNull());
7528  goto all_done;
7529  }
7530  /* we have to break since we did not cancel the term, but only decreased
7531  * its coefficient. */
7532  break;
7533  }
7534  } else {
7535  With = &(strat->T[j]);
7536  assume(With->GetpLength()==pLength(With->p != __null ? With->p : With->t_p));
7537  cnt--;
7538  if (cnt==0)
7539  {
7541  /*poly tmp=*/Ln.CanonicalizeP();
7542  }
7543  strat->redTailChange=TRUE;
7544  /* reduction cancelling a tail term */
7545  if (ksReducePolyTail_Z(L, With, &Ln))
7546  {
7547  // reducing the tail would violate the exp bound
7548  // set a flag and hope for a retry (in bba)
7549  strat->completeReduce_retry=TRUE;
7550  if ((Ln.p != NULL) && (Ln.t_p != NULL)) Ln.p=NULL;
7551  do
7552  {
7553  pNext(h) = Ln.LmExtractAndIter();
7554  pIter(h);
7555  L->pLength++;
7556  } while (!Ln.IsNull());
7557  goto all_done;
7558  }
7559  }
7560  if (Ln.IsNull()) goto all_done;
7561  }
7562  pNext(h) = Ln.LmExtractAndIter();
7563  pIter(h);
7564  L->pLength++;
7565  }
7566 
7567  all_done:
7568  Ln.Delete();
7569  if (L->p != NULL) pNext(L->p) = pNext(p);
7570 
7571  if (strat->redTailChange)
7572  {
7573  L->length = 0;
7574  L->pLength = 0;
7575  }
7576 
7577  kTest_L(L, strat);
7578  return;
7579 }
KINLINE int ksReducePolyTailLC_Z(LObject *PR, TObject *PW, LObject *Red)
Definition: kInline.h:1120
int kFindDivisibleByInT_Z(const kStrategy strat, const LObject *L, const int start)
Definition: kstd2.cc:209

◆ redtailBbaBound()

poly redtailBbaBound ( LObject L,
int  end_pos,
kStrategy  strat,
int  bound,
BOOLEAN  withT,
BOOLEAN  normalize 
)

Definition at line 7336 of file kutil.cc.

7337 {
7338  strat->redTailChange=FALSE;
7339  if (strat->noTailReduction) return L->GetLmCurrRing();
7340  poly h, p;
7341  p = h = L->GetLmTailRing();
7342  if ((h==NULL) || (pNext(h)==NULL))
7343  return L->GetLmCurrRing();
7344 
7345  TObject* With;
7346  // placeholder in case strat->tl < 0
7347  TObject With_s(strat->tailRing);
7348 
7349  LObject Ln(pNext(h), strat->tailRing);
7350  Ln.pLength = L->GetpLength() - 1;
7351 
7352  pNext(h) = NULL;
7353  if (L->p != NULL) pNext(L->p) = NULL;
7354  L->pLength = 1;
7355 
7356  Ln.PrepareRed(strat->use_buckets);
7357 
7358  int cnt=REDTAIL_CANONICALIZE;
7359  while(!Ln.IsNull())
7360  {
7361  loop
7362  {
7363  if (TEST_OPT_IDLIFT)
7364  {
7365  if (Ln.p!=NULL)
7366  {
7367  if (__p_GetComp(Ln.p,currRing)> strat->syzComp) break;
7368  }
7369  else
7370  {
7371  if (__p_GetComp(Ln.t_p,strat->tailRing)> strat->syzComp) break;
7372  }
7373  }
7374  Ln.SetShortExpVector();
7375  if (withT)
7376  {
7377  int j;
7378  j = kFindDivisibleByInT(strat, &Ln);
7379  if (j < 0) break;
7380  With = &(strat->T[j]);
7381  }
7382  else
7383  {
7384  With = kFindDivisibleByInS_T(strat, end_pos, &Ln, &With_s);
7385  if (With == NULL) break;
7386  }
7387  cnt--;
7388  if (cnt==0)
7389  {
7391  /*poly tmp=*/Ln.CanonicalizeP();
7392  if (normalize)
7393  {
7394  Ln.Normalize();
7395  //pNormalize(tmp);
7396  //if (TEST_OPT_PROT) { PrintS("n"); mflush(); }
7397  }
7398  }
7399  if (normalize && (!TEST_OPT_INTSTRATEGY) && (!nIsOne(pGetCoeff(With->p))))
7400  {
7401  With->pNorm();
7402  }
7403  strat->redTailChange=TRUE;
7404  if (ksReducePolyTail(L, With, &Ln))
7405  {
7406  // reducing the tail would violate the exp bound
7407  // set a flag and hope for a retry (in bba)
7408  strat->completeReduce_retry=TRUE;
7409  if ((Ln.p != NULL) && (Ln.t_p != NULL)) Ln.p=NULL;
7410  do
7411  {
7412  pNext(h) = Ln.LmExtractAndIter();
7413  pIter(h);
7414  L->pLength++;
7415  } while (!Ln.IsNull());
7416  goto all_done;
7417  }
7418  if(!Ln.IsNull())
7419  {
7420  Ln.GetP();
7421  Ln.p = pJet(Ln.p,bound);
7422  }
7423  if (Ln.IsNull())
7424  {
7425  goto all_done;
7426  }
7427  if (! withT) With_s.Init(currRing);
7428  }
7429  pNext(h) = Ln.LmExtractAndIter();
7430  pIter(h);
7431  pNormalize(h);
7432  L->pLength++;
7433  }
7434 
7435  all_done:
7436  Ln.Delete();
7437  if (L->p != NULL) pNext(L->p) = pNext(p);
7438 
7439  if (strat->redTailChange)
7440  {
7441  L->length = 0;
7442  L->pLength = 0;
7443  }
7444 
7445  //if (TEST_OPT_PROT) { PrintS("N"); mflush(); }
7446  //L->Normalize(); // HANNES: should have a test
7447  kTest_L(L,strat);
7448  return L->GetLmCurrRing();
7449 }
static CanonicalForm bound(const CFMatrix &M)
Definition: cf_linsys.cc:460
#define pJet(p, m)
Definition: polys.h:368

◆ redtailBbaShift()

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

Definition at line 13473 of file kutil.cc.

13474 {
13475  /* for the shift case need to run it with withT = TRUE */
13476  strat->redTailChange=FALSE;
13477  if (strat->noTailReduction) return L->GetLmCurrRing();
13478  poly h, p;
13479  p = h = L->GetLmTailRing();
13480  if ((h==NULL) || (pNext(h)==NULL))
13481  return L->GetLmCurrRing();
13482 
13483  TObject* With;
13484  // placeholder in case strat->tl < 0
13485  TObject With_s(strat->tailRing);
13486 
13487  LObject Ln(pNext(h), strat->tailRing);
13488  Ln.pLength = L->GetpLength() - 1;
13489 
13490  pNext(h) = NULL;
13491  if (L->p != NULL) pNext(L->p) = NULL;
13492  L->pLength = 1;
13493 
13494  Ln.PrepareRed(strat->use_buckets);
13495 
13496  while(!Ln.IsNull())
13497  {
13498  loop
13499  {
13500  Ln.SetShortExpVector();
13501  if (withT)
13502  {
13503  int j;
13504  j = kFindDivisibleByInT(strat, &Ln);
13505  if (j < 0) break;
13506  With = &(strat->T[j]);
13507  }
13508  else
13509  {
13510  With = kFindDivisibleByInS_T(strat, pos, &Ln, &With_s);
13511  if (With == NULL) break;
13512  }
13513  if (normalize && (!TEST_OPT_INTSTRATEGY) && (!nIsOne(pGetCoeff(With->p))))
13514  {
13515  With->pNorm();
13516  //if (TEST_OPT_PROT) { PrintS("n"); mflush(); }
13517  }
13518  strat->redTailChange=TRUE;
13519  if (ksReducePolyTail(L, With, &Ln))
13520  {
13521  // reducing the tail would violate the exp bound
13522  // set a flag and hope for a retry (in bba)
13523  strat->completeReduce_retry=TRUE;
13524  if ((Ln.p != NULL) && (Ln.t_p != NULL)) Ln.p=NULL;
13525  do
13526  {
13527  pNext(h) = Ln.LmExtractAndIter();
13528  pIter(h);
13529  L->pLength++;
13530  } while (!Ln.IsNull());
13531  goto all_done;
13532  }
13533  if (Ln.IsNull()) goto all_done;
13534  if (! withT) With_s.Init(currRing);
13535  }
13536  pNext(h) = Ln.LmExtractAndIter();
13537  pIter(h);
13538  L->pLength++;
13539  }
13540 
13541  all_done:
13542  Ln.Delete();
13543  if (L->p != NULL) pNext(L->p) = pNext(p);
13544 
13545  if (strat->redTailChange)
13546  {
13547  L->length = 0;
13548  }
13549  L->Normalize(); // HANNES: should have a test
13550  kTest_L(L,strat);
13551  return L->GetLmCurrRing();
13552 }

◆ reorderS()

void reorderS ( int *  suc,
kStrategy  strat 
)

Definition at line 4710 of file kutil.cc.

4711 {
4712  int i,j,at,ecart, s2r;
4713  int fq=0;
4714  unsigned long sev;
4715  poly p;
4716  int new_suc=strat->sl+1;
4717  i= *suc;
4718  if (i<0) i=0;
4719 
4720  for (; i<=strat->sl; i++)
4721  {
4722  at = posInS(strat,i-1,strat->S[i],strat->ecartS[i]);
4723  if (at != i)
4724  {
4725  if (new_suc > at) new_suc = at;
4726  p = strat->S[i];
4727  ecart = strat->ecartS[i];
4728  sev = strat->sevS[i];
4729  s2r = strat->S_2_R[i];
4730  if (strat->fromQ!=NULL) fq=strat->fromQ[i];
4731  for (j=i; j>=at+1; j--)
4732  {
4733  strat->S[j] = strat->S[j-1];
4734  strat->ecartS[j] = strat->ecartS[j-1];
4735  strat->sevS[j] = strat->sevS[j-1];
4736  strat->S_2_R[j] = strat->S_2_R[j-1];
4737  }
4738  strat->S[at] = p;
4739  strat->ecartS[at] = ecart;
4740  strat->sevS[at] = sev;
4741  strat->S_2_R[at] = s2r;
4742  if (strat->fromQ!=NULL)
4743  {
4744  for (j=i; j>=at+1; j--)
4745  {
4746  strat->fromQ[j] = strat->fromQ[j-1];
4747  }
4748  strat->fromQ[at]=fq;
4749  }
4750  }
4751  }
4752  if (new_suc <= strat->sl) *suc=new_suc;
4753  else *suc=-1;
4754 }

◆ replaceInLAndSAndT()

void replaceInLAndSAndT ( LObject p,
int  tj,
kStrategy  strat 
)

Definition at line 9359 of file kutil.cc.

9360 {
9361  p.GetP(strat->lmBin);
9362  if (strat->homog) strat->initEcart(&p);
9363  strat->redTailChange=FALSE;
9365  {
9366  p.pCleardenom();
9368  {
9369 #ifdef HAVE_SHIFTBBA
9370  if (rIsLPRing(currRing))
9371  p.p = redtailBba(&p,strat->tl,strat, TRUE,!TEST_OPT_CONTENTSB);
9372  else
9373 #endif
9374  {
9375  p.p = redtailBba(&p,strat->sl,strat, FALSE,!TEST_OPT_CONTENTSB);
9376  }
9377  p.pCleardenom();
9378  if (strat->redTailChange)
9379  p.t_p=NULL;
9380  if (strat->P.p!=NULL) strat->P.sev=p_GetShortExpVector(strat->P.p,currRing);
9381  else strat->P.sev=0;
9382  }
9383  }
9384 
9385  assume(strat->tailRing == p.tailRing);
9386  assume(p.pLength == 0 || pLength(p.p) == p.pLength || rIsSyzIndexRing(currRing)); // modulo syzring
9387 
9388  int i, j, pos;
9389  poly tp = strat->T[tj].p;
9390 
9391  /* enter p to T set */
9392  enterT(p, strat);
9393 
9394  for (j = 0; j <= strat->sl; ++j)
9395  {
9396  if (pLtCmp(tp, strat->S[j]) == 0)
9397  {
9398  break;
9399  }
9400  }
9401  /* it may be that the exchanged element
9402  * is until now only in T and not in S */
9403  if (j <= strat->sl)
9404  {
9405  deleteInS(j, strat);
9406  }
9407 
9408  pos = posInS(strat, strat->sl, p.p, p.ecart);
9409 
9410  pp_Test(p.p, currRing, p.tailRing);
9411  assume(p.FDeg == p.pFDeg());
9412 
9413  /* remove useless pairs from L set */
9414  for (i = 0; i <= strat->Ll; ++i)
9415  {
9416  if (strat->L[i].p1 != NULL && pLtCmp(tp, strat->L[i].p1) == 0)
9417  {
9418  deleteInL(strat->L, &(strat->Ll), i, strat);
9419  i--;
9420  continue;
9421  }
9422  if (strat->L[i].p2 != NULL && pLtCmp(tp, strat->L[i].p2) == 0)
9423  {
9424  deleteInL(strat->L, &(strat->Ll), i, strat);
9425  i--;
9426  }
9427  }
9428 #ifdef HAVE_SHIFTBBA
9429  if (rIsLPRing(currRing))
9430  enterpairsShift(p.p, strat->sl, p.ecart, pos, strat, strat->tl); // TODO LP
9431  else
9432 #endif
9433  {
9434  /* generate new pairs with p, probably removing older, now useless pairs */
9435  superenterpairs(p.p, strat->sl, p.ecart, pos, strat, strat->tl);
9436  }
9437  /* enter p to S set */
9438  strat->enterS(p, pos, strat, strat->tl);
9439 
9440 #ifdef HAVE_SHIFTBBA
9441  /* do this after enterS so that the index in R (which is strat->tl) is correct */
9442  if (rIsLPRing(currRing) && !strat->rightGB)
9443  enterTShift(p,strat);
9444 #endif
9445 }
omBin lmBin
Definition: kutil.h:344
void enterTShift(LObject p, kStrategy strat, int atT)
Definition: kutil.cc:13450
void enterpairsShift(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
Definition: kutil.cc:13420
void superenterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
Definition: kutil.cc:4556

◆ sbaCheckGcdPair()

BOOLEAN sbaCheckGcdPair ( LObject h,
kStrategy  strat 
)

Definition at line 1780 of file kutil.cc.

1781 {
1782  if(strat->sl < 0) return FALSE;
1783  int i;
1784  for(i=0;i<strat->sl;i++)
1785  {
1786  //Construct the gcd pair between h and S[i]
1787  number d, s, t;
1788  poly m1, m2, gcd;
1789  d = n_ExtGcd(pGetCoeff(h->p), pGetCoeff(strat->S[i]), &s, &t, currRing->cf);
1790  if (nIsZero(s) || nIsZero(t)) // evtl. durch divBy tests ersetzen
1791  {
1792  nDelete(&d);
1793  nDelete(&s);
1794  nDelete(&t);
1795  }
1796  else
1797  {
1798  k_GetStrongLeadTerms(h->p, strat->S[i], currRing, m1, m2, gcd, strat->tailRing);
1799  pSetCoeff0(m1, s);
1800  pSetCoeff0(m2, t);
1801  pSetCoeff0(gcd, d);
1802  pNext(gcd) = p_Add_q(pp_Mult_mm(pNext(h->p), m1, strat->tailRing), pp_Mult_mm(pNext(strat->S[i]), m2, strat->tailRing), strat->tailRing);
1803  poly pSigMult = p_Copy(h->sig,currRing);
1804  poly sSigMult = p_Copy(strat->sig[i],currRing);
1805  pSigMult = p_Mult_mm(pSigMult,m1,currRing);
1806  sSigMult = p_Mult_mm(sSigMult,m2,currRing);
1807  p_LmDelete(m1, strat->tailRing);
1808  p_LmDelete(m2, strat->tailRing);
1809  poly pairsig = p_Add_q(pSigMult,sSigMult,currRing);
1810  if(pairsig!= NULL && pLtCmp(pairsig,h->sig) == 0)
1811  {
1812  pDelete(&h->p);
1813  h->p = gcd;
1814  pDelete(&h->sig);
1815  h->sig = pairsig;
1816  pNext(h->sig) = NULL;
1817  strat->initEcart(h);
1818  h->sev = pGetShortExpVector(h->p);
1819  h->sevSig = pGetShortExpVector(h->sig);
1820  h->i_r1 = -1;h->i_r2 = -1;
1821  if(h->lcm != NULL)
1822  {
1823  pLmDelete(h->lcm);
1824  h->lcm = NULL;
1825  }
1826  if (currRing!=strat->tailRing)
1827  h->t_p = k_LmInit_currRing_2_tailRing(h->p, strat->tailRing);
1828  return TRUE;
1829  }
1830  //Delete what you didn't use
1831  pDelete(&gcd);
1832  pDelete(&pairsig);
1833  }
1834  }
1835  return FALSE;
1836 }

◆ sbaRing()

ring sbaRing ( kStrategy  strat,
const ring  r,
BOOLEAN  complete,
int  sgn 
)

Definition at line 11415 of file kutil.cc.

11416 {
11417  int n = rBlocks(r); // Including trailing zero!
11418  // if sbaOrder == 1 => use (C,monomial order from r)
11419  if (strat->sbaOrder == 1)
11420  {
11421  if (r->order[0] == ringorder_C || r->order[0] == ringorder_c)
11422  {
11423  return r;
11424  }
11425  ring res = rCopy0(r, TRUE, FALSE);
11426  res->order = (rRingOrder_t *)omAlloc0((n+1)*sizeof(rRingOrder_t));
11427  res->block0 = (int *)omAlloc0((n+1)*sizeof(int));
11428  res->block1 = (int *)omAlloc0((n+1)*sizeof(int));
11429  int **wvhdl = (int **)omAlloc0((n+1)*sizeof(int*));
11430  res->wvhdl = wvhdl;
11431  for (int i=1; i<n; i++)
11432  {
11433  res->order[i] = r->order[i-1];
11434  res->block0[i] = r->block0[i-1];
11435  res->block1[i] = r->block1[i-1];
11436  res->wvhdl[i] = r->wvhdl[i-1];
11437  }
11438 
11439  // new 1st block
11440  res->order[0] = ringorder_C; // Prefix
11441  // removes useless secondary component order if defined in old ring
11442  for (int i=rBlocks(res); i>0; --i)
11443  {
11444  if (res->order[i] == ringorder_C || res->order[i] == ringorder_c)
11445  {
11446  res->order[i] = (rRingOrder_t)0;
11447  }
11448  }
11449  rComplete(res, 1);
11450 #ifdef HAVE_PLURAL
11451  if (rIsPluralRing(r))
11452  {
11453  if ( nc_rComplete(r, res, false) ) // no qideal!
11454  {
11455 #ifndef SING_NDEBUG
11456  WarnS("error in nc_rComplete");
11457 #endif
11458  // cleanup?
11459 
11460  // rDelete(res);
11461  // return r;
11462 
11463  // just go on..
11464  }
11465  }
11466 #endif
11467  strat->tailRing = res;
11468  return (res);
11469  }
11470  // if sbaOrder == 3 => degree - position - ring order
11471  if (strat->sbaOrder == 3)
11472  {
11473  ring res = rCopy0(r, TRUE, FALSE);
11474  res->order = (rRingOrder_t*)omAlloc0((n+2)*sizeof(rRingOrder_t));
11475  res->block0 = (int *)omAlloc0((n+2)*sizeof(int));
11476  res->block1 = (int *)omAlloc0((n+2)*sizeof(int));
11477  int **wvhdl = (int **)omAlloc0((n+2)*sizeof(int*));
11478  res->wvhdl = wvhdl;
11479  for (int i=2; i<n+2; i++)
11480  {
11481  res->order[i] = r->order[i-2];
11482  res->block0[i] = r->block0[i-2];
11483  res->block1[i] = r->block1[i-2];
11484  res->wvhdl[i] = r->wvhdl[i-2];
11485  }
11486 
11487  // new 1st block
11488  res->order[0] = ringorder_a; // Prefix
11489  res->block0[0] = 1;
11490  res->wvhdl[0] = (int *)omAlloc(res->N*sizeof(int));
11491  for (int i=0; i<res->N; ++i)
11492  res->wvhdl[0][i] = 1;
11493  res->block1[0] = si_min(res->N, rVar(res));
11494  // new 2nd block
11495  res->order[1] = ringorder_C; // Prefix
11496  res->wvhdl[1] = NULL;
11497  // removes useless secondary component order if defined in old ring
11498  for (int i=rBlocks(res); i>1; --i)
11499  {
11500  if (res->order[i] == ringorder_C || res->order[i] == ringorder_c)
11501  {
11502  res->order[i] = (rRingOrder_t)0;
11503  }
11504  }
11505  rComplete(res, 1);
11506 #ifdef HAVE_PLURAL
11507  if (rIsPluralRing(r))
11508  {
11509  if ( nc_rComplete(r, res, false) ) // no qideal!
11510  {
11511 #ifndef SING_NDEBUG
11512  WarnS("error in nc_rComplete");
11513 #endif
11514  // cleanup?
11515 
11516  // rDelete(res);
11517  // return r;
11518 
11519  // just go on..
11520  }
11521  }
11522 #endif
11523  strat->tailRing = res;
11524  return (res);
11525  }
11526 
11527  // not sbaOrder == 1 => use Schreyer order
11528  // this is done by a trick when initializing the signatures
11529  // in initSLSba():
11530  // Instead of using the signature 1e_i for F->m[i], we start
11531  // with the signature LM(F->m[i])e_i for F->m[i]. Doing this we get a
11532  // Schreyer order w.r.t. the underlying monomial order.
11533  // => we do not need to change the underlying polynomial ring at all!
11534 
11535  // UPDATE/NOTE/TODO: use induced Schreyer ordering 'IS'!!!!????
11536 
11537  /*
11538  else
11539  {
11540  ring res = rCopy0(r, FALSE, FALSE);
11541  // Create 2 more blocks for prefix/suffix:
11542  res->order=(int *)omAlloc0((n+2)*sizeof(int)); // 0 .. n+1
11543  res->block0=(int *)omAlloc0((n+2)*sizeof(int));
11544  res->block1=(int *)omAlloc0((n+2)*sizeof(int));
11545  int ** wvhdl =(int **)omAlloc0((n+2)*sizeof(int**));
11546 
11547  // Encapsulate all existing blocks between induced Schreyer ordering markers: prefix and suffix!
11548  // Note that prefix and suffix have the same ringorder marker and only differ in block[] parameters!
11549 
11550  // new 1st block
11551  int j = 0;
11552  res->order[j] = ringorder_IS; // Prefix
11553  res->block0[j] = res->block1[j] = 0;
11554  // wvhdl[j] = NULL;
11555  j++;
11556 
11557  for(int i = 0; (i < n) && (r->order[i] != 0); i++, j++) // i = [0 .. n-1] <- non-zero old blocks
11558  {
11559  res->order [j] = r->order [i];
11560  res->block0[j] = r->block0[i];
11561  res->block1[j] = r->block1[i];
11562 
11563  if (r->wvhdl[i] != NULL)
11564  {
11565  wvhdl[j] = (int*) omMemDup(r->wvhdl[i]);
11566  } // else wvhdl[j] = NULL;
11567  }
11568 
11569  // new last block
11570  res->order [j] = ringorder_IS; // Suffix
11571  res->block0[j] = res->block1[j] = sgn; // Sign of v[o]: 1 for C, -1 for c
11572  // wvhdl[j] = NULL;
11573  j++;
11574 
11575  // res->order [j] = 0; // The End!
11576  res->wvhdl = wvhdl;
11577 
11578  // j == the last zero block now!
11579  assume(j == (n+1));
11580  assume(res->order[0]==ringorder_IS);
11581  assume(res->order[j-1]==ringorder_IS);
11582  assume(res->order[j]==0);
11583 
11584  if (complete)
11585  {
11586  rComplete(res, 1);
11587 
11588 #ifdef HAVE_PLURAL
11589  if (rIsPluralRing(r))
11590  {
11591  if ( nc_rComplete(r, res, false) ) // no qideal!
11592  {
11593  }
11594  }
11595  assume(rIsPluralRing(r) == rIsPluralRing(res));
11596 #endif
11597 
11598 
11599 #ifdef HAVE_PLURAL
11600  ring old_ring = r;
11601 
11602 #endif
11603 
11604  if (r->qideal!=NULL)
11605  {
11606  res->qideal= idrCopyR_NoSort(r->qideal, r, res);
11607 
11608  assume(idRankFreeModule(res->qideal, res) == 0);
11609 
11610 #ifdef HAVE_PLURAL
11611  if( rIsPluralRing(res) )
11612  if( nc_SetupQuotient(res, r, true) )
11613  {
11614  // WarnS("error in nc_SetupQuotient"); // cleanup? rDelete(res); return r; // just go on...?
11615  }
11616 
11617 #endif
11618  assume(idRankFreeModule(res->qideal, res) == 0);
11619  }
11620 
11621 #ifdef HAVE_PLURAL
11622  assume((res->qideal==NULL) == (old_ring->qideal==NULL));
11623  assume(rIsPluralRing(res) == rIsPluralRing(old_ring));
11624  assume(rIsSCA(res) == rIsSCA(old_ring));
11625  assume(ncRingType(res) == ncRingType(old_ring));
11626 #endif
11627  }
11628  strat->tailRing = res;
11629  return res;
11630  }
11631  */
11632 
11633  assume(FALSE);
11634  return(NULL);
11635 }
#define WarnS
Definition: emacs.cc:78
CanonicalForm res
Definition: facAbsFact.cc:60
BOOLEAN nc_rComplete(const ring src, ring dest, bool bSetupQuotient)
Definition: ring.cc:5786
static int rBlocks(const ring r)
Definition: ring.h:569
rRingOrder_t
order stuff
Definition: ring.h:68
@ ringorder_a
Definition: ring.h:70

◆ showOption()

char* showOption ( )

Definition at line 709 of file misc_ip.cc.

710 {
711  int i;
712  BITSET tmp;
713 
714  StringSetS("//options:");
715  if ((si_opt_1!=0)||(si_opt_2!=0))
716  {
717  tmp=si_opt_1;
718  if(tmp)
719  {
720  for (i=0; optionStruct[i].setval!=0; i++)
721  {
722  if (optionStruct[i].setval & tmp)
723  {
725  tmp &=optionStruct[i].resetval;
726  }
727  }
728  for (i=0; i<32; i++)
729  {
730  if (tmp & Sy_bit(i)) StringAppend(" %d",i);
731  }
732  }
733  tmp=si_opt_2;
734  if (tmp)
735  {
736  for (i=0; verboseStruct[i].setval!=0; i++)
737  {
738  if (verboseStruct[i].setval & tmp)
739  {
741  tmp &=verboseStruct[i].resetval;
742  }
743  }
744  for (i=1; i<32; i++)
745  {
746  if (tmp & Sy_bit(i)) StringAppend(" %d",i+32);
747  }
748  }
749  return StringEndS();
750  }
751  StringAppendS(" none");
752  return StringEndS();
753 }
#define StringAppend
Definition: emacs.cc:79
char name(const Variable &v)
Definition: factory.h:189
unsigned resetval
Definition: ipid.h:154
unsigned setval
Definition: ipid.h:153
const struct soptionStruct verboseStruct[]
Definition: misc_ip.cc:538
const struct soptionStruct optionStruct[]
Definition: misc_ip.cc:507
VAR unsigned si_opt_2
Definition: options.c:6
VAR unsigned si_opt_1
Definition: options.c:5
#define Sy_bit(x)
Definition: options.h:31
void StringSetS(const char *st)
Definition: reporter.cc:128
void StringAppendS(const char *st)
Definition: reporter.cc:107
char * StringEndS()
Definition: reporter.cc:151
#define BITSET
Definition: structs.h:16

◆ sugarDivisibleBy()

static BOOLEAN sugarDivisibleBy ( int  ecart1,
int  ecart2 
)
inlinestatic

Definition at line 1417 of file kutil.cc.

1418 {
1419  return (ecart1 <= ecart2);
1420 }

◆ superenterpairs()

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

Definition at line 4556 of file kutil.cc.

4557 {
4559 #if HAVE_SHIFTBBA
4560  assume(!rIsLPRing(currRing)); /* LP should use enterpairsShift */
4561 #endif
4562  // enter also zero divisor * poly, if this is non zero and of smaller degree
4563  if (!(rField_is_Domain(currRing))) enterExtendedSpoly(h, strat);
4564  initenterstrongPairs(h, k, ecart, 0, strat, atR);
4565  initenterpairs(h, k, ecart, 0, strat, atR);
4566  clearSbatch(h, k, pos, strat);
4567 }
void clearSbatch(poly h, int k, int pos, kStrategy strat)
Definition: kutil.cc:4530
void initenterstrongPairs(poly h, int k, int ecart, int isFromQ, kStrategy strat, int atR=-1)
Definition: kutil.cc:4247
void enterExtendedSpoly(poly h, kStrategy strat)
Definition: kutil.cc:4329
static BOOLEAN rField_is_Domain(const ring r)
Definition: ring.h:488

◆ superenterpairsSig()

void superenterpairsSig ( poly  h,
poly  hSig,
int  hFrom,
int  k,
int  ecart,
int  pos,
kStrategy  strat,
int  atR 
)

Definition at line 4569 of file kutil.cc.

4570 {
4572  // enter also zero divisor * poly, if this is non zero and of smaller degree
4573  if (!(rField_is_Domain(currRing))) enterExtendedSpolySig(h, hSig, strat);
4574  if(strat->sigdrop) return;
4575  initenterpairsSigRing(h, hSig, hFrom, k, ecart, 0, strat, atR);
4576  if(strat->sigdrop) return;
4577  initenterstrongPairsSig(h, hSig, k, ecart, 0, strat, atR);
4578  if(strat->sigdrop) return;
4579  clearSbatch(h, k, pos, strat);
4580 }
void initenterpairsSigRing(poly h, poly hSig, int hFrom, int k, int ecart, int isFromQ, kStrategy strat, int atR=-1)
Definition: kutil.cc:4027
static void initenterstrongPairsSig(poly h, poly hSig, int k, int ecart, int isFromQ, kStrategy strat, int atR=-1)
Definition: kutil.cc:4302
void enterExtendedSpolySig(poly h, poly hSig, kStrategy strat)
Definition: kutil.cc:4412

◆ syzCriterion()

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

Definition at line 6786 of file kutil.cc.

6787 {
6788 //#if 1
6789 #ifdef DEBUGF5
6790  PrintS("syzygy criterion checks: ");
6791  pWrite(sig);
6792 #endif
6793  for (int k=0; k<strat->syzl; k++)
6794  {
6795  //printf("-%d",k);
6796 //#if 1
6797 #ifdef DEBUGF5
6798  Print("checking with: %d / %d -- \n",k,strat->syzl);
6799  pWrite(pHead(strat->syz[k]));
6800 #endif
6801  if (p_LmShortDivisibleBy(strat->syz[k], strat->sevSyz[k], sig, not_sevSig, currRing)
6802  && (!rField_is_Ring(currRing) ||
6803  (n_DivBy(pGetCoeff(sig), pGetCoeff(strat->syz[k]),currRing->cf) && pLtCmp(sig,strat->syz[k]) == 1)))
6804  {
6805 //#if 1
6806 #ifdef DEBUGF5
6807  PrintS("DELETE!\n");
6808 #endif
6809  strat->nrsyzcrit++;
6810  //printf("- T -\n\n");
6811  return TRUE;
6812  }
6813  }
6814  //printf("- F -\n\n");
6815  return FALSE;
6816 }

◆ syzCriterionInc()

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

Definition at line 6821 of file kutil.cc.

6822 {
6823 //#if 1
6824  if(sig == NULL)
6825  return FALSE;
6826 #ifdef DEBUGF5
6827  PrintS("--- syzygy criterion checks: ");
6828  pWrite(sig);
6829 #endif
6830  int comp = __p_GetComp(sig, currRing);
6831  int min, max;
6832  if (comp<=1)
6833  return FALSE;
6834  else
6835  {
6836  min = strat->syzIdx[comp-2];
6837  //printf("SYZIDX %d/%d\n",strat->syzIdx[comp-2],comp-2);
6838  //printf("SYZIDX %d/%d\n",strat->syzIdx[comp-1],comp-1);
6839  //printf("SYZIDX %d/%d\n",strat->syzIdx[comp],comp);
6840  if (comp == strat->currIdx)
6841  {
6842  max = strat->syzl;
6843  }
6844  else
6845  {
6846  max = strat->syzIdx[comp-1];
6847  }
6848  for (int k=min; k<max; k++)
6849  {
6850 #ifdef F5DEBUG
6851  Print("COMP %d/%d - MIN %d - MAX %d - SYZL %ld\n",comp,strat->currIdx,min,max,strat->syzl);
6852  Print("checking with: %d -- ",k);
6853  pWrite(pHead(strat->syz[k]));
6854 #endif
6855  if (p_LmShortDivisibleBy(strat->syz[k], strat->sevSyz[k], sig, not_sevSig, currRing)
6856  && (!rField_is_Ring(currRing) ||
6857  (n_DivBy(pGetCoeff(sig), pGetCoeff(strat->syz[k]),currRing->cf) && pLtCmp(sig,strat->syz[k]) == 1)))
6858  {
6859  strat->nrsyzcrit++;
6860  return TRUE;
6861  }
6862  }
6863  return FALSE;
6864  }
6865 }
static int min(int a, int b)
Definition: fast_mult.cc:268
static int max(int a, int b)
Definition: fast_mult.cc:264

◆ updateResult()

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

Definition at line 10401 of file kutil.cc.

10402 {
10403  int l;
10404  if (strat->ak>0)
10405  {
10406  for (l=IDELEMS(r)-1;l>=0;l--)
10407  {
10408  if ((r->m[l]!=NULL) && (pGetComp(r->m[l])==0))
10409  {
10410  pDelete(&r->m[l]); // and set it to NULL
10411  }
10412  }
10413  int q;
10414  poly p;
10415  if(!rField_is_Ring(currRing))
10416  {
10417  for (l=IDELEMS(r)-1;l>=0;l--)
10418  {
10419  if ((r->m[l]!=NULL)
10420  //&& (strat->syzComp>0)
10421  //&& (pGetComp(r->m[l])<=strat->syzComp)
10422  )
10423  {
10424  for(q=IDELEMS(Q)-1; q>=0;q--)
10425  {
10426  if ((Q->m[q]!=NULL)
10427  &&(pLmDivisibleBy(Q->m[q],r->m[l])))
10428  {
10429  if (TEST_OPT_REDSB)
10430  {
10431  p=r->m[l];
10432  r->m[l]=kNF(Q,NULL,p);
10433  pDelete(&p);
10434  }
10435  else
10436  {
10437  pDelete(&r->m[l]); // and set it to NULL
10438  }
10439  break;
10440  }
10441  }
10442  }
10443  }
10444  }
10445  #ifdef HAVE_RINGS
10446  else
10447  {
10448  for (l=IDELEMS(r)-1;l>=0;l--)
10449  {
10450  if ((r->m[l]!=NULL)
10451  //&& (strat->syzComp>0)
10452  //&& (pGetComp(r->m[l])<=strat->syzComp)
10453  )
10454  {
10455  for(q=IDELEMS(Q)-1; q>=0;q--)
10456  {
10457  if ((Q->m[q]!=NULL)
10458  &&(pLmDivisibleBy(Q->m[q],r->m[l])))
10459  {
10460  if(n_DivBy(r->m[l]->coef, Q->m[q]->coef, currRing->cf))
10461  {
10462  if (TEST_OPT_REDSB)
10463  {
10464  p=r->m[l];
10465  r->m[l]=kNF(Q,NULL,p);
10466  pDelete(&p);
10467  }
10468  else
10469  {
10470  pDelete(&r->m[l]); // and set it to NULL
10471  }
10472  break;
10473  }
10474  }
10475  }
10476  }
10477  }
10478  }
10479  #endif
10480  }
10481  else
10482  {
10483  int q;
10484  poly p;
10485  BOOLEAN reduction_found=FALSE;
10486  if (!rField_is_Ring(currRing))
10487  {
10488  for (l=IDELEMS(r)-1;l>=0;l--)
10489  {
10490  if (r->m[l]!=NULL)
10491  {
10492  for(q=IDELEMS(Q)-1; q>=0;q--)
10493  {
10494  if ((Q->m[q]!=NULL)&&(pLmEqual(Q->m[q],r->m[l])))
10495  {
10496  if (TEST_OPT_REDSB)
10497  {
10498  p=r->m[l];
10499  r->m[l]=kNF(Q,NULL,p);
10500  pDelete(&p);
10501  reduction_found=TRUE;
10502  }
10503  else
10504  {
10505  pDelete(&r->m[l]); // and set it to NULL
10506  }
10507  break;
10508  }
10509  }
10510  }
10511  }
10512  }
10513  #ifdef HAVE_RINGS
10514  //Also need divisibility of the leading coefficients
10515  else
10516  {
10517  for (l=IDELEMS(r)-1;l>=0;l--)
10518  {
10519  if (r->m[l]!=NULL)
10520  {
10521  for(q=IDELEMS(Q)-1; q>=0;q--)
10522  {
10523  if(n_DivBy(r->m[l]->coef, Q->m[q]->coef, currRing->cf))
10524  {
10525  if ((Q->m[q]!=NULL)&&(pLmEqual(Q->m[q],r->m[l])) && pDivisibleBy(Q->m[q],r->m[l]))
10526  {
10527  if (TEST_OPT_REDSB)
10528  {
10529  p=r->m[l];
10530  r->m[l]=kNF(Q,NULL,p);
10531  pDelete(&p);
10532  reduction_found=TRUE;
10533  }
10534  else
10535  {
10536  pDelete(&r->m[l]); // and set it to NULL
10537  }
10538  break;
10539  }
10540  }
10541  }
10542  }
10543  }
10544  }
10545  #endif
10546  if (/*TEST_OPT_REDSB &&*/ reduction_found)
10547  {
10548  #ifdef HAVE_RINGS
10550  {
10551  for (l=IDELEMS(r)-1;l>=0;l--)
10552  {
10553  if (r->m[l]!=NULL)
10554  {
10555  for(q=IDELEMS(r)-1;q>=0;q--)
10556  {
10557  if ((l!=q)
10558  && (r->m[q]!=NULL)
10559  &&(pLmDivisibleBy(r->m[l],r->m[q]))
10560  &&(n_DivBy(r->m[q]->coef, r->m[l]->coef, currRing->cf))
10561  )
10562  {
10563  //If they are equal then take the one with the smallest length
10564  if(pLmDivisibleBy(r->m[q],r->m[l])
10565  && n_DivBy(r->m[q]->coef, r->m[l]->coef, currRing->cf)
10566  && (pLength(r->m[q]) < pLength(r->m[l]) ||
10567  (pLength(r->m[q]) == pLength(r->m[l]) && nGreaterZero(r->m[q]->coef))))
10568  {
10569  pDelete(&r->m[l]);
10570  break;
10571  }
10572  else
10573  pDelete(&r->m[q]);
10574  }
10575  }
10576  }
10577  }
10578  }
10579  else
10580  #endif
10581  {
10582  for (l=IDELEMS(r)-1;l>=0;l--)
10583  {
10584  if (r->m[l]!=NULL)
10585  {
10586  for(q=IDELEMS(r)-1;q>=0;q--)
10587  {
10588  if ((l!=q)
10589  && (r->m[q]!=NULL)
10590  &&(pLmDivisibleBy(r->m[l],r->m[q]))
10591  )
10592  {
10593  //If they are equal then take the one with the smallest length
10594  if(pLmDivisibleBy(r->m[q],r->m[l])
10595  &&(pLength(r->m[q]) < pLength(r->m[l]) ||
10596  (pLength(r->m[q]) == pLength(r->m[l]) && nGreaterZero(r->m[q]->coef))))
10597  {
10598  pDelete(&r->m[l]);
10599  break;
10600  }
10601  else
10602  pDelete(&r->m[q]);
10603  }
10604  }
10605  }
10606  }
10607  }
10608  }
10609  }
10610  idSkipZeroes(r);
10611 }
poly kNF(ideal F, ideal Q, poly p, int syzComp, int lazyReduce)
Definition: kstd1.cc:3167

◆ updateS()

void updateS ( BOOLEAN  toT,
kStrategy  strat 
)

Definition at line 8866 of file kutil.cc.

8867 {
8868  LObject h;
8869  int i, suc=0;
8870  poly redSi=NULL;
8871  BOOLEAN change,any_change;
8872 // Print("nach initS: updateS start mit sl=%d\n",(strat->sl));
8873 // for (i=0; i<=(strat->sl); i++)
8874 // {
8875 // Print("s%d:",i);
8876 // if (strat->fromQ!=NULL) Print("(Q:%d) ",strat->fromQ[i]);
8877 // pWrite(strat->S[i]);
8878 // }
8879 // Print("currRing->OrdSgn=%d\n", currRing->OrdSgn);
8880  any_change=FALSE;
8882  {
8883  while (suc != -1)
8884  {
8885  i=suc+1;
8886  while (i<=strat->sl)
8887  {
8888  change=FALSE;
8890  any_change = FALSE;
8891  if (((strat->fromQ==NULL) || (strat->fromQ[i]==0)) && (i>0))
8892  {
8893  redSi = pHead(strat->S[i]);
8894  strat->S[i] = redBba(strat->S[i],i-1,strat);
8895  //if ((strat->ak!=0)&&(strat->S[i]!=NULL))
8896  // strat->S[i]=redQ(strat->S[i],i+1,strat); /*reduce S[i] mod Q*/
8897  if (pCmp(redSi,strat->S[i])!=0)
8898  {
8899  change=TRUE;
8900  any_change=TRUE;
8901  #ifdef KDEBUG
8902  if (TEST_OPT_DEBUG)
8903  {
8904  PrintS("reduce:");
8905  wrp(redSi);PrintS(" to ");p_wrp(strat->S[i], currRing, strat->tailRing);PrintLn();
8906  }
8907  #endif
8908  if (TEST_OPT_PROT)
8909  {
8910  if (strat->S[i]==NULL)
8911  PrintS("V");
8912  else
8913  PrintS("v");
8914  mflush();
8915  }
8916  }
8917  pLmDelete(&redSi);
8918  if (strat->S[i]==NULL)
8919  {
8920  deleteInS(i,strat);
8921  i--;
8922  }
8923  else if (change)
8924  {
8926  {
8927  if (TEST_OPT_CONTENTSB)
8928  {
8929  number n;
8930  p_Cleardenom_n(strat->S[i], currRing, n);// also does remove Content
8931  if (!nIsOne(n))
8932  {
8934  denom->n=nInvers(n);
8935  denom->next=DENOMINATOR_LIST;
8936  DENOMINATOR_LIST=denom;
8937  }
8938  nDelete(&n);
8939  }
8940  else
8941  {
8942  strat->S[i]=p_Cleardenom(strat->S[i], currRing);// also does remove Content
8943  }
8944  }
8945  else
8946  {
8947  pNorm(strat->S[i]);
8948  }
8949  strat->sevS[i] = pGetShortExpVector(strat->S[i]);
8950  }
8951  }
8952  i++;
8953  }
8954  if (any_change) reorderS(&suc,strat);
8955  else break;
8956  }
8957  if (toT)
8958  {
8959  for (i=0; i<=strat->sl; i++)
8960  {
8961  if ((strat->fromQ==NULL) || (strat->fromQ[i]==0))
8962  {
8963  h.p = redtailBba(strat->S[i],i-1,strat);
8965  {
8966  h.pCleardenom();// also does remove Content
8967  }
8968  }
8969  else
8970  {
8971  h.p = strat->S[i];
8972  }
8973  strat->initEcart(&h);
8974  if (strat->honey)
8975  {
8976  strat->ecartS[i] = h.ecart;
8977  }
8978  if (strat->sevS[i] == 0) {strat->sevS[i] = pGetShortExpVector(h.p);}
8979  else assume(strat->sevS[i] == pGetShortExpVector(h.p));
8980  h.sev = strat->sevS[i];
8981  /*puts the elements of S also to T*/
8982  strat->initEcart(&h);
8983  /*if (toT) - already checked*/ enterT(h,strat);
8984  strat->S_2_R[i] = strat->tl;
8985 #ifdef HAVE_SHIFTBBA
8986  if (/*(toT) && */(currRing->isLPring))
8987  enterTShift(h, strat);
8988 #endif
8989  }
8990  }
8991  }
8992  else
8993  {
8994  while (suc != -1)
8995  {
8996  i=suc;
8997  while (i<=strat->sl)
8998  {
8999  change=FALSE;
9000  if (((strat->fromQ==NULL) || (strat->fromQ[i]==0)) && (i>0))
9001  {
9002  redSi=pHead((strat->S)[i]);
9003  (strat->S)[i] = redMora((strat->S)[i],i-1,strat);
9004  if ((strat->S)[i]==NULL)
9005  {
9006  deleteInS(i,strat);
9007  i--;
9008  }
9009  else if (pCmp((strat->S)[i],redSi)!=0)
9010  {
9011  any_change=TRUE;
9012  h.p = strat->S[i];
9013  strat->initEcart(&h);
9014  strat->ecartS[i] = h.ecart;
9016  {
9017  if (TEST_OPT_CONTENTSB)
9018  {
9019  number n;
9020  p_Cleardenom_n(strat->S[i], currRing, n);// also does remove Content
9021  if (!nIsOne(n))
9022  {
9024  denom->n=nInvers(n);
9025  denom->next=DENOMINATOR_LIST;
9026  DENOMINATOR_LIST=denom;
9027  }
9028  nDelete(&n);
9029  }
9030  else
9031  {
9032  strat->S[i]=p_Cleardenom(strat->S[i], currRing);// also does remove Content
9033  }
9034  }
9035  else
9036  {
9037  pNorm(strat->S[i]); // == h.p
9038  }
9039  h.sev = pGetShortExpVector(h.p);
9040  strat->sevS[i] = h.sev;
9041  }
9042  pLmDelete(&redSi);
9043  kTest(strat);
9044  }
9045  i++;
9046  }
9047 #ifdef KDEBUG
9048  kTest(strat);
9049 #endif
9050  if (any_change) reorderS(&suc,strat);
9051  else { suc=-1; break; }
9052  if (h.p!=NULL)
9053  {
9054  if (!strat->kAllAxis)
9055  {
9056  /*strat->kAllAxis =*/ HEckeTest(h.p,strat);
9057  }
9058  if (strat->kAllAxis)
9059  newHEdge(strat);
9060  }
9061  }
9062  for (i=0; i<=strat->sl; i++)
9063  {
9064  if ((strat->fromQ==NULL) || (strat->fromQ[i]==0))
9065  {
9066  strat->S[i] = h.p = redtail(strat->S[i],strat->sl,strat);
9067  strat->initEcart(&h);
9068  strat->ecartS[i] = h.ecart;
9069  h.sev = pGetShortExpVector(h.p);
9070  strat->sevS[i] = h.sev;
9071  }
9072  else
9073  {
9074  h.p = strat->S[i];
9075  h.ecart=strat->ecartS[i];
9076  h.sev = strat->sevS[i];
9077  h.length = h.pLength = pLength(h.p);
9078  }
9079  if ((strat->fromQ==NULL) || (strat->fromQ[i]==0))
9080  cancelunit1(&h,&suc,strat->sl,strat);
9081  h.SetpFDeg();
9082  /*puts the elements of S also to T*/
9083  enterT(h,strat);
9084  strat->S_2_R[i] = strat->tl;
9085 #ifdef HAVE_SHIFTBBA
9086  if (currRing->isLPring)
9087  enterTShift(h, strat);
9088 #endif
9089  }
9090  if (suc!= -1) updateS(toT,strat);
9091  }
9092 #ifdef KDEBUG
9093  kTest(strat);
9094 #endif
9095 }
void cancelunit1(LObject *p, int *suc, int index, kStrategy strat)
Definition: kutil.cc:8709
void reorderS(int *suc, kStrategy strat)
Definition: kutil.cc:4710

Variable Documentation

◆ DENOMINATOR_LIST

VAR denominator_list DENOMINATOR_LIST =NULL

Definition at line 84 of file kutil.cc.

◆ HCord

VAR int HCord

Definition at line 246 of file kutil.cc.

◆ Kstd1_deg

VAR int Kstd1_deg

Definition at line 247 of file kutil.cc.

◆ Kstd1_mu

VAR int Kstd1_mu =INT_MAX

Definition at line 248 of file kutil.cc.

◆ sloppy_max

STATIC_VAR BOOLEAN sloppy_max = FALSE

Definition at line 824 of file kutil.cc.