My Project
Data Structures | Macros | Typedefs | Functions | Variables
kutil.h File Reference
#include <string.h>
#include "omalloc/omalloc.h"
#include "omalloc/omallocClass.h"
#include "misc/mylimits.h"
#include "kernel/polys.h"
#include "polys/operations/pShallowCopyDelete.h"
#include "kernel/structs.h"
#include "kernel/GBEngine/kstd1.h"
#include "kernel/GBEngine/kInline.h"
#include "kernel/GBEngine/shiftgb.h"

Go to the source code of this file.

Data Structures

struct  denominator_list_s
 
class  sTObject
 
class  sLObject
 
class  skStrategy
 

Macros

#define HAVE_TAIL_RING
 
#define setmax   128
 
#define setmaxL   ((4096-12)/sizeof(LObject))
 
#define setmaxLinc   ((4096)/sizeof(LObject))
 
#define setmaxT   ((4096-12)/sizeof(TObject))
 
#define setmaxTinc   ((4096)/sizeof(TObject))
 
#define RED_CANONICALIZE   200
 
#define REDNF_CANONICALIZE   60
 
#define REDTAIL_CANONICALIZE   100
 
#define KINLINE
 
#define NO_KINLINE   1
 
#define ALLOW_PROD_CRIT(A)   (!(A)->no_prod_crit)
 

Typedefs

typedef int * intset
 
typedef int64 wlen_type
 
typedef wlen_type * wlen_set
 
typedef class sTObject TObject
 
typedef class sLObject LObject
 
typedef TObject * TSet
 
typedef LObject * LSet
 
typedef denominator_list_s * denominator_list
 

Functions

void deleteHC (poly *p, int *e, int *l, kStrategy strat)
 
void deleteHC (LObject *L, kStrategy strat, BOOLEAN fromNext=FALSE)
 
void deleteInS (int i, kStrategy strat)
 
void cleanT (kStrategy strat)
 
static LSet initL (int nr=setmaxL)
 
void deleteInL (LSet set, int *length, int j, kStrategy strat)
 
void enterL (LSet *set, int *length, int *LSetmax, LObject p, int at)
 
void enterSBba (LObject &p, int atS, kStrategy strat, int atR=-1)
 
void enterSBbaShift (LObject &p, int atS, kStrategy strat, int atR=-1)
 
void enterSSba (LObject &p, int atS, kStrategy strat, int atR=-1)
 
void initEcartPairBba (LObject *Lp, poly f, poly g, int ecartF, int ecartG)
 
void initEcartPairMora (LObject *Lp, poly f, poly g, int ecartF, int ecartG)
 
int posInS (const kStrategy strat, const int length, const poly p, const int ecart_p)
 
int posInSMonFirst (const kStrategy strat, const int length, const poly p)
 
int posInIdealMonFirst (const ideal F, const poly p, int start=0, int end=-1)
 
int posInT0 (const TSet set, const int length, LObject &p)
 
int posInT1 (const TSet set, const int length, LObject &p)
 
int posInT2 (const TSet set, const int length, LObject &p)
 
int posInT11 (const TSet set, const int length, LObject &p)
 
int posInTSig (const TSet set, const int length, LObject &p)
 
int posInT110 (const TSet set, const int length, LObject &p)
 
int posInT13 (const TSet set, const int length, LObject &p)
 
int posInT15 (const TSet set, const int length, LObject &p)
 
int posInT17 (const TSet set, const int length, LObject &p)
 
int posInT17_c (const TSet set, const int length, LObject &p)
 
int posInT19 (const TSet set, const int length, LObject &p)
 
int posInT_EcartpLength (const TSet set, const int length, LObject &p)
 
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)
 
void reorderS (int *suc, kStrategy strat)
 
int posInLF5C (const LSet set, const int length, LObject *L, const kStrategy strat)
 
int posInLSig (const LSet set, const int length, LObject *L, const kStrategy strat)
 
int posInLSigRing (const LSet set, const int length, LObject *L, const kStrategy strat)
 
int posInSyz (const kStrategy strat, const poly sig)
 
int posInL0 (const LSet set, const int length, LObject *L, const kStrategy strat)
 
int posInL11 (const LSet set, const int length, LObject *L, const kStrategy strat)
 
int posInL11Ring (const LSet set, const int length, LObject *L, const kStrategy strat)
 
int posInLF5CRing (const LSet set, int start, const int length, LObject *L, const kStrategy strat)
 
int posInL11Ringls (const LSet set, const int length, LObject *L, const kStrategy strat)
 
int posInL13 (const LSet set, const int length, LObject *L, const kStrategy strat)
 
int posInL15 (const LSet set, const int length, LObject *L, const kStrategy strat)
 
int posInL15Ring (const LSet set, const int length, LObject *L, const kStrategy strat)
 
int posInL17 (const LSet set, const int length, LObject *L, const kStrategy strat)
 
int posInL10 (const LSet set, const int length, LObject *L, const kStrategy strat)
 
int posInL10Ring (const LSet set, const int length, LObject *L, const kStrategy strat)
 
int posInL110 (const LSet set, const int length, LObject *L, const kStrategy strat)
 
KINLINE poly redtailBba (poly p, int end_pos, kStrategy strat, BOOLEAN normalize=FALSE)
 
KINLINE poly redtailBbaBound (poly p, int end_pos, kStrategy strat, int bound, BOOLEAN normalize=FALSE)
 
KINLINE poly redtailBba_Ring (poly p, int end_pos, kStrategy strat)
 
KINLINE poly redtailBba_Z (poly p, int end_pos, kStrategy strat)
 
poly redtailBba_NF (poly p, kStrategy strat)
 
poly redtailBba_Ring (LObject *L, int end_pos, kStrategy strat)
 
poly redtailBba_Z (LObject *L, int end_pos, kStrategy strat)
 
void redtailBbaAlsoLC_Z (LObject *L, int end_pos, kStrategy strat)
 
poly redtailBba (LObject *L, int end_pos, kStrategy strat, BOOLEAN withT=FALSE, BOOLEAN normalize=FALSE)
 
poly redtailBbaBound (LObject *L, int end_pos, kStrategy strat, int bound, BOOLEAN withT=FALSE, BOOLEAN normalize=FALSE)
 
poly redtailSba (LObject *L, int end_pos, kStrategy strat, BOOLEAN withT=FALSE, BOOLEAN normalize=FALSE)
 
poly redtailBba (TObject *T, int end_pos, kStrategy strat)
 
poly redtail (poly p, int end_pos, kStrategy strat)
 
poly redtail (LObject *L, int end_pos, kStrategy strat)
 
poly redNF (poly h, int &max_ind, int nonorm, kStrategy strat)
 
int redNF0 (LObject *P, kStrategy strat)
 
poly redNFTail (poly h, const int sl, kStrategy strat)
 
int redHoney (LObject *h, kStrategy strat)
 
int redHoneyM (LObject *h, kStrategy strat)
 
int redLiftstd (LObject *h, kStrategy strat)
 
int redRing (LObject *h, kStrategy strat)
 
int redRing_Z (LObject *h, kStrategy strat)
 
int redRiloc (LObject *h, kStrategy strat)
 
void enterExtendedSpoly (poly h, kStrategy strat)
 
void enterExtendedSpolySig (poly h, poly hSig, kStrategy strat)
 
void superenterpairs (poly h, int k, int ecart, int pos, kStrategy strat, int atR=-1)
 
void superenterpairsSig (poly h, poly hSig, int hFrom, int k, int ecart, int pos, kStrategy strat, int atR=-1)
 
int redLazy (LObject *h, kStrategy strat)
 
int redHomog (LObject *h, kStrategy strat)
 
int redSig (LObject *h, kStrategy strat)
 
int redSigRing (LObject *h, kStrategy strat)
 
void enterpairsSig (poly h, poly hSig, int from, int k, int ec, int pos, kStrategy strat, int atR=-1)
 
void enterpairs (poly h, int k, int ec, int pos, kStrategy strat, int atR=-1)
 
void entersets (LObject h)
 
void pairs ()
 
BOOLEAN sbaCheckGcdPair (LObject *h, 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 initEcartNormal (TObject *h)
 
void initEcartBBA (TObject *h)
 
void initS (ideal F, ideal Q, kStrategy strat)
 
void initSL (ideal F, ideal Q, kStrategy strat)
 
void initSLSba (ideal F, ideal Q, kStrategy strat)
 
void initSyzRules (kStrategy strat)
 
void updateS (BOOLEAN toT, kStrategy strat)
 
void enterSyz (LObject &p, kStrategy strat, int atT)
 
void enterT (LObject &p, kStrategy strat, int atT=-1)
 
void replaceInLAndSAndT (LObject &p, int tj, kStrategy strat)
 
void enterT_strong (LObject &p, kStrategy strat, int atT=-1)
 
void cancelunit (LObject *p, BOOLEAN inNF=FALSE)
 
void HEckeTest (poly pp, kStrategy strat)
 
void initBuchMoraCrit (kStrategy strat)
 
void initSbaCrit (kStrategy strat)
 
void initHilbCrit (ideal F, ideal Q, intvec **hilb, kStrategy strat)
 
void initBuchMoraPos (kStrategy strat)
 
void initBuchMoraPosRing (kStrategy strat)
 
void initSbaPos (kStrategy strat)
 
void initBuchMora (ideal F, ideal Q, kStrategy strat)
 
void initSbaBuchMora (ideal F, ideal Q, kStrategy strat)
 
void exitBuchMora (kStrategy strat)
 
void exitSba (kStrategy strat)
 
void updateResult (ideal r, ideal Q, kStrategy strat)
 
void completeReduce (kStrategy strat, BOOLEAN withT=FALSE)
 
void kFreeStrat (kStrategy strat)
 
void enterOnePairNormal (int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR)
 
void chainCritNormal (poly p, int ecart, kStrategy strat)
 
void chainCritOpt_1 (poly, int, kStrategy strat)
 
void chainCritSig (poly p, int ecart, kStrategy strat)
 
BOOLEAN homogTest (polyset F, int Fmax)
 
BOOLEAN newHEdge (kStrategy strat)
 
BOOLEAN syzCriterion (poly sig, unsigned long not_sevSig, kStrategy strat)
 
BOOLEAN syzCriterionInc (poly sig, unsigned long not_sevSig, kStrategy strat)
 
KINLINE BOOLEAN arriRewDummy (poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
 
BOOLEAN arriRewCriterion (poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
 
BOOLEAN arriRewCriterionPre (poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
 
BOOLEAN faugereRewCriterion (poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
 
BOOLEAN findMinLMPair (poly sig, unsigned long not_sevSig, kStrategy strat, int start)
 
int kFindInT (poly p, TSet T, int tlength)
 returns index of p in TSet, or -1 if not found More...
 
int kFindInTShift (poly p, TSet T, int tlength)
 
int kFindDivisibleByInT (const kStrategy strat, const LObject *L, const int start=0)
 return -1 if no divisor is found number of first divisor in T, otherwise More...
 
int kFindDivisibleByInT_Z (const kStrategy strat, const LObject *L, const int start=0)
 
int kFindSameLMInT_Z (const kStrategy strat, const LObject *L, const int start=0)
 
int kTestDivisibleByT0_Z (const kStrategy strat, const LObject *L)
 tests if T[0] divides the leading monomial of L, returns -1 if not More...
 
int kFindDivisibleByInS (const kStrategy strat, int *max_ind, LObject *L)
 return -1 if no divisor is found number of first divisor in S, otherwise More...
 
int kFindNextDivisibleByInS (const kStrategy strat, int start, int max_ind, LObject *L)
 
TObject * kFindDivisibleByInS_T (kStrategy strat, int end_pos, LObject *L, TObject *T, long ecart=LONG_MAX)
 
KINLINE TSet initT ()
 
KINLINE TObject ** initR ()
 
KINLINE unsigned long * initsevT ()
 
KINLINE poly k_LmInit_currRing_2_tailRing (poly p, ring tailRing, omBin bin)
 
KINLINE poly k_LmInit_tailRing_2_currRing (poly p, ring tailRing, omBin bin)
 
KINLINE poly k_LmShallowCopyDelete_currRing_2_tailRing (poly p, ring tailRing, omBin bin)
 
KINLINE poly k_LmShallowCopyDelete_tailRing_2_currRing (poly p, ring tailRing, omBin bin)
 
KINLINE poly k_LmInit_currRing_2_tailRing (poly p, ring tailRing)
 
KINLINE poly k_LmInit_tailRing_2_currRing (poly p, ring tailRing)
 
KINLINE poly k_LmShallowCopyDelete_currRing_2_tailRing (poly p, ring tailRing)
 
KINLINE poly k_LmShallowCopyDelete_tailRing_2_currRing (poly p, ring tailRing)
 
KINLINE BOOLEAN k_GetLeadTerms (const poly p1, const poly p2, const ring p_r, poly &m1, poly &m2, const ring m_r)
 
KINLINE void k_GetStrongLeadTerms (const poly p1, const poly p2, const ring leadRing, poly &m1, poly &m2, poly &lcm, const ring taiRing)
 
BOOLEAN kTest (kStrategy strat)
 
BOOLEAN kTest_TS (kStrategy strat)
 
BOOLEAN kTest_L (LObject *L, kStrategy strat, BOOLEAN testp=FALSE, int lpos=-1, TSet T=NULL, int tlength=-1)
 
BOOLEAN kTest_T (TObject *T, kStrategy strat, int tpos=-1, char TN='?')
 
BOOLEAN kTest_S (kStrategy strat)
 
poly kFindZeroPoly (poly input_p, ring leadRing, ring tailRing)
 
ideal bba (ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
 
ideal sba (ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
 
poly kNF2 (ideal F, ideal Q, poly q, kStrategy strat, int lazyReduce)
 
ideal kNF2 (ideal F, ideal Q, ideal q, kStrategy strat, int lazyReduce)
 
poly kNF2Bound (ideal F, ideal Q, poly q, int bound, kStrategy strat, int lazyReduce)
 
ideal kNF2Bound (ideal F, ideal Q, ideal q, int bound, kStrategy strat, int lazyReduce)
 
void initBba (kStrategy strat)
 
void initSba (ideal F, kStrategy strat)
 
void f5c (kStrategy strat, int &olddeg, int &minimcnt, int &hilbeledeg, int &hilbcount, int &srmax, int &lrmax, int &reduc, ideal Q, intvec *w, intvec *hilb)
 
int ksReducePoly (LObject *PR, TObject *PW, poly spNoether=NULL, number *coef=NULL, poly *mon=NULL, kStrategy strat=NULL, BOOLEAN redtail=FALSE)
 
int ksReducePolyZ (LObject *PR, TObject *PW, poly spNoether=NULL, number *coef=NULL, kStrategy strat=NULL)
 
int ksReducePolyLC (LObject *PR, TObject *PW, poly spNoether=NULL, number *coef=NULL, kStrategy strat=NULL)
 
int ksReducePolyGCD (LObject *PR, TObject *PW, poly spNoether=NULL, number *coef=NULL, kStrategy strat=NULL)
 
int ksReducePolyBound (LObject *PR, TObject *PW, int bound, poly spNoether=NULL, number *coef=NULL, kStrategy strat=NULL)
 
int ksReducePolySig (LObject *PR, TObject *PW, long idx, poly spNoether=NULL, number *coef=NULL, kStrategy strat=NULL)
 
int ksReducePolySigRing (LObject *PR, TObject *PW, long idx, poly spNoether=NULL, number *coef=NULL, kStrategy strat=NULL)
 
int ksReducePolyTail (LObject *PR, TObject *PW, poly Current, poly spNoether=NULL)
 
KINLINE int ksReducePolyTail (LObject *PR, TObject *PW, LObject *Red)
 
void ksCreateSpoly (LObject *Pair, poly spNoether=NULL, int use_buckets=0, ring tailRing=currRing, poly m1=NULL, poly m2=NULL, TObject **R=NULL)
 
poly ksCreateShortSpoly (poly p1, poly p2, ring tailRing)
 
KINLINE poly ksOldSpolyRed (poly p1, poly p2, poly spNoether=NULL)
 
KINLINE poly ksOldSpolyRedNew (poly p1, poly p2, poly spNoether=NULL)
 
KINLINE poly ksOldCreateSpoly (poly p1, poly p2, poly spNoether=NULL, ring r=currRing)
 
KINLINE void ksOldSpolyTail (poly p1, poly q, poly q2, poly spNoether, ring r=currRing)
 
BOOLEAN kCheckSpolyCreation (LObject *L, kStrategy strat, poly &m1, poly &m2)
 
BOOLEAN kCheckStrongCreation (int atR, poly m1, int atS, poly m2, kStrategy strat)
 
poly preIntegerCheck (ideal F, ideal Q)
 used for GB over ZZ: look for constant and monomial elements in the ideal background: any known constant element of ideal suppresses intermediate coefficient swell More...
 
void postReduceByMon (LObject *h, kStrategy strat)
 used for GB over ZZ: intermediate reduction by monomial elements background: any known constant element of ideal suppresses intermediate coefficient swell More...
 
void 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=NULL, TObject *T=NULL, unsigned long new_expbound=0)
 
void kStratInitChangeTailRing (kStrategy strat)
 
void kDebugPrint (kStrategy strat)
 Output some debug info about a given strategy. More...
 
ring sbaRing (kStrategy strat, const ring r=currRing, BOOLEAN complete=TRUE, int sgn=1)
 
KINLINE void clearS (poly p, unsigned long p_sev, int *at, int *k, kStrategy strat)
 
static int kFindInL1 (const poly p, const kStrategy strat)
 
void enterTShift (LObject p, kStrategy strat, int atT=-1)
 
BOOLEAN enterOnePairShift (poly q, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int ecartq, int qisFromQ, int shiftcount, int ifromS)
 
void enterpairsShift (poly h, int k, int ecart, int pos, kStrategy strat, int atR)
 
void superenterpairsShift (poly h, int k, int ecart, int pos, kStrategy strat, int atR)
 
poly redtailBbaShift (LObject *L, int pos, kStrategy strat, BOOLEAN withT, BOOLEAN normalize)
 
int redFirstShift (LObject *h, kStrategy strat)
 
ideal bbaShift (ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
 
static void kDeleteLcm (LObject *P)
 
void initenterpairs (poly h, int k, int ecart, int isFromQ, kStrategy strat, int atR=-1)
 

Variables

EXTERN_VAR denominator_list DENOMINATOR_LIST
 
EXTERN_VAR int strat_nr
 
EXTERN_VAR int HCord
 
EXTERN_VAR int(* test_PosInT )(const TSet T, const int tl, LObject &h)
 
EXTERN_VAR int(* test_PosInL )(const LSet set, const int length, LObject *L, const kStrategy strat)
 

Data Structure Documentation

◆ denominator_list_s

struct denominator_list_s

Definition at line 65 of file kutil.h.

Data Fields
number n
denominator_list next

Macro Definition Documentation

◆ ALLOW_PROD_CRIT

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

Definition at line 395 of file kutil.h.

◆ HAVE_TAIL_RING

#define HAVE_TAIL_RING

Definition at line 27 of file kutil.h.

◆ KINLINE

#define KINLINE

Definition at line 49 of file kutil.h.

◆ NO_KINLINE

#define NO_KINLINE   1

Definition at line 50 of file kutil.h.

◆ RED_CANONICALIZE

#define RED_CANONICALIZE   200

Definition at line 36 of file kutil.h.

◆ REDNF_CANONICALIZE

#define REDNF_CANONICALIZE   60

Definition at line 37 of file kutil.h.

◆ REDTAIL_CANONICALIZE

#define REDTAIL_CANONICALIZE   100

Definition at line 38 of file kutil.h.

◆ setmax

#define setmax   128

Definition at line 29 of file kutil.h.

◆ setmaxL

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

Definition at line 30 of file kutil.h.

◆ setmaxLinc

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

Definition at line 31 of file kutil.h.

◆ setmaxT

#define setmaxT   ((4096-12)/sizeof(TObject))

Definition at line 33 of file kutil.h.

◆ setmaxTinc

#define setmaxTinc   ((4096)/sizeof(TObject))

Definition at line 34 of file kutil.h.

Typedef Documentation

◆ denominator_list

typedef denominator_list_s* denominator_list

Definition at line 63 of file kutil.h.

◆ intset

typedef int* intset

Definition at line 53 of file kutil.h.

◆ LObject

typedef class sLObject LObject

Definition at line 58 of file kutil.h.

◆ LSet

typedef LObject* LSet

Definition at line 60 of file kutil.h.

◆ TObject

typedef class sTObject TObject

Definition at line 57 of file kutil.h.

◆ TSet

typedef TObject* TSet

Definition at line 59 of file kutil.h.

◆ wlen_set

typedef wlen_type* wlen_set

Definition at line 55 of file kutil.h.

◆ wlen_type

typedef int64 wlen_type

Definition at line 54 of file kutil.h.

Function Documentation

◆ arriRewCriterion()

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

Definition at line 6664 of file kutil.cc.

6665{
6666 if(rField_is_Ring(currRing))
6667 return FALSE;
6668 poly p1 = pOne();
6669 poly p2 = pOne();
6670 for (int ii=strat->sl; ii>start; ii--)
6671 {
6672 if (p_LmShortDivisibleBy(strat->sig[ii], strat->sevSig[ii], strat->P.sig, ~strat->P.sevSig, currRing))
6673 {
6674 p_ExpVectorSum(p1,strat->P.sig,strat->S[ii],currRing);
6675 p_ExpVectorSum(p2,strat->sig[ii],strat->P.p,currRing);
6676 if (!(pLmCmp(p1,p2) == 1))
6677 {
6678 pDelete(&p1);
6679 pDelete(&p2);
6680 return TRUE;
6681 }
6682 }
6683 }
6684 pDelete(&p1);
6685 pDelete(&p2);
6686 return FALSE;
6687}
TRUE
#define TRUE
Definition: auxiliary.h:100
FALSE
#define FALSE
Definition: auxiliary.h:96
skStrategy::S
polyset S
Definition: kutil.h:306
skStrategy::sevSig
unsigned long * sevSig
Definition: kutil.h:324
skStrategy::sig
polyset sig
Definition: kutil.h:308
skStrategy::P
LObject P
Definition: kutil.h:302
skStrategy::sl
int sl
Definition: kutil.h:348
p_ExpVectorSum
static void p_ExpVectorSum(poly pr, poly p1, poly p2, const ring r)
Definition: p_polys.h:1423
p_LmShortDivisibleBy
static BOOLEAN p_LmShortDivisibleBy(poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, const ring r)
Definition: p_polys.h:1908
currRing
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
pDelete
#define pDelete(p_ptr)
Definition: polys.h:186
pLmCmp
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
Definition: polys.h:105
pOne
#define pOne()
Definition: polys.h:315
rField_is_Ring
#define rField_is_Ring(R)
Definition: ring.h:485

◆ arriRewCriterionPre()

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

Definition at line 6689 of file kutil.cc.

6690{
6691 //Over Rings, there are still some changes to do: considering coeffs
6692 if(rField_is_Ring(currRing))
6693 return FALSE;
6694 int found = -1;
6695 for (int i=strat->Bl; i>-1; i--)
6696 {
6697 if (pLmEqual(strat->B[i].sig,sig))
6698 {
6699 found = i;
6700 break;
6701 }
6702 }
6703 if (found != -1)
6704 {
6705 if (pLmCmp(lm,strat->B[found].GetLmCurrRing()) == -1)
6706 {
6707 deleteInL(strat->B,&strat->Bl,found,strat);
6708 }
6709 else
6710 {
6711 return TRUE;
6712 }
6713 }
6714 poly p1 = pOne();
6715 poly p2 = pOne();
6716 for (int ii=strat->sl; ii>-1; ii--)
6717 {
6718 if (p_LmShortDivisibleBy(strat->sig[ii], strat->sevSig[ii], sig, not_sevSig, currRing))
6719 {
6720 p_ExpVectorSum(p1,sig,strat->S[ii],currRing);
6721 p_ExpVectorSum(p2,strat->sig[ii],lm,currRing);
6722 if (!(pLmCmp(p1,p2) == 1))
6723 {
6724 pDelete(&p1);
6725 pDelete(&p2);
6726 return TRUE;
6727 }
6728 }
6729 }
6730 pDelete(&p1);
6731 pDelete(&p2);
6732 return FALSE;
6733}
i
int i
Definition: cfEzgcd.cc:132
skStrategy::Bl
int Bl
Definition: kutil.h:352
skStrategy::B
LSet B
Definition: kutil.h:328
found
bool found
Definition: facFactorize.cc:55
deleteInL
void deleteInL(LSet set, int *length, int j, kStrategy strat)
Definition: kutil.cc:1215
pLmEqual
#define pLmEqual(p1, p2)
Definition: polys.h:111

◆ arriRewDummy()

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

Definition at line 1264 of file kInline.h.

1265{
1266 return FALSE;
1267}

◆ bba()

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

Definition at line 2642 of file kstd2.cc.

2643{
2644 int red_result = 1;
2645 int olddeg,reduc;
2646 int hilbeledeg=1,hilbcount=0,minimcnt=0;
2647 BOOLEAN withT = FALSE;
2648 BITSET save;
2649 SI_SAVE_OPT1(save);
2650
2651 initBuchMoraCrit(strat); /*set Gebauer, honey, sugarCrit*/
2652 if(rField_is_Ring(currRing))
2653 initBuchMoraPosRing(strat);
2654 else
2655 initBuchMoraPos(strat);
2656 initHilbCrit(F,Q,&hilb,strat);
2657 initBba(strat);
2658 /*set enterS, spSpolyShort, reduce, red, initEcart, initEcartPair*/
2659 /*Shdl=*/initBuchMora(F, Q,strat);
2660 if (strat->minim>0) strat->M=idInit(IDELEMS(F),F->rank);
2661 reduc = olddeg = 0;
2662
2663#ifndef NO_BUCKETS
2664 if (!TEST_OPT_NOT_BUCKETS)
2665 strat->use_buckets = 1;
2666#endif
2667 // redtailBBa against T for inhomogeneous input
2668 if (!TEST_OPT_OLDSTD)
2669 withT = ! strat->homog;
2670
2671 // strat->posInT = posInT_pLength;
2672 kTest_TS(strat);
2673
2674#ifdef HAVE_TAIL_RING
2675 if(!idIs0(F) &&(!rField_is_Ring(currRing))) // create strong gcd poly computes with tailring and S[i] ->to be fixed
2676 kStratInitChangeTailRing(strat);
2677#endif
2678 if (BVERBOSE(23))
2679 {
2680 if (test_PosInT!=NULL) strat->posInT=test_PosInT;
2681 if (test_PosInL!=NULL) strat->posInL=test_PosInL;
2682 kDebugPrint(strat);
2683 }
2684
2685
2686#ifdef KDEBUG
2687 //kDebugPrint(strat);
2688#endif
2689 /* compute------------------------------------------------------- */
2690 while (strat->Ll >= 0)
2691 {
2692 #ifdef KDEBUG
2693 if (TEST_OPT_DEBUG) messageSets(strat);
2694 #endif
2695 if (siCntrlc)
2696 {
2697 while (strat->Ll >= 0)
2698 deleteInL(strat->L,&strat->Ll,strat->Ll,strat);
2699 strat->noClearS=TRUE;
2700 }
2701 if (TEST_OPT_DEGBOUND
2702 && ((strat->honey && (strat->L[strat->Ll].ecart+currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg))
2703 || ((!strat->honey) && (currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg))))
2704 {
2705 /*
2706 *stops computation if
2707 * 24 IN test and the degree +ecart of L[strat->Ll] is bigger then
2708 *a predefined number Kstd1_deg
2709 */
2710 while ((strat->Ll >= 0)
2711 && (strat->L[strat->Ll].p1!=NULL) && (strat->L[strat->Ll].p2!=NULL)
2712 && ((strat->honey && (strat->L[strat->Ll].ecart+currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg))
2713 || ((!strat->honey) && (currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg)))
2714 )
2715 deleteInL(strat->L,&strat->Ll,strat->Ll,strat);
2716 if (strat->Ll<0) break;
2717 else strat->noClearS=TRUE;
2718 }
2719 if (strat->Ll== 0) strat->interpt=TRUE;
2720 /* picks the last element from the lazyset L */
2721 strat->P = strat->L[strat->Ll];
2722 strat->Ll--;
2723
2724 if (pNext(strat->P.p) == strat->tail)
2725 {
2726 // deletes the short spoly
2727 if (rField_is_Ring(currRing))
2728 pLmDelete(strat->P.p);
2729 else
2730 pLmFree(strat->P.p);
2731 strat->P.p = NULL;
2732 poly m1 = NULL, m2 = NULL;
2733
2734 // check that spoly creation is ok
2735 while (strat->tailRing != currRing &&
2736 !kCheckSpolyCreation(&(strat->P), strat, m1, m2))
2737 {
2738 assume(m1 == NULL && m2 == NULL);
2739 // if not, change to a ring where exponents are at least
2740 // large enough
2741 if (!kStratChangeTailRing(strat))
2742 {
2743 WerrorS("OVERFLOW...");
2744 break;
2745 }
2746 }
2747 // create the real one
2748 ksCreateSpoly(&(strat->P), NULL, strat->use_buckets,
2749 strat->tailRing, m1, m2, strat->R);
2750 }
2751 else if (strat->P.p1 == NULL)
2752 {
2753 if (strat->minim > 0)
2754 strat->P.p2=p_Copy(strat->P.p, currRing, strat->tailRing);
2755 // for input polys, prepare reduction
2756 strat->P.PrepareRed(strat->use_buckets);
2757 }
2758
2759 if ((strat->P.p == NULL) && (strat->P.t_p == NULL))
2760 {
2761 red_result = 0;
2762 }
2763 else
2764 {
2765 if (TEST_OPT_PROT)
2766 message((strat->honey ? strat->P.ecart : 0) + strat->P.pFDeg(),
2767 &olddeg,&reduc,strat, red_result);
2768
2769 /* reduction of the element chosen from L */
2770 red_result = strat->red(&strat->P,strat);
2771 if (errorreported) break;
2772 }
2773
2774 if (strat->overflow)
2775 {
2776 if (!kStratChangeTailRing(strat)) { WerrorS("OVERFLOW.."); break;}
2777 }
2778
2779 // reduction to non-zero new poly
2780 if (red_result == 1)
2781 {
2782 // get the polynomial (canonicalize bucket, make sure P.p is set)
2783 strat->P.GetP(strat->lmBin);
2784 // in the homogeneous case FDeg >= pFDeg (sugar/honey)
2785 // but now, for entering S, T, we reset it
2786 // in the inhomogeneous case: FDeg == pFDeg
2787 if (strat->homog) strat->initEcart(&(strat->P));
2788
2789 /* statistic */
2790 if (TEST_OPT_PROT) PrintS("s");
2791
2792 int pos=posInS(strat,strat->sl,strat->P.p,strat->P.ecart);
2793
2794 // reduce the tail and normalize poly
2795 // in the ring case we cannot expect LC(f) = 1,
2796 strat->redTailChange=FALSE;
2797
2798 /* if we are computing over Z we always want to try and cut down
2799 * the coefficients in the tail terms */
2800 if (rField_is_Z(currRing) && !rHasLocalOrMixedOrdering(currRing))
2801 {
2802 redtailBbaAlsoLC_Z(&(strat->P), strat->tl, strat);
2803 }
2804
2805 if (TEST_OPT_INTSTRATEGY)
2806 {
2807 strat->P.pCleardenom();
2808 if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
2809 {
2810 strat->P.p = redtailBba(&(strat->P),pos-1,strat, withT,!TEST_OPT_CONTENTSB);
2811 strat->P.pCleardenom();
2812 if (strat->redTailChange) { strat->P.t_p=NULL; }
2813 }
2814 }
2815 else
2816 {
2817 strat->P.pNorm();
2818 if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
2819 {
2820 strat->P.p = redtailBba(&(strat->P),pos-1,strat, withT);
2821 if (strat->redTailChange) { strat->P.t_p=NULL; }
2822 }
2823 }
2824
2825#ifdef KDEBUG
2826 if (TEST_OPT_DEBUG){PrintS("new s:");strat->P.wrp();PrintLn();}
2827#endif /* KDEBUG */
2828
2829 // min_std stuff
2830 if ((strat->P.p1==NULL) && (strat->minim>0))
2831 {
2832 if (strat->minim==1)
2833 {
2834 strat->M->m[minimcnt]=p_Copy(strat->P.p,currRing,strat->tailRing);
2835 p_Delete(&strat->P.p2, currRing, strat->tailRing);
2836 }
2837 else
2838 {
2839 strat->M->m[minimcnt]=strat->P.p2;
2840 strat->P.p2=NULL;
2841 }
2842 if (strat->tailRing!=currRing && pNext(strat->M->m[minimcnt])!=NULL)
2843 pNext(strat->M->m[minimcnt])
2844 = strat->p_shallow_copy_delete(pNext(strat->M->m[minimcnt]),
2845 strat->tailRing, currRing,
2846 currRing->PolyBin);
2847 minimcnt++;
2848 }
2849
2850 // enter into S, L, and T
2851 if (((!TEST_OPT_IDLIFT) || (pGetComp(strat->P.p) <= strat->syzComp))
2852 && ((!TEST_OPT_IDELIM) || (p_Deg(strat->P.p,currRing) > 0)))
2853 {
2854 strat->P.SetShortExpVector();
2855 enterT(strat->P, strat);
2856 if (rField_is_Ring(currRing))
2857 superenterpairs(strat->P.p,strat->sl,strat->P.ecart,pos,strat, strat->tl);
2858 else
2859 enterpairs(strat->P.p,strat->sl,strat->P.ecart,pos,strat, strat->tl);
2860 // posInS only depends on the leading term
2861 strat->enterS(strat->P, pos, strat, strat->tl);
2862#if 0
2863 int pl=pLength(strat->P.p);
2864 if (pl==1)
2865 {
2866 //if (TEST_OPT_PROT)
2867 //PrintS("<1>");
2868 }
2869 else if (pl==2)
2870 {
2871 //if (TEST_OPT_PROT)
2872 //PrintS("<2>");
2873 }
2874#endif
2875 }
2876 if (hilb!=NULL) khCheck(Q,w,hilb,hilbeledeg,hilbcount,strat);
2877// Print("[%d]",hilbeledeg);
2878 kDeleteLcm(&strat->P);
2879 if (strat->s_poly!=NULL)
2880 {
2881 // the only valid entries are: strat->P.p,
2882 // strat->tailRing (read-only, keep it)
2883 // (and P->p1, P->p2 (read-only, must set to NULL if P.p is changed)
2884 if (strat->s_poly(strat))
2885 {
2886 // we are called AFTER enterS, i.e. if we change P
2887 // we have to add it also to S/T
2888 // and add pairs
2889 int pos=posInS(strat,strat->sl,strat->P.p,strat->P.ecart);
2890 enterT(strat->P, strat);
2891 if (rField_is_Ring(currRing))
2892 superenterpairs(strat->P.p,strat->sl,strat->P.ecart,pos,strat, strat->tl);
2893 else
2894 enterpairs(strat->P.p,strat->sl,strat->P.ecart,pos,strat, strat->tl);
2895 strat->enterS(strat->P, pos, strat, strat->tl);
2896 }
2897 }
2898 }
2899 else if (strat->P.p1 == NULL && strat->minim > 0)
2900 {
2901 p_Delete(&strat->P.p2, currRing, strat->tailRing);
2902 }
2903
2904#ifdef KDEBUG
2905 memset(&(strat->P), 0, sizeof(strat->P));
2906#endif /* KDEBUG */
2907 kTest_TS(strat);
2908 }
2909#ifdef KDEBUG
2910 if (TEST_OPT_DEBUG) messageSets(strat);
2911#endif /* KDEBUG */
2912
2913 if (TEST_OPT_SB_1)
2914 {
2915 if(!rField_is_Ring(currRing))
2916 {
2917 int k=1;
2918 int j;
2919 while(k<=strat->sl)
2920 {
2921 j=0;
2922 loop
2923 {
2924 if (j>=k) break;
2925 clearS(strat->S[j],strat->sevS[j],&k,&j,strat);
2926 j++;
2927 }
2928 k++;
2929 }
2930 }
2931 }
2932 /* complete reduction of the standard basis--------- */
2933 if (TEST_OPT_REDSB)
2934 {
2935 completeReduce(strat);
2936 if (strat->completeReduce_retry)
2937 {
2938 // completeReduce needed larger exponents, retry
2939 // to reduce with S (instead of T)
2940 // and in currRing (instead of strat->tailRing)
2941#ifdef HAVE_TAIL_RING
2942 if(currRing->bitmask>strat->tailRing->bitmask)
2943 {
2944 strat->completeReduce_retry=FALSE;
2945 cleanT(strat);strat->tailRing=currRing;
2946 int i;
2947 for(i=strat->sl;i>=0;i--) strat->S_2_R[i]=-1;
2948 completeReduce(strat);
2949 }
2950 if (strat->completeReduce_retry)
2951#endif
2952 Werror("exponent bound is %ld",currRing->bitmask);
2953 }
2954 }
2955 else if (TEST_OPT_PROT) PrintLn();
2956 /* release temp data-------------------------------- */
2957 exitBuchMora(strat);
2958 /* postprocessing for GB over ZZ --------------------*/
2959 if (!errorreported)
2960 {
2961 if(rField_is_Z(currRing))
2962 {
2963 for(int i = 0;i<=strat->sl;i++)
2964 {
2965 if(!nGreaterZero(pGetCoeff(strat->S[i])))
2966 {
2967 strat->S[i] = pNeg(strat->S[i]);
2968 }
2969 }
2970 finalReduceByMon(strat);
2971 for(int i = 0;i<IDELEMS(strat->Shdl);i++)
2972 {
2973 if(!nGreaterZero(pGetCoeff(strat->Shdl->m[i])))
2974 {
2975 strat->S[i] = pNeg(strat->Shdl->m[i]);
2976 }
2977 }
2978 }
2979 //else if (rField_is_Ring(currRing))
2980 // finalReduceByMon(strat);
2981 }
2982// if (TEST_OPT_WEIGHTM)
2983// {
2984// pRestoreDegProcs(currRing,pFDegOld, pLDegOld);
2985// if (ecartWeights)
2986// {
2987// omFreeSize((ADDRESS)ecartWeights,((currRing->N)+1)*sizeof(short));
2988// ecartWeights=NULL;
2989// }
2990// }
2991 if ((TEST_OPT_PROT) || (TEST_OPT_DEBUG)) messageStat(hilbcount,strat);
2992 SI_RESTORE_OPT1(save);
2993 /* postprocessing for GB over Q-rings ------------------*/
2994 if ((Q!=NULL)&&(!errorreported)) updateResult(strat->Shdl,Q,strat);
2995
2996 idTest(strat->Shdl);
2997
2998 return (strat->Shdl);
2999}
BOOLEAN
int BOOLEAN
Definition: auxiliary.h:87
k
int k
Definition: cfEzgcd.cc:99
skStrategy::S_2_R
int * S_2_R
Definition: kutil.h:342
skStrategy::tailRing
ring tailRing
Definition: kutil.h:343
skStrategy::Ll
int Ll
Definition: kutil.h:351
skStrategy::lmBin
omBin lmBin
Definition: kutil.h:344
skStrategy::honey
char honey
Definition: kutil.h:377
skStrategy::syzComp
unsigned syzComp
Definition: kutil.h:354
skStrategy::minim
int minim
Definition: kutil.h:357
skStrategy::R
TObject ** R
Definition: kutil.h:340
skStrategy::M
ideal M
Definition: kutil.h:305
skStrategy::tl
int tl
Definition: kutil.h:350
skStrategy::tail
poly tail
Definition: kutil.h:334
skStrategy::posInL
int(* posInL)(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.h:284
skStrategy::Shdl
ideal Shdl
Definition: kutil.h:303
skStrategy::p_shallow_copy_delete
pShallowCopyDeleteProc p_shallow_copy_delete
Definition: kutil.h:338
skStrategy::enterS
void(* enterS)(LObject &h, int pos, kStrategy strat, int atR)
Definition: kutil.h:286
skStrategy::use_buckets
char use_buckets
Definition: kutil.h:383
skStrategy::interpt
char interpt
Definition: kutil.h:371
skStrategy::redTailChange
char redTailChange
Definition: kutil.h:399
skStrategy::completeReduce_retry
char completeReduce_retry
Definition: kutil.h:403
skStrategy::initEcart
void(* initEcart)(TObject *L)
Definition: kutil.h:280
skStrategy::noClearS
char noClearS
Definition: kutil.h:402
skStrategy::overflow
char overflow
Definition: kutil.h:404
skStrategy::L
LSet L
Definition: kutil.h:327
skStrategy::posInT
int(* posInT)(const TSet T, const int tl, LObject &h)
Definition: kutil.h:281
skStrategy::red
int(* red)(LObject *L, kStrategy strat)
Definition: kutil.h:278
skStrategy::sevS
unsigned long * sevS
Definition: kutil.h:322
skStrategy::homog
char homog
Definition: kutil.h:372
skStrategy::s_poly
s_poly_proc_t s_poly
Definition: kutil.h:300
w
const CanonicalForm & w
Definition: facAbsFact.cc:51
j
int j
Definition: facHensel.cc:110
errorreported
VAR short errorreported
Definition: feFopen.cc:23
WerrorS
void WerrorS(const char *s)
Definition: feFopen.cc:24
idIs0
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
Definition: simpleideals.cc:917
idTest
#define idTest(id)
Definition: ideals.h:47
Q
STATIC_VAR jList * Q
Definition: janet.cc:30
redtailBba
KINLINE poly redtailBba(poly p, int pos, kStrategy strat, BOOLEAN normalize)
Definition: kInline.h:1214
clearS
KINLINE void clearS(poly p, unsigned long p_sev, int *at, int *k, kStrategy strat)
Definition: kInline.h:1239
khCheck
void khCheck(ideal Q, intvec *w, intvec *hilb, int &eledeg, int &count, kStrategy strat)
Definition: khstd.cc:28
ksCreateSpoly
void ksCreateSpoly(LObject *Pair, poly spNoether, int use_buckets, ring tailRing, poly m1, poly m2, TObject **R)
Definition: kspoly.cc:1208
initBba
void initBba(kStrategy strat)
Definition: kstd1.cc:1689
Kstd1_deg
EXTERN_VAR int Kstd1_deg
Definition: kstd1.h:49
test_PosInL
VAR int(* test_PosInL)(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kstd2.cc:83
kDebugPrint
void kDebugPrint(kStrategy strat)
Definition: kutil.cc:11560
test_PosInT
VAR int(* test_PosInT)(const TSet T, const int tl, LObject &h)
Definition: kstd2.cc:82
message
void message(int i, int *reduc, int *olddeg, kStrategy strat, int red_result)
Definition: kutil.cc:7512
initBuchMora
void initBuchMora(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:9800
enterT
void enterT(LObject &p, kStrategy strat, int atT)
Definition: kutil.cc:9178
kTest_TS
BOOLEAN kTest_TS(kStrategy strat)
Definition: kutil.cc:1073
enterpairs
void enterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
Definition: kutil.cc:4509
redtailBbaAlsoLC_Z
void redtailBbaAlsoLC_Z(LObject *L, int end_pos, kStrategy strat)
Definition: kutil.cc:7188
initHilbCrit
void initHilbCrit(ideal, ideal, intvec **hilb, kStrategy strat)
Definition: kutil.cc:9458
initBuchMoraPos
void initBuchMoraPos(kStrategy strat)
Definition: kutil.cc:9627
kStratChangeTailRing
BOOLEAN kStratChangeTailRing(kStrategy strat, LObject *L, TObject *T, unsigned long expbound)
Definition: kutil.cc:11021
exitBuchMora
void exitBuchMora(kStrategy strat)
Definition: kutil.cc:9885
posInS
int posInS(const kStrategy strat, const int length, const poly p, const int ecart_p)
Definition: kutil.cc:4685
kCheckSpolyCreation
BOOLEAN kCheckSpolyCreation(LObject *L, kStrategy strat, poly &m1, poly &m2)
Definition: kutil.cc:10534
cleanT
void cleanT(kStrategy strat)
Definition: kutil.cc:565
updateResult
void updateResult(ideal r, ideal Q, kStrategy strat)
Definition: kutil.cc:10128
superenterpairs
void superenterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
Definition: kutil.cc:4478
kStratInitChangeTailRing
void kStratInitChangeTailRing(kStrategy strat)
Definition: kutil.cc:11114
initBuchMoraCrit
void initBuchMoraCrit(kStrategy strat)
Definition: kutil.cc:9476
completeReduce
void completeReduce(kStrategy strat, BOOLEAN withT)
Definition: kutil.cc:10340
initBuchMoraPosRing
void initBuchMoraPosRing(kStrategy strat)
Definition: kutil.cc:9713
messageSets
void messageSets(kStrategy strat)
Definition: kutil.cc:7585
messageStat
void messageStat(int hilbcount, kStrategy strat)
Definition: kutil.cc:7553
finalReduceByMon
void finalReduceByMon(kStrategy strat)
used for GB over ZZ: final reduction by constant elements background: any known constant element of i...
Definition: kutil.cc:10928
kDeleteLcm
static void kDeleteLcm(LObject *P)
Definition: kutil.h:880
assume
#define assume(x)
Definition: mod2.h:389
pNext
#define pNext(p)
Definition: monomials.h:36
pGetCoeff
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
nGreaterZero
#define nGreaterZero(n)
Definition: numbers.h:27
NULL
#define NULL
Definition: omList.c:12
siCntrlc
VAR BOOLEAN siCntrlc
Definition: options.c:14
TEST_OPT_IDLIFT
#define TEST_OPT_IDLIFT
Definition: options.h:130
TEST_OPT_INTSTRATEGY
#define TEST_OPT_INTSTRATEGY
Definition: options.h:111
BVERBOSE
#define BVERBOSE(a)
Definition: options.h:35
TEST_OPT_REDTAIL
#define TEST_OPT_REDTAIL
Definition: options.h:117
SI_SAVE_OPT1
#define SI_SAVE_OPT1(A)
Definition: options.h:21
SI_RESTORE_OPT1
#define SI_RESTORE_OPT1(A)
Definition: options.h:24
TEST_OPT_OLDSTD
#define TEST_OPT_OLDSTD
Definition: options.h:124
TEST_OPT_REDSB
#define TEST_OPT_REDSB
Definition: options.h:105
TEST_OPT_DEGBOUND
#define TEST_OPT_DEGBOUND
Definition: options.h:114
TEST_OPT_SB_1
#define TEST_OPT_SB_1
Definition: options.h:120
TEST_OPT_PROT
#define TEST_OPT_PROT
Definition: options.h:104
TEST_OPT_IDELIM
#define TEST_OPT_IDELIM
Definition: options.h:131
TEST_OPT_DEBUG
#define TEST_OPT_DEBUG
Definition: options.h:109
TEST_OPT_CONTENTSB
#define TEST_OPT_CONTENTSB
Definition: options.h:128
TEST_OPT_NOT_BUCKETS
#define TEST_OPT_NOT_BUCKETS
Definition: options.h:106
p_Deg
long p_Deg(poly a, const ring r)
Definition: p_polys.cc:587
pLength
static int pLength(poly a)
Definition: p_polys.h:188
p_Delete
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:899
p_Copy
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition: p_polys.h:844
pNeg
#define pNeg(p)
Definition: polys.h:198
pGetComp
#define pGetComp(p)
Component.
Definition: polys.h:37
pLmDelete
#define pLmDelete(p)
assume p != NULL, deletes Lm(p)->coef and Lm(p)
Definition: polys.h:76
pLmFree
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
PrintS
void PrintS(const char *s)
Definition: reporter.cc:284
PrintLn
void PrintLn()
Definition: reporter.cc:310
Werror
void Werror(const char *fmt,...)
Definition: reporter.cc:189
rField_is_Z
static BOOLEAN rField_is_Z(const ring r)
Definition: ring.h:509
rHasLocalOrMixedOrdering
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
Definition: ring.h:760
idInit
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35
IDELEMS
#define IDELEMS(i)
Definition: simpleideals.h:23
BITSET
#define BITSET
Definition: structs.h:16
loop
#define loop
Definition: structs.h:75

◆ bbaShift()

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

Definition at line 4608 of file kstd2.cc.

4609{
4610 int red_result = 1;
4611 int olddeg,reduc;
4612 int hilbeledeg=1,hilbcount=0,minimcnt=0;
4613 BOOLEAN withT = TRUE; // currently only T contains the shifts
4614 BITSET save;
4615 SI_SAVE_OPT1(save);
4616
4617 initBuchMoraCrit(strat); /*set Gebauer, honey, sugarCrit*/
4618 if(rField_is_Ring(currRing))
4619 initBuchMoraPosRing(strat);
4620 else
4621 initBuchMoraPos(strat);
4622 initHilbCrit(F,Q,&hilb,strat);
4623 initBba(strat);
4624 /*set enterS, spSpolyShort, reduce, red, initEcart, initEcartPair*/
4625 /*Shdl=*/initBuchMora(F, Q,strat);
4626 if (strat->minim>0) strat->M=idInit(IDELEMS(F),F->rank);
4627 reduc = olddeg = 0;
4628
4629#ifndef NO_BUCKETS
4630 if (!TEST_OPT_NOT_BUCKETS)
4631 strat->use_buckets = 1;
4632#endif
4633 // redtailBBa against T for inhomogeneous input
4634 // if (!TEST_OPT_OLDSTD)
4635 // withT = ! strat->homog;
4636
4637 // strat->posInT = posInT_pLength;
4638 kTest_TS(strat);
4639
4640#ifdef HAVE_TAIL_RING
4641 // if(!idIs0(F) &&(!rField_is_Ring(currRing))) // create strong gcd poly computes with tailring and S[i] ->to be fixed
4642 // kStratInitChangeTailRing(strat);
4643 strat->tailRing=currRing;
4644#endif
4645 if (BVERBOSE(23))
4646 {
4647 if (test_PosInT!=NULL) strat->posInT=test_PosInT;
4648 if (test_PosInL!=NULL) strat->posInL=test_PosInL;
4649 kDebugPrint(strat);
4650 }
4651
4652#ifdef KDEBUG
4653 //kDebugPrint(strat);
4654#endif
4655 /* compute------------------------------------------------------- */
4656 while (strat->Ll >= 0)
4657 {
4658 #ifdef KDEBUG
4659 if (TEST_OPT_DEBUG) messageSets(strat);
4660 #endif
4661 if (siCntrlc)
4662 {
4663 while (strat->Ll >= 0)
4664 deleteInL(strat->L,&strat->Ll,strat->Ll,strat);
4665 strat->noClearS=TRUE;
4666 }
4667 if (TEST_OPT_DEGBOUND
4668 && ((strat->honey && (strat->L[strat->Ll].ecart+currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg))
4669 || ((!strat->honey) && (currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg))))
4670 {
4671 /*
4672 *stops computation if
4673 * 24 IN test and the degree +ecart of L[strat->Ll] is bigger then
4674 *a predefined number Kstd1_deg
4675 */
4676 while ((strat->Ll >= 0)
4677 && (strat->L[strat->Ll].p1!=NULL) && (strat->L[strat->Ll].p2!=NULL)
4678 && ((strat->honey && (strat->L[strat->Ll].ecart+currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg))
4679 || ((!strat->honey) && (currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg)))
4680 )
4681 deleteInL(strat->L,&strat->Ll,strat->Ll,strat);
4682 if (strat->Ll<0) break;
4683 else strat->noClearS=TRUE;
4684 }
4685 if (strat->Ll== 0) strat->interpt=TRUE;
4686 /* picks the last element from the lazyset L */
4687 strat->P = strat->L[strat->Ll];
4688 strat->Ll--;
4689
4690 if (pNext(strat->P.p) == strat->tail)
4691 {
4692 // deletes the short spoly
4693 if (rField_is_Ring(currRing))
4694 pLmDelete(strat->P.p);
4695 else
4696 pLmFree(strat->P.p);
4697 strat->P.p = NULL;
4698 poly m1 = NULL, m2 = NULL;
4699
4700 // check that spoly creation is ok
4701 while (strat->tailRing != currRing &&
4702 !kCheckSpolyCreation(&(strat->P), strat, m1, m2))
4703 {
4704 assume(m1 == NULL && m2 == NULL);
4705 // if not, change to a ring where exponents are at least
4706 // large enough
4707 if (!kStratChangeTailRing(strat))
4708 {
4709 WerrorS("OVERFLOW...");
4710 break;
4711 }
4712 }
4713 // create the real one
4714 ksCreateSpoly(&(strat->P), NULL, strat->use_buckets,
4715 strat->tailRing, m1, m2, strat->R);
4716 }
4717 else if (strat->P.p1 == NULL)
4718 {
4719 if (strat->minim > 0)
4720 strat->P.p2=p_Copy(strat->P.p, currRing, strat->tailRing);
4721 // for input polys, prepare reduction
4722 strat->P.PrepareRed(strat->use_buckets);
4723 }
4724
4725 if ((strat->P.p == NULL) && (strat->P.t_p == NULL))
4726 {
4727 red_result = 0;
4728 }
4729 else
4730 {
4731 if (TEST_OPT_PROT)
4732 message((strat->honey ? strat->P.ecart : 0) + strat->P.pFDeg(),
4733 &olddeg,&reduc,strat, red_result);
4734
4735 /* reduction of the element chosen from L */
4736 red_result = strat->red(&strat->P,strat);
4737 if (errorreported) break;
4738 }
4739
4740 if (strat->overflow)
4741 {
4742 if (!kStratChangeTailRing(strat)) { WerrorS("OVERFLOW.."); break;}
4743 }
4744
4745 // reduction to non-zero new poly
4746 if (red_result == 1)
4747 {
4748 // get the polynomial (canonicalize bucket, make sure P.p is set)
4749 strat->P.GetP(strat->lmBin);
4750 // in the homogeneous case FDeg >= pFDeg (sugar/honey)
4751 // but now, for entering S, T, we reset it
4752 // in the inhomogeneous case: FDeg == pFDeg
4753 if (strat->homog) strat->initEcart(&(strat->P));
4754
4755 /* statistic */
4756 if (TEST_OPT_PROT) PrintS("s");
4757
4758 int pos=posInS(strat,strat->sl,strat->P.p,strat->P.ecart);
4759
4760 // reduce the tail and normalize poly
4761 // in the ring case we cannot expect LC(f) = 1,
4762 strat->redTailChange=FALSE;
4763
4764 /* if we are computing over Z we always want to try and cut down
4765 * the coefficients in the tail terms */
4766 if (rField_is_Z(currRing) && !rHasLocalOrMixedOrdering(currRing))
4767 {
4768 redtailBbaAlsoLC_Z(&(strat->P), strat->tl, strat);
4769 }
4770
4771 if (TEST_OPT_INTSTRATEGY)
4772 {
4773 strat->P.pCleardenom();
4774 if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
4775 {
4776 strat->P.p = redtailBba(&(strat->P),pos-1,strat, withT,!TEST_OPT_CONTENTSB);
4777 strat->P.pCleardenom();
4778 if (strat->redTailChange)
4779 {
4780 strat->P.t_p=NULL;
4781 strat->initEcart(&(strat->P)); // somehow we need this here with letterplace
4782 }
4783 }
4784 }
4785 else
4786 {
4787 strat->P.pNorm();
4788 if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
4789 {
4790 strat->P.p = redtailBba(&(strat->P),pos-1,strat, withT);
4791 if (strat->redTailChange)
4792 {
4793 strat->P.t_p=NULL;
4794 strat->initEcart(&(strat->P)); // somehow we need this here with letterplace
4795 }
4796 }
4797 }
4798
4799#ifdef KDEBUG
4800 if (TEST_OPT_DEBUG){PrintS("new s:");strat->P.wrp();PrintLn();}
4801#endif /* KDEBUG */
4802
4803 // min_std stuff
4804 if ((strat->P.p1==NULL) && (strat->minim>0))
4805 {
4806 if (strat->minim==1)
4807 {
4808 strat->M->m[minimcnt]=p_Copy(strat->P.p,currRing,strat->tailRing);
4809 p_Delete(&strat->P.p2, currRing, strat->tailRing);
4810 }
4811 else
4812 {
4813 strat->M->m[minimcnt]=strat->P.p2;
4814 strat->P.p2=NULL;
4815 }
4816 if (strat->tailRing!=currRing && pNext(strat->M->m[minimcnt])!=NULL)
4817 pNext(strat->M->m[minimcnt])
4818 = strat->p_shallow_copy_delete(pNext(strat->M->m[minimcnt]),
4819 strat->tailRing, currRing,
4820 currRing->PolyBin);
4821 minimcnt++;
4822 }
4823
4824
4825 // enter into S, L, and T
4826 if ((!TEST_OPT_IDLIFT) || (pGetComp(strat->P.p) <= strat->syzComp))
4827 {
4828 enterT(strat->P, strat);
4829 enterpairsShift(strat->P.p,strat->sl,strat->P.ecart,pos,strat, strat->tl);
4830 // posInS only depends on the leading term
4831 strat->enterS(strat->P, pos, strat, strat->tl);
4832 if (!strat->rightGB)
4833 enterTShift(strat->P, strat);
4834 }
4835
4836 if (hilb!=NULL) khCheck(Q,w,hilb,hilbeledeg,hilbcount,strat);
4837// Print("[%d]",hilbeledeg);
4838 kDeleteLcm(&strat->P);
4839 if (strat->s_poly!=NULL)
4840 {
4841 // the only valid entries are: strat->P.p,
4842 // strat->tailRing (read-only, keep it)
4843 // (and P->p1, P->p2 (read-only, must set to NULL if P.p is changed)
4844 if (strat->s_poly(strat))
4845 {
4846 // we are called AFTER enterS, i.e. if we change P
4847 // we have to add it also to S/T
4848 // and add pairs
4849 int pos=posInS(strat,strat->sl,strat->P.p,strat->P.ecart);
4850 enterT(strat->P, strat);
4851 enterpairsShift(strat->P.p,strat->sl,strat->P.ecart,pos,strat, strat->tl);
4852 strat->enterS(strat->P, pos, strat, strat->tl);
4853 if (!strat->rightGB)
4854 enterTShift(strat->P,strat);
4855 }
4856 }
4857 }
4858 else if (strat->P.p1 == NULL && strat->minim > 0)
4859 {
4860 p_Delete(&strat->P.p2, currRing, strat->tailRing);
4861 }
4862#ifdef KDEBUG
4863 memset(&(strat->P), 0, sizeof(strat->P));
4864#endif /* KDEBUG */
4865 kTest_TS(strat);
4866 }
4867#ifdef KDEBUG
4868 if (TEST_OPT_DEBUG) messageSets(strat);
4869#endif /* KDEBUG */
4870 /* shift case: look for elt's in S such that they are divisible by elt in T */
4871 if ((TEST_OPT_SB_1 || TEST_OPT_REDSB) && !strat->noClearS) // when is OPT_SB_1 set?
4872 {
4873 if(!rField_is_Ring(currRing))
4874 {
4875 for (int k = 0; k <= strat->sl; ++k)
4876 {
4877 if ((strat->fromQ!=NULL) && (strat->fromQ[k])) continue; // do not reduce Q_k
4878 for (int j = 0; j<=strat->tl; ++j)
4879 {
4880 if (strat->T[j].p!=NULL)
4881 {
4882 // this is like clearS in bba, but we reduce with elements from T, because it contains the shifts too
4883 assume(strat->sevT[j] == pGetShortExpVector(strat->T[j].p));
4884 assume(strat->sevS[k] == pGetShortExpVector(strat->S[k]));
4885 if (pLmShortDivisibleBy(strat->T[j].p, strat->sevT[j], strat->S[k], ~strat->sevS[k]))
4886 {
4887 if (pLmCmp(strat->T[j].p, strat->S[k]) != 0)
4888 { // check whether LM is different
4889 deleteInS(k, strat);
4890 --k;
4891 break;
4892 }
4893 }
4894 }
4895 }
4896 }
4897 }
4898 }
4899 /* complete reduction of the standard basis--------- */
4900 if (TEST_OPT_REDSB)
4901 {
4902 completeReduce(strat, TRUE); //shift: withT = TRUE
4903 if (strat->completeReduce_retry)
4904 {
4905 // completeReduce needed larger exponents, retry
4906 // to reduce with S (instead of T)
4907 // and in currRing (instead of strat->tailRing)
4908#ifdef HAVE_TAIL_RING
4909 if(currRing->bitmask>strat->tailRing->bitmask)
4910 {
4911 strat->completeReduce_retry=FALSE;
4912 cleanT(strat);strat->tailRing=currRing;
4913 int i;
4914 for(i=strat->sl;i>=0;i--) strat->S_2_R[i]=-1;
4915 WarnS("reduction with S is not yet supported by Letterplace"); // if this ever happens, we'll know
4916 completeReduce(strat);
4917 }
4918 if (strat->completeReduce_retry)
4919#endif
4920 Werror("exponent bound is %ld",currRing->bitmask);
4921 }
4922 }
4923 else if (TEST_OPT_PROT) PrintLn();
4924
4925 /* release temp data-------------------------------- */
4926 exitBuchMora(strat);
4927 /* postprocessing for GB over ZZ --------------------*/
4928 if (!errorreported)
4929 {
4930 if(rField_is_Z(currRing))
4931 {
4932 for(int i = 0;i<=strat->sl;i++)
4933 {
4934 if(!nGreaterZero(pGetCoeff(strat->S[i])))
4935 {
4936 strat->S[i] = pNeg(strat->S[i]);
4937 }
4938 }
4939 finalReduceByMon(strat);
4940 for(int i = 0;i<IDELEMS(strat->Shdl);i++)
4941 {
4942 if(!nGreaterZero(pGetCoeff(strat->Shdl->m[i])))
4943 {
4944 strat->S[i] = pNeg(strat->Shdl->m[i]);
4945 }
4946 }
4947 }
4948 //else if (rField_is_Ring(currRing))
4949 // finalReduceByMon(strat);
4950 }
4951// if (TEST_OPT_WEIGHTM)
4952// {
4953// pRestoreDegProcs(currRing,pFDegOld, pLDegOld);
4954// if (ecartWeights)
4955// {
4956// omFreeSize((ADDRESS)ecartWeights,((currRing->N)+1)*sizeof(short));
4957// ecartWeights=NULL;
4958// }
4959// }
4960 if ((TEST_OPT_PROT) || (TEST_OPT_DEBUG)) messageStat(hilbcount,strat);
4961 SI_RESTORE_OPT1(save);
4962 /* postprocessing for GB over Q-rings ------------------*/
4963 if ((Q!=NULL)&&(!errorreported)) updateResult(strat->Shdl,Q,strat);
4964
4965 idTest(strat->Shdl);
4966
4967 return (strat->Shdl);
4968}
skStrategy::T
TSet T
Definition: kutil.h:326
skStrategy::rightGB
char rightGB
Definition: kutil.h:369
skStrategy::sevT
unsigned long * sevT
Definition: kutil.h:325
skStrategy::fromQ
intset fromQ
Definition: kutil.h:321
WarnS
#define WarnS
Definition: emacs.cc:78
enterTShift
void enterTShift(LObject p, kStrategy strat, int atT)
Definition: kutil.cc:13058
enterpairsShift
void enterpairsShift(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
Definition: kutil.cc:13028
deleteInS
void deleteInS(int i, kStrategy strat)
Definition: kutil.cc:1139
pLmShortDivisibleBy
#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
pGetShortExpVector
#define pGetShortExpVector(a)
returns the "Short Exponent Vector" – used to speed up divisibility tests (see polys-impl....
Definition: polys.h:152

◆ cancelunit()

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

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 poly h = pNext(p);
392 int i;
393
394 if(rField_is_Ring(currRing))
395 {
396 loop
397 {
398 if (h==NULL)
399 {
400 p_Delete(&pNext(p), r);
401 if (!inNF)
402 {
403 number eins= nCopy(lc);
404 if (L->p != NULL)
405 {
406 pSetCoeff(L->p,eins);
407 if (L->t_p != NULL)
408 pSetCoeff0(L->t_p,eins);
409 }
410 else
411 pSetCoeff(L->t_p,eins);
412 /* p and t_p share the same coeff, if both are !=NULL */
413 /* p==NULL==t_p cannot happen here */
414 }
415 L->ecart = 0;
416 L->length = 1;
417 //if (L->pLength > 0)
418 L->pLength = 1;
419 L->max_exp = NULL;
420
421 if (L->t_p != NULL && pNext(L->t_p) != NULL)
422 p_Delete(&pNext(L->t_p),r);
423 if (L->p != NULL && pNext(L->p) != NULL)
424 pNext(L->p) = NULL;
425 return;
426 }
427 i = rVar(r);
428 loop
429 {
430 if (p_GetExp(p,i,r) > p_GetExp(h,i,r)) return; // does not divide
431 i--;
432 if (i == 0) break; // does divide, try next monom
433 }
434 //wrp(p); PrintS(" divide ");wrp(h); PrintLn();
435 // Note: As long as qring j forbidden if j contains integer (i.e. ground rings are
436 // domains), no zerodivisor test needed CAUTION
437 if (!n_DivBy(pGetCoeff(h),lc,r->cf))
438 {
439 return;
440 }
441 pIter(h);
442 }
443 }
444 else
445 {
446 loop
447 {
448 if (h==NULL)
449 {
450 p_Delete(&pNext(p), r);
451 if (!inNF)
452 {
453 number eins=nInit(1);
454 if (L->p != NULL)
455 {
456 pSetCoeff(L->p,eins);
457 if (L->t_p != NULL)
458 pSetCoeff0(L->t_p,eins);
459 }
460 else
461 pSetCoeff(L->t_p,eins);
462 /* p and t_p share the same coeff, if both are !=NULL */
463 /* p==NULL==t_p cannot happen here */
464 }
465 L->ecart = 0;
466 L->length = 1;
467 //if (L->pLength > 0)
468 L->pLength = 1;
469 L->max_exp = NULL;
470
471 if (L->t_p != NULL && pNext(L->t_p) != NULL)
472 p_Delete(&pNext(L->t_p),r);
473 if (L->p != NULL && pNext(L->p) != NULL)
474 pNext(L->p) = NULL;
475
476 return;
477 }
478 i = rVar(r);
479 loop
480 {
481 if (p_GetExp(p,i,r) > p_GetExp(h,i,r)) return; // does not divide
482 i--;
483 if (i == 0) break; // does divide, try next monom
484 }
485 //wrp(p); PrintS(" divide ");wrp(h); PrintLn();
486 pIter(h);
487 }
488 }
489}
lc
CanonicalForm lc(const CanonicalForm &f)
Definition: canonicalform.h:304
p
int p
Definition: cfModGcd.cc:4078
n_DivBy
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:750
h
STATIC_VAR Poly * h
Definition: janet.cc:971
p_GetComp
#define p_GetComp(p, r)
Definition: monomials.h:64
pIter
#define pIter(p)
Definition: monomials.h:37
pSetCoeff0
#define pSetCoeff0(p, n)
Definition: monomials.h:59
nCopy
#define nCopy(n)
Definition: numbers.h:15
nInit
#define nInit(i)
Definition: numbers.h:24
TEST_OPT_CANCELUNIT
#define TEST_OPT_CANCELUNIT
Definition: options.h:129
p_OneComp
BOOLEAN p_OneComp(poly p, const ring r)
return TRUE if all monoms have the same component
Definition: p_polys.cc:1208
p_GetExp
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:467
pSetCoeff
#define pSetCoeff(p, n)
deletes old coeff before setting the new one
Definition: polys.h:31
rVar
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:592
rHasGlobalOrdering
BOOLEAN rHasGlobalOrdering(const ring r)
Definition: ring.h:759

◆ chainCritNormal()

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

Definition at line 3217 of file kutil.cc.

3218{
3219 int i,j,l;
3220
3221 /*
3222 *pairtest[i] is TRUE if spoly(S[i],p) == 0.
3223 *In this case all elements in B such
3224 *that their lcm is divisible by the leading term of S[i] can be canceled
3225 */
3226 if (strat->pairtest!=NULL)
3227 {
3228#ifdef HAVE_SHIFTBBA
3229 // only difference is pLPDivisibleBy instead of pDivisibleBy
3230 if (rIsLPRing(currRing))
3231 {
3232 for (j=0; j<=strat->sl; j++)
3233 {
3234 if (strat->pairtest[j])
3235 {
3236 for (i=strat->Bl; i>=0; i--)
3237 {
3238 if (pLPDivisibleBy(strat->S[j],strat->B[i].lcm))
3239 {
3240 deleteInL(strat->B,&strat->Bl,i,strat);
3241 strat->c3++;
3242 }
3243 }
3244 }
3245 }
3246 }
3247 else
3248#endif
3249 {
3250 /*- i.e. there is an i with pairtest[i]==TRUE -*/
3251 for (j=0; j<=strat->sl; j++)
3252 {
3253 if (strat->pairtest[j])
3254 {
3255 for (i=strat->Bl; i>=0; i--)
3256 {
3257 if (pDivisibleBy(strat->S[j],strat->B[i].lcm))
3258 {
3259 deleteInL(strat->B,&strat->Bl,i,strat);
3260 strat->c3++;
3261 }
3262 }
3263 }
3264 }
3265 }
3266 omFreeSize(strat->pairtest,(strat->sl+2)*sizeof(BOOLEAN));
3267 strat->pairtest=NULL;
3268 }
3269 if (strat->Gebauer || strat->fromT)
3270 {
3271 if (strat->sugarCrit)
3272 {
3273 /*
3274 *suppose L[j] == (s,r) and p/lcm(s,r)
3275 *and lcm(s,r)#lcm(s,p) and lcm(s,r)#lcm(r,p)
3276 *and in case the sugar is o.k. then L[j] can be canceled
3277 */
3278 for (j=strat->Ll; j>=0; j--)
3279 {
3280 if (sugarDivisibleBy(ecart,strat->L[j].ecart)
3281 && ((pNext(strat->L[j].p) == strat->tail) || (rHasGlobalOrdering(currRing)))
3282 && pCompareChain(p,strat->L[j].p1,strat->L[j].p2,strat->L[j].lcm))
3283 {
3284 if (strat->L[j].p == strat->tail)
3285 {
3286 deleteInL(strat->L,&strat->Ll,j,strat);
3287 strat->c3++;
3288 }
3289 }
3290 }
3291 /*
3292 *this is GEBAUER-MOELLER:
3293 *in B all elements with the same lcm except the "best"
3294 *(i.e. the last one in B with this property) will be canceled
3295 */
3296 j = strat->Bl;
3297 loop /*cannot be changed into a for !!! */
3298 {
3299 if (j <= 0) break;
3300 i = j-1;
3301 loop
3302 {
3303 if (i < 0) break;
3304 if (pLmEqual(strat->B[j].lcm,strat->B[i].lcm))
3305 {
3306 strat->c3++;
3307 if (sugarDivisibleBy(strat->B[j].ecart,strat->B[i].ecart))
3308 {
3309 deleteInL(strat->B,&strat->Bl,i,strat);
3310 j--;
3311 }
3312 else
3313 {
3314 deleteInL(strat->B,&strat->Bl,j,strat);
3315 break;
3316 }
3317 }
3318 i--;
3319 }
3320 j--;
3321 }
3322 }
3323 else /*sugarCrit*/
3324 {
3325 /*
3326 *suppose L[j] == (s,r) and p/lcm(s,r)
3327 *and lcm(s,r)#lcm(s,p) and lcm(s,r)#lcm(r,p)
3328 *and in case the sugar is o.k. then L[j] can be canceled
3329 */
3330 for (j=strat->Ll; j>=0; j--)
3331 {
3332 if (pCompareChain(p,strat->L[j].p1,strat->L[j].p2,strat->L[j].lcm))
3333 {
3334 if ((pNext(strat->L[j].p) == strat->tail)||(rHasGlobalOrdering(currRing)))
3335 {
3336 deleteInL(strat->L,&strat->Ll,j,strat);
3337 strat->c3++;
3338 }
3339 }
3340 }
3341 /*
3342 *this is GEBAUER-MOELLER:
3343 *in B all elements with the same lcm except the "best"
3344 *(i.e. the last one in B with this property) will be canceled
3345 */
3346 j = strat->Bl;
3347 loop /*cannot be changed into a for !!! */
3348 {
3349 if (j <= 0) break;
3350 for(i=j-1; i>=0; i--)
3351 {
3352 if (pLmEqual(strat->B[j].lcm,strat->B[i].lcm))
3353 {
3354 strat->c3++;
3355 deleteInL(strat->B,&strat->Bl,i,strat);
3356 j--;
3357 }
3358 }
3359 j--;
3360 }
3361 }
3362 /*
3363 *the elements of B enter L
3364 */
3365 kMergeBintoL(strat);
3366 }
3367 else
3368 {
3369 for (j=strat->Ll; j>=0; j--)
3370 {
3371 #ifdef HAVE_SHIFTBBA
3372 if ((strat->L[j].p1!=NULL) &&
3373 pCompareChain(p,strat->L[j].p1,strat->L[j].p2,strat->L[j].lcm))
3374 #else
3375 if (pCompareChain(p,strat->L[j].p1,strat->L[j].p2,strat->L[j].lcm))
3376 #endif
3377 {
3378 if ((pNext(strat->L[j].p) == strat->tail)||(rHasGlobalOrdering(currRing)))
3379 {
3380 deleteInL(strat->L,&strat->Ll,j,strat);
3381 strat->c3++;
3382 }
3383 }
3384 }
3385 /*
3386 *this is our MODIFICATION of GEBAUER-MOELLER:
3387 *First the elements of B enter L,
3388 *then we fix a lcm and the "best" element in L
3389 *(i.e the last in L with this lcm and of type (s,p))
3390 *and cancel all the other elements of type (r,p) with this lcm
3391 *except the case the element (s,r) has also the same lcm
3392 *and is on the worst position with respect to (s,p) and (r,p)
3393 */
3394 /*
3395 *B enters to L/their order with respect to B is permutated for elements
3396 *B[i].p with the same leading term
3397 */
3398 kMergeBintoL(strat);
3399 j = strat->Ll;
3400 loop /*cannot be changed into a for !!! */
3401 {
3402 if (j <= 0)
3403 {
3404 /*now L[0] cannot be canceled any more and the tail can be removed*/
3405 if (strat->L[0].p2 == strat->tail) strat->L[0].p2 = p;
3406 break;
3407 }
3408 if (strat->L[j].p2 == p)
3409 {
3410 i = j-1;
3411 loop
3412 {
3413 if (i < 0) break;
3414 if ((strat->L[i].p2 == p) && pLmEqual(strat->L[j].lcm,strat->L[i].lcm))
3415 {
3416 /*L[i] could be canceled but we search for a better one to cancel*/
3417 strat->c3++;
3418 if (isInPairsetL(i-1,strat->L[j].p1,strat->L[i].p1,&l,strat)
3419 && (pNext(strat->L[l].p) == strat->tail)
3420 && (!pLmEqual(strat->L[i].p,strat->L[l].p))
3421 && pDivisibleBy(p,strat->L[l].lcm))
3422 {
3423 /*
3424 *"NOT equal(...)" because in case of "equal" the element L[l]
3425 *is "older" and has to be from theoretical point of view behind
3426 *L[i], but we do not want to reorder L
3427 */
3428 strat->L[i].p2 = strat->tail;
3429 /*
3430 *L[l] will be canceled, we cannot cancel L[i] later on,
3431 *so we mark it with "tail"
3432 */
3433 deleteInL(strat->L,&strat->Ll,l,strat);
3434 i--;
3435 }
3436 else
3437 {
3438 deleteInL(strat->L,&strat->Ll,i,strat);
3439 }
3440 j--;
3441 }
3442 i--;
3443 }
3444 }
3445 else if (strat->L[j].p2 == strat->tail)
3446 {
3447 /*now L[j] cannot be canceled any more and the tail can be removed*/
3448 strat->L[j].p2 = p;
3449 }
3450 j--;
3451 }
3452 }
3453}
l
int l
Definition: cfEzgcd.cc:100
skStrategy::pairtest
BOOLEAN * pairtest
Definition: kutil.h:333
skStrategy::sugarCrit
char sugarCrit
Definition: kutil.h:377
skStrategy::Gebauer
char Gebauer
Definition: kutil.h:378
skStrategy::fromT
char fromT
Definition: kutil.h:379
skStrategy::c3
int c3
Definition: kutil.h:347
pCompareChain
BOOLEAN pCompareChain(poly p, poly p1, poly p2, poly lcm, const ring R)
Returns TRUE if.
Definition: kpolys.cc:17
kMergeBintoL
void kMergeBintoL(kStrategy strat)
Definition: kutil.cc:3174
sugarDivisibleBy
static BOOLEAN sugarDivisibleBy(int ecart1, int ecart2)
Definition: kutil.cc:1337
isInPairsetL
BOOLEAN isInPairsetL(int length, poly p1, poly p2, int *k, kStrategy strat)
Definition: kutil.cc:702
omFreeSize
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
pDivisibleBy
#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
rIsLPRing
static BOOLEAN rIsLPRing(const ring r)
Definition: ring.h:411
pLPDivisibleBy
#define pLPDivisibleBy(a, b)
Definition: shiftop.h:57

◆ chainCritOpt_1()

void chainCritOpt_1 ( poly  ,
int  ,
kStrategy  strat 
)

Definition at line 3458 of file kutil.cc.

3459{
3460 if (strat->pairtest!=NULL)
3461 {
3462 omFreeSize(strat->pairtest,(strat->sl+2)*sizeof(BOOLEAN));
3463 strat->pairtest=NULL;
3464 }
3465 /*
3466 *the elements of B enter L
3467 */
3468 kMergeBintoL(strat);
3469}

◆ chainCritSig()

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

Definition at line 3474 of file kutil.cc.

3475{
3476 int i,j,l;
3477 kMergeBintoLSba(strat);
3478 j = strat->Ll;
3479 loop /*cannot be changed into a for !!! */
3480 {
3481 if (j <= 0)
3482 {
3483 /*now L[0] cannot be canceled any more and the tail can be removed*/
3484 if (strat->L[0].p2 == strat->tail) strat->L[0].p2 = p;
3485 break;
3486 }
3487 if (strat->L[j].p2 == p)
3488 {
3489 i = j-1;
3490 loop
3491 {
3492 if (i < 0) break;
3493 if ((strat->L[i].p2 == p) && pLmEqual(strat->L[j].lcm,strat->L[i].lcm))
3494 {
3495 /*L[i] could be canceled but we search for a better one to cancel*/
3496 strat->c3++;
3497 if (isInPairsetL(i-1,strat->L[j].p1,strat->L[i].p1,&l,strat)
3498 && (pNext(strat->L[l].p) == strat->tail)
3499 && (!pLmEqual(strat->L[i].p,strat->L[l].p))
3500 && pDivisibleBy(p,strat->L[l].lcm))
3501 {
3502 /*
3503 *"NOT equal(...)" because in case of "equal" the element L[l]
3504 *is "older" and has to be from theoretical point of view behind
3505 *L[i], but we do not want to reorder L
3506 */
3507 strat->L[i].p2 = strat->tail;
3508 /*
3509 *L[l] will be canceled, we cannot cancel L[i] later on,
3510 *so we mark it with "tail"
3511 */
3512 deleteInL(strat->L,&strat->Ll,l,strat);
3513 i--;
3514 }
3515 else
3516 {
3517 deleteInL(strat->L,&strat->Ll,i,strat);
3518 }
3519 j--;
3520 }
3521 i--;
3522 }
3523 }
3524 else if (strat->L[j].p2 == strat->tail)
3525 {
3526 /*now L[j] cannot be canceled any more and the tail can be removed*/
3527 strat->L[j].p2 = p;
3528 }
3529 j--;
3530 }
3531}
kMergeBintoLSba
void kMergeBintoLSba(kStrategy strat)
Definition: kutil.cc:3195

◆ cleanT()

void cleanT ( kStrategy  strat)

Definition at line 565 of file kutil.cc.

566{
567 int i,j;
568 poly p;
569 assume(currRing == strat->tailRing || strat->tailRing != NULL);
570
571 pShallowCopyDeleteProc p_shallow_copy_delete =
572 (strat->tailRing != currRing ?
573 pGetShallowCopyDeleteProc(strat->tailRing, currRing) :
574 NULL);
575 for (j=0; j<=strat->tl; j++)
576 {
577 p = strat->T[j].p;
578 strat->T[j].p=NULL;
579 if (strat->T[j].max_exp != NULL)
580 {
581 p_LmFree(strat->T[j].max_exp, strat->tailRing);
582 }
583 i = -1;
584 loop
585 {
586 i++;
587 if (i>strat->sl)
588 {
589 if (strat->T[j].t_p != NULL)
590 {
591 p_Delete(&(strat->T[j].t_p), strat->tailRing);
592 p_LmFree(p, currRing);
593 }
594 else
595 {
596#ifdef HAVE_SHIFTBBA
597 if (currRing->isLPring && strat->T[j].shift > 0)
598 {
599 pNext(p) = NULL; // pNext(p) points to the unshifted tail, don't try to delete it here
600 }
601#endif
602 pDelete(&p);
603 }
604 break;
605 }
606 if (p == strat->S[i])
607 {
608 if (strat->T[j].t_p != NULL)
609 {
610 if (p_shallow_copy_delete!=NULL)
611 {
612 pNext(p) = p_shallow_copy_delete(pNext(p),strat->tailRing,currRing,
613 currRing->PolyBin);
614 }
615 p_LmFree(strat->T[j].t_p, strat->tailRing);
616 }
617 break;
618 }
619 }
620 }
621 strat->tl=-1;
622}
pGetShallowCopyDeleteProc
pShallowCopyDeleteProc pGetShallowCopyDeleteProc(ring, ring)
Definition: pShallowCopyDelete.cc:50
p_LmFree
static void p_LmFree(poly p, ring)
Definition: p_polys.h:681
pShallowCopyDeleteProc
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

◆ clearS()

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

Definition at line 1239 of file kInline.h.

1241{
1242 assume(p_sev == pGetShortExpVector(p));
1243 if (strat->noClearS) return;
1244 #ifdef HAVE_RINGS
1245 if(rField_is_Ring(currRing))
1246 {
1247 if (!pLmShortDivisibleBy(p,p_sev, strat->S[*at], ~ strat->sevS[*at]))
1248 return;
1249 if(!n_DivBy(pGetCoeff(strat->S[*at]), pGetCoeff(p), currRing->cf))
1250 return;
1251 }
1252 else
1253 #endif
1254 {
1255 if (!pLmShortDivisibleBy(p,p_sev, strat->S[*at], ~ strat->sevS[*at])) return;
1256 }
1257 deleteInS((*at),strat);
1258 (*at)--;
1259 (*k)--;
1260}

◆ completeReduce()

void completeReduce ( kStrategy  strat,
BOOLEAN  withT = FALSE 
)

Definition at line 10340 of file kutil.cc.

10341{
10342 int i;
10343 int low = (((rHasGlobalOrdering(currRing)) && (strat->ak==0)) ? 1 : 0);
10344 LObject L;
10345
10346#ifdef KDEBUG
10347 // need to set this: during tailreductions of T[i], T[i].max is out of
10348 // sync
10349 sloppy_max = TRUE;
10350#endif
10351
10352 strat->noTailReduction = FALSE;
10353 //if(rHasMixedOrdering(currRing)) strat->noTailReduction = TRUE;
10354 if (TEST_OPT_PROT)
10355 {
10356 PrintLn();
10357// if (timerv) writeTime("standard base computed:");
10358 }
10359 if (TEST_OPT_PROT)
10360 {
10361 Print("(S:%d)",strat->sl);mflush();
10362 }
10363 for (i=strat->sl; i>=low; i--)
10364 {
10365 int end_pos=strat->sl;
10366 if ((strat->fromQ!=NULL) && (strat->fromQ[i])) continue; // do not reduce Q_i
10367 if (strat->ak==0) end_pos=i-1;
10368 TObject* T_j = strat->s_2_t(i);
10369 if ((T_j != NULL)&&(T_j->p==strat->S[i]))
10370 {
10371 L = *T_j;
10372 #ifdef KDEBUG
10373 if (TEST_OPT_DEBUG)
10374 {
10375 Print("test S[%d]:",i);
10376 p_wrp(L.p,currRing,strat->tailRing);
10377 PrintLn();
10378 }
10379 #endif
10380 if (rHasGlobalOrdering(currRing))
10381 strat->S[i] = redtailBba(&L, end_pos, strat, withT);
10382 else
10383 strat->S[i] = redtail(&L, strat->sl, strat);
10384 #ifdef KDEBUG
10385 if (TEST_OPT_DEBUG)
10386 {
10387 Print("to (tailR) S[%d]:",i);
10388 p_wrp(strat->S[i],currRing,strat->tailRing);
10389 PrintLn();
10390 }
10391 #endif
10392
10393 if (strat->redTailChange)
10394 {
10395 if (T_j->max_exp != NULL) p_LmFree(T_j->max_exp, strat->tailRing);
10396 if (pNext(T_j->p) != NULL)
10397 T_j->max_exp = p_GetMaxExpP(pNext(T_j->p), strat->tailRing);
10398 else
10399 T_j->max_exp = NULL;
10400 }
10401 if (TEST_OPT_INTSTRATEGY)
10402 T_j->pCleardenom();
10403 }
10404 else
10405 {
10406 assume(currRing == strat->tailRing);
10407 #ifdef KDEBUG
10408 if (TEST_OPT_DEBUG)
10409 {
10410 Print("test S[%d]:",i);
10411 p_wrp(strat->S[i],currRing,strat->tailRing);
10412 PrintLn();
10413 }
10414 #endif
10415 if (rHasGlobalOrdering(currRing))
10416 strat->S[i] = redtailBba(strat->S[i], end_pos, strat, withT);
10417 else
10418 strat->S[i] = redtail(strat->S[i], strat->sl, strat);
10419 if (TEST_OPT_INTSTRATEGY)
10420 {
10421 if (TEST_OPT_CONTENTSB)
10422 {
10423 number n;
10424 p_Cleardenom_n(strat->S[i], currRing, n);// also does remove Content
10425 if (!nIsOne(n))
10426 {
10427 denominator_list denom=(denominator_list)omAlloc(sizeof(denominator_list_s));
10428 denom->n=nInvers(n);
10429 denom->next=DENOMINATOR_LIST;
10430 DENOMINATOR_LIST=denom;
10431 }
10432 nDelete(&n);
10433 }
10434 else
10435 {
10436 strat->S[i]=p_Cleardenom(strat->S[i], currRing);// also does remove Content
10437 }
10438 }
10439 #ifdef KDEBUG
10440 if (TEST_OPT_DEBUG)
10441 {
10442 Print("to (-tailR) S[%d]:",i);
10443 p_wrp(strat->S[i],currRing,strat->tailRing);
10444 PrintLn();
10445 }
10446 #endif
10447 }
10448 if (TEST_OPT_PROT)
10449 PrintS("-");
10450 }
10451 if (TEST_OPT_PROT) PrintLn();
10452#ifdef KDEBUG
10453 sloppy_max = FALSE;
10454#endif
10455}
skStrategy::noTailReduction
char noTailReduction
Definition: kutil.h:378
skStrategy::ak
int ak
Definition: kutil.h:353
skStrategy::s_2_t
KINLINE TObject * s_2_t(int i)
Definition: kInline.h:47
Print
#define Print
Definition: emacs.cc:80
redtail
poly redtail(LObject *L, int end_pos, kStrategy strat)
Definition: kutil.cc:6883
redtailBba
poly redtailBba(LObject *L, int end_pos, kStrategy strat, BOOLEAN withT, BOOLEAN normalize)
Definition: kutil.cc:6959
sloppy_max
STATIC_VAR BOOLEAN sloppy_max
Definition: kutil.cc:800
DENOMINATOR_LIST
VAR denominator_list DENOMINATOR_LIST
Definition: kutil.cc:84
denominator_list
denominator_list_s * denominator_list
Definition: kutil.h:63
denominator_list_s::next
denominator_list next
Definition: kutil.h:65
TObject
class sTObject TObject
Definition: kutil.h:57
LObject
class sLObject LObject
Definition: kutil.h:58
denominator_list_s
Definition: kutil.h:65
nDelete
#define nDelete(n)
Definition: numbers.h:16
nInvers
#define nInvers(a)
Definition: numbers.h:33
nIsOne
#define nIsOne(n)
Definition: numbers.h:25
omAlloc
#define omAlloc(size)
Definition: omAllocDecl.h:210
p_GetMaxExpP
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
p_Cleardenom_n
void p_Cleardenom_n(poly ph, const ring r, number &c)
Definition: p_polys.cc:2950
p_Cleardenom
poly p_Cleardenom(poly p, const ring r)
Definition: p_polys.cc:2841
p_wrp
void p_wrp(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:373
mflush
#define mflush()
Definition: reporter.h:58

◆ deleteHC() [1/2]

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

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}
skStrategy::kNoetherTail
KINLINE poly kNoetherTail()
Definition: kInline.h:66
skStrategy::kNoether
poly kNoether
Definition: kutil.h:329
skStrategy::LDegLast
char LDegLast
Definition: kutil.h:385
kBucketDestroy
void kBucketDestroy(kBucket_pt *bucket_pt)
Definition: kbuckets.cc:216
deleteHCBucket
static void deleteHCBucket(LObject *L, kStrategy strat)
Definition: kutil.cc:250
kTest_L
BOOLEAN kTest_L(LObject *L, kStrategy strat, BOOLEAN testp, int lpos, TSet T, int tlength)
Definition: kutil.cc:926
p_Cmp
static int p_Cmp(poly p1, poly p2, ring r)
Definition: p_polys.h:1725
p_LmCmp
static int p_LmCmp(poly p, poly q, const ring r)
Definition: p_polys.h:1578

◆ 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}
deleteHC
void deleteHC(LObject *L, kStrategy strat, BOOLEAN fromNext)
Definition: kutil.cc:294

◆ deleteInL()

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

Definition at line 1215 of file kutil.cc.

1216{
1217 if (set[j].lcm!=NULL)
1218 {
1219 kDeleteLcm(&set[j]);
1220 }
1221 if (set[j].sig!=NULL)
1222 {
1223#ifdef HAVE_RINGS
1224 if (pGetCoeff(set[j].sig) != NULL)
1225 pLmDelete(set[j].sig);
1226 else
1227#endif
1228 pLmFree(set[j].sig);
1229 }
1230 if (set[j].p!=NULL)
1231 {
1232 if (pNext(set[j].p) == strat->tail)
1233 {
1234#ifdef HAVE_RINGS
1235 if (pGetCoeff(set[j].p) != NULL)
1236 pLmDelete(set[j].p);
1237 else
1238#endif
1239 pLmFree(set[j].p);
1240 /*- tail belongs to several int spolys -*/
1241 }
1242 else
1243 {
1244 // search p in T, if it is there, do not delete it
1245 if (rHasGlobalOrdering(currRing) || (kFindInT(set[j].p, strat) < 0))
1246 {
1247 // assure that for global orderings kFindInT fails
1248 //assume((rHasLocalOrMixedOrdering(currRing)) && (kFindInT(set[j].p, strat) >= 0));
1249 set[j].Delete();
1250 }
1251 }
1252 }
1253 #ifdef HAVE_SHIFTBBA
1254 if (is_shifted_p1(strat->P.p1,strat))
1255 {
1256 // clean up strat->P.p1: may be shifted
1257 pLmDelete(strat->P.p1);
1258 strat->P.p1=NULL;
1259 }
1260 #endif
1261 if (*length > 0 && j < *length)
1262 {
1263#ifdef ENTER_USE_MEMMOVE
1264 memmove(&(set[j]), &(set[j+1]), (*length - j)*sizeof(LObject));
1265#else
1266 int i;
1267 for (i=j; i < (*length); i++)
1268 set[i] = set[i+1];
1269#endif
1270 }
1271#ifdef KDEBUG
1272 memset(&(set[*length]),0,sizeof(LObject));
1273#endif
1274 (*length)--;
1275}
length
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:257
kFindInT
int kFindInT(poly p, TSet T, int tlength)
returns index of p in TSet, or -1 if not found
Definition: kutil.cc:718
is_shifted_p1
static BOOLEAN is_shifted_p1(const poly p, const kStrategy strat)
Definition: kutil.cc:1188
lcm
int lcm(unsigned long *l, unsigned long *a, unsigned long *b, unsigned long p, int dega, int degb)
Definition: minpoly.cc:709

◆ deleteInS()

void deleteInS ( int  i,
kStrategy  strat 
)

Definition at line 1139 of file kutil.cc.

1140{
1141#ifdef ENTER_USE_MEMMOVE
1142 memmove(&(strat->S[i]), &(strat->S[i+1]), (strat->sl - i)*sizeof(poly));
1143 memmove(&(strat->ecartS[i]),&(strat->ecartS[i+1]),(strat->sl - i)*sizeof(int));
1144 memmove(&(strat->sevS[i]),&(strat->sevS[i+1]),(strat->sl - i)*sizeof(unsigned long));
1145 memmove(&(strat->S_2_R[i]),&(strat->S_2_R[i+1]),(strat->sl - i)*sizeof(int));
1146#else
1147 int j;
1148 for (j=i; j<strat->sl; j++)
1149 {
1150 strat->S[j] = strat->S[j+1];
1151 strat->ecartS[j] = strat->ecartS[j+1];
1152 strat->sevS[j] = strat->sevS[j+1];
1153 strat->S_2_R[j] = strat->S_2_R[j+1];
1154 }
1155#endif
1156 if (strat->lenS!=NULL)
1157 {
1158#ifdef ENTER_USE_MEMMOVE
1159 memmove(&(strat->lenS[i]),&(strat->lenS[i+1]),(strat->sl - i)*sizeof(int));
1160#else
1161 for (j=i; j<strat->sl; j++) strat->lenS[j] = strat->lenS[j+1];
1162#endif
1163 }
1164 if (strat->lenSw!=NULL)
1165 {
1166#ifdef ENTER_USE_MEMMOVE
1167 memmove(&(strat->lenSw[i]),&(strat->lenSw[i+1]),(strat->sl - i)*sizeof(wlen_type));
1168#else
1169 for (j=i; j<strat->sl; j++) strat->lenSw[j] = strat->lenSw[j+1];
1170#endif
1171 }
1172 if (strat->fromQ!=NULL)
1173 {
1174#ifdef ENTER_USE_MEMMOVE
1175 memmove(&(strat->fromQ[i]),&(strat->fromQ[i+1]),(strat->sl - i)*sizeof(int));
1176#else
1177 for (j=i; j<strat->sl; j++)
1178 {
1179 strat->fromQ[j] = strat->fromQ[j+1];
1180 }
1181#endif
1182 }
1183 strat->S[strat->sl] = NULL;
1184 strat->sl--;
1185}
skStrategy::lenS
intset lenS
Definition: kutil.h:319
skStrategy::ecartS
intset ecartS
Definition: kutil.h:309
skStrategy::lenSw
wlen_set lenSw
Definition: kutil.h:320
wlen_type
int64 wlen_type
Definition: kutil.h:54

◆ enterExtendedSpoly()

void enterExtendedSpoly ( poly  h,
kStrategy  strat 
)

Definition at line 4249 of file kutil.cc.

4250{
4251 if (nIsOne(pGetCoeff(h))) return;
4252 number gcd;
4253 number zero=n_Init(0,currRing->cf);
4254 bool go = false;
4255 if (n_DivBy(zero, pGetCoeff(h), currRing->cf))
4256 {
4257 gcd = n_Ann(pGetCoeff(h),currRing->cf);
4258 go = true;
4259 }
4260 else
4261 gcd = n_Gcd(zero, pGetCoeff(h), strat->tailRing->cf);
4262 if (go || !nIsOne(gcd))
4263 {
4264 poly p = h->next;
4265 if (!go)
4266 {
4267 number tmp = gcd;
4268 gcd = n_Ann(gcd,currRing->cf);
4269 nDelete(&tmp);
4270 }
4271 p_Test(p,strat->tailRing);
4272 p = __pp_Mult_nn(p, gcd, strat->tailRing);
4273
4274 if (p != NULL)
4275 {
4276 if (TEST_OPT_PROT)
4277 {
4278 PrintS("Z");
4279 }
4280#ifdef KDEBUG
4281 if (TEST_OPT_DEBUG)
4282 {
4283 PrintS("--- create zero spoly: ");
4284 p_wrp(h,currRing,strat->tailRing);
4285 PrintS(" ---> ");
4286 }
4287#endif
4288 poly tmp = pInit();
4289 pSetCoeff0(tmp, pGetCoeff(p));
4290 for (int i = 1; i <= rVar(currRing); i++)
4291 {
4292 pSetExp(tmp, i, p_GetExp(p, i, strat->tailRing));
4293 }
4294 if (rRing_has_Comp(currRing) && rRing_has_Comp(strat->tailRing))
4295 {
4296 p_SetComp(tmp, __p_GetComp(p, strat->tailRing), currRing);
4297 }
4298 p_Setm(tmp, currRing);
4299 p = p_LmFreeAndNext(p, strat->tailRing);
4300 pNext(tmp) = p;
4301 LObject Lp;
4302 Lp.Init();
4303 Lp.p = tmp;
4304 Lp.tailRing = strat->tailRing;
4305 int posx;
4306 if (Lp.p!=NULL)
4307 {
4308 strat->initEcart(&Lp);
4309 if (strat->Ll==-1)
4310 posx =0;
4311 else
4312 posx = strat->posInL(strat->L,strat->Ll,&Lp,strat);
4313 Lp.sev = pGetShortExpVector(Lp.p);
4314 if (strat->tailRing != currRing)
4315 {
4316 Lp.t_p = k_LmInit_currRing_2_tailRing(Lp.p, strat->tailRing);
4317 }
4318#ifdef KDEBUG
4319 if (TEST_OPT_DEBUG)
4320 {
4321 p_wrp(tmp,currRing,strat->tailRing);
4322 PrintLn();
4323 }
4324#endif
4325 enterL(&strat->L,&strat->Ll,&strat->Lmax,Lp,posx);
4326 }
4327 }
4328 }
4329 nDelete(&zero);
4330 nDelete(&gcd);
4331}
skStrategy::Lmax
int Lmax
Definition: kutil.h:351
n_Gcd
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:661
n_Ann
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:676
n_Init
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:535
k_LmInit_currRing_2_tailRing
KINLINE poly k_LmInit_currRing_2_tailRing(poly p, ring tailRing, omBin tailBin)
Definition: kInline.h:959
enterL
void enterL(LSet *set, int *length, int *LSetmax, LObject p, int at)
Definition: kutil.cc:1280
__p_GetComp
#define __p_GetComp(p, r)
Definition: monomials.h:63
rRing_has_Comp
#define rRing_has_Comp(r)
Definition: monomials.h:266
__pp_Mult_nn
#define __pp_Mult_nn(p, n, r)
Definition: p_polys.h:1000
p_SetComp
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition: p_polys.h:245
p_Setm
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:231
p_LmFreeAndNext
static poly p_LmFreeAndNext(poly p, ring)
Definition: p_polys.h:709
p_Test
#define p_Test(p, r)
Definition: p_polys.h:159
pInit
#define pInit()
allocates a new monomial and initializes everything to 0
Definition: polys.h:61
pSetExp
#define pSetExp(p, i, v)
Definition: polys.h:42
gcd
int gcd(int a, int b)
Definition: walkSupport.cc:836

◆ enterExtendedSpolySig()

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

Definition at line 4333 of file kutil.cc.

4334{
4335 if (nIsOne(pGetCoeff(h))) return;
4336 number gcd;
4337 number zero=n_Init(0,currRing->cf);
4338 bool go = false;
4339 if (n_DivBy(zero, pGetCoeff(h), currRing->cf))
4340 {
4341 gcd = n_Ann(pGetCoeff(h),currRing->cf);
4342 go = true;
4343 }
4344 else
4345 gcd = n_Gcd(zero, pGetCoeff(h), strat->tailRing->cf);
4346 if (go || !nIsOne(gcd))
4347 {
4348 poly p = h->next;
4349 if (!go)
4350 {
4351 number tmp = gcd;
4352 gcd = n_Ann(gcd,currRing->cf);
4353 nDelete(&tmp);
4354 }
4355 p_Test(p,strat->tailRing);
4356 p = __pp_Mult_nn(p, gcd, strat->tailRing);
4357
4358 if (p != NULL)
4359 {
4360 if (TEST_OPT_PROT)
4361 {
4362 PrintS("Z");
4363 }
4364#ifdef KDEBUG
4365 if (TEST_OPT_DEBUG)
4366 {
4367 PrintS("--- create zero spoly: ");
4368 p_wrp(h,currRing,strat->tailRing);
4369 PrintS(" ---> ");
4370 }
4371#endif
4372 poly tmp = pInit();
4373 pSetCoeff0(tmp, pGetCoeff(p));
4374 for (int i = 1; i <= rVar(currRing); i++)
4375 {
4376 pSetExp(tmp, i, p_GetExp(p, i, strat->tailRing));
4377 }
4378 if (rRing_has_Comp(currRing) && rRing_has_Comp(strat->tailRing))
4379 {
4380 p_SetComp(tmp, __p_GetComp(p, strat->tailRing), currRing);
4381 }
4382 p_Setm(tmp, currRing);
4383 p = p_LmFreeAndNext(p, strat->tailRing);
4384 pNext(tmp) = p;
4385 LObject Lp;
4386 Lp.Init();
4387 Lp.p = tmp;
4388 //printf("\nOld\n");pWrite(h);pWrite(hSig);
4389 #if EXT_POLY_NEW
4390 Lp.sig = __pp_Mult_nn(hSig, gcd, currRing);
4391 if(Lp.sig == NULL || nIsZero(pGetCoeff(Lp.sig)))
4392 {
4393 strat->sigdrop = TRUE;
4394 //Try to reduce it as far as we can via redRing
4395 int red_result = redRing(&Lp,strat);
4396 if(red_result == 0)
4397 {
4398 // Cancel the sigdrop
4399 p_Delete(&Lp.sig,currRing);Lp.sig = NULL;
4400 strat->sigdrop = FALSE;
4401 }
4402 else
4403 {
4404 strat->enterS(strat->P,strat->sl+1,strat, strat->tl+1);
4405 #if 1
4406 strat->enterS(Lp,0,strat,strat->tl);
4407 #endif
4408 }
4409 nDelete(&zero);
4410 nDelete(&gcd);
4411 return;
4412 }
4413 #else
4414 Lp.sig = pOne();
4415 if(strat->Ll >= 0)
4416 p_SetComp(Lp.sig,pGetComp(strat->L[0].sig)+1,currRing);
4417 else
4418 p_SetComp(Lp.sig,pGetComp(hSig)+1,currRing);
4419 #endif
4420 Lp.tailRing = strat->tailRing;
4421 int posx;
4422 if (Lp.p!=NULL)
4423 {
4424 strat->initEcart(&Lp);
4425 if (strat->Ll==-1)
4426 posx =0;
4427 else
4428 posx = strat->posInLSba(strat->L,strat->Ll,&Lp,strat);
4429 Lp.sev = pGetShortExpVector(Lp.p);
4430 if (strat->tailRing != currRing)
4431 {
4432 Lp.t_p = k_LmInit_currRing_2_tailRing(Lp.p, strat->tailRing);
4433 }
4434#ifdef KDEBUG
4435 if (TEST_OPT_DEBUG)
4436 {
4437 p_wrp(tmp,currRing,strat->tailRing);
4438 PrintLn();
4439 }
4440#endif
4441 //pWrite(h);pWrite(hSig);pWrite(Lp.p);pWrite(Lp.sig);printf("\n------------------\n");getchar();
4442 enterL(&strat->L,&strat->Ll,&strat->Lmax,Lp,posx);
4443 }
4444 }
4445 }
4446 nDelete(&gcd);
4447 nDelete(&zero);
4448}
skStrategy::sigdrop
bool sigdrop
Definition: kutil.h:359
skStrategy::posInLSba
int(* posInLSba)(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.h:282
redRing
int redRing(LObject *h, kStrategy strat)
Definition: kstd2.cc:954
nIsZero
#define nIsZero(n)
Definition: numbers.h:19

◆ enterL()

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

Definition at line 1280 of file kutil.cc.

1281{
1282 // this should be corrected
1283 assume(p.FDeg == p.pFDeg());
1284
1285 if ((*length)>=0)
1286 {
1287 if ((*length) == (*LSetmax)-1) enlargeL(set,LSetmax,setmaxLinc);
1288 if (at <= (*length))
1289#ifdef ENTER_USE_MEMMOVE
1290 memmove(&((*set)[at+1]), &((*set)[at]), ((*length)-at+1)*sizeof(LObject));
1291#else
1292 for (i=(*length)+1; i>=at+1; i--) (*set)[i] = (*set)[i-1];
1293#endif
1294 }
1295 else at = 0;
1296 (*set)[at] = p;
1297 (*length)++;
1298}
enlargeL
static void enlargeL(LSet *L, int *length, const int incr)
Definition: kutil.cc:683
setmaxLinc
#define setmaxLinc
Definition: kutil.h:31

◆ enterOnePairNormal()

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

Definition at line 1952 of file kutil.cc.

1953{
1954 assume(i<=strat->sl);
1955
1956 int l,j,compare;
1957 LObject Lp;
1958 Lp.i_r = -1;
1959
1960#ifdef KDEBUG
1961 Lp.ecart=0; Lp.length=0;
1962#endif
1963 /*- computes the lcm(s[i],p) -*/
1964 Lp.lcm = pInit();
1965
1966#ifndef HAVE_RATGRING
1967 pLcm(p,strat->S[i],Lp.lcm);
1968#elif defined(HAVE_RATGRING)
1969 if (rIsRatGRing(currRing))
1970 pLcmRat(p,strat->S[i],Lp.lcm, currRing->real_var_start); // int rat_shift
1971 else
1972 pLcm(p,strat->S[i],Lp.lcm);
1973#endif
1974 pSetm(Lp.lcm);
1975
1976
1977 if (strat->sugarCrit && ALLOW_PROD_CRIT(strat))
1978 {
1979 if (strat->fromT && (strat->ecartS[i]>ecart))
1980 {
1981 pLmFree(Lp.lcm);
1982 return;
1983 /*the pair is (s[i],t[.]), discard it if the ecart is too big*/
1984 }
1985 if((!((strat->ecartS[i]>0)&&(ecart>0)))
1986 && pHasNotCF(p,strat->S[i]))
1987 {
1988 /*
1989 *the product criterion has applied for (s,p),
1990 *i.e. lcm(s,p)=product of the leading terms of s and p.
1991 *Suppose (s,r) is in L and the leading term
1992 *of p divides lcm(s,r)
1993 *(==> the leading term of p divides the leading term of r)
1994 *but the leading term of s does not divide the leading term of r
1995 *(notice that tis condition is automatically satisfied if r is still
1996 *in S), then (s,r) can be cancelled.
1997 *This should be done here because the
1998 *case lcm(s,r)=lcm(s,p) is not covered by chainCrit.
1999 *
2000 *Moreover, skipping (s,r) holds also for the noncommutative case.
2001 */
2002 strat->cp++;
2003 pLmFree(Lp.lcm);
2004 return;
2005 }
2006 Lp.ecart = si_max(ecart,strat->ecartS[i]);
2007 /*
2008 *the set B collects the pairs of type (S[j],p)
2009 *suppose (r,p) is in B and (s,p) is the new pair and lcm(s,p)#lcm(r,p)
2010 *if the leading term of s divides lcm(r,p) then (r,p) will be canceled
2011 *if the leading term of r divides lcm(s,p) then (s,p) will not enter B
2012 */
2013 {
2014 j = strat->Bl;
2015 loop
2016 {
2017 if (j < 0) break;
2018 compare=pDivComp(strat->B[j].lcm,Lp.lcm);
2019 if ((compare==1)
2020 &&(sugarDivisibleBy(strat->B[j].ecart,Lp.ecart)))
2021 {
2022 strat->c3++;
2023 if ((strat->fromQ==NULL) || (isFromQ==0) || (strat->fromQ[i]==0))
2024 {
2025 pLmFree(Lp.lcm);
2026 return;
2027 }
2028 break;
2029 }
2030 else
2031 if ((compare ==-1)
2032 && sugarDivisibleBy(Lp.ecart,strat->B[j].ecart))
2033 {
2034 deleteInL(strat->B,&strat->Bl,j,strat);
2035 strat->c3++;
2036 }
2037 j--;
2038 }
2039 }
2040 }
2041 else /*sugarcrit*/
2042 {
2043 if (ALLOW_PROD_CRIT(strat))
2044 {
2045 if (strat->fromT && (strat->ecartS[i]>ecart))
2046 {
2047 pLmFree(Lp.lcm);
2048 return;
2049 /*the pair is (s[i],t[.]), discard it if the ecart is too big*/
2050 }
2051 // if currRing->nc_type!=quasi (or skew)
2052 // TODO: enable productCrit for super commutative algebras...
2053 if(/*(strat->ak==0) && productCrit(p,strat->S[i])*/
2054 pHasNotCF(p,strat->S[i]))
2055 {
2056 /*
2057 *the product criterion has applied for (s,p),
2058 *i.e. lcm(s,p)=product of the leading terms of s and p.
2059 *Suppose (s,r) is in L and the leading term
2060 *of p divides lcm(s,r)
2061 *(==> the leading term of p divides the leading term of r)
2062 *but the leading term of s does not divide the leading term of r
2063 *(notice that tis condition is automatically satisfied if r is still
2064 *in S), then (s,r) can be canceled.
2065 *This should be done here because the
2066 *case lcm(s,r)=lcm(s,p) is not covered by chainCrit.
2067 */
2068 strat->cp++;
2069 pLmFree(Lp.lcm);
2070 return;
2071 }
2072 /*
2073 *the set B collects the pairs of type (S[j],p)
2074 *suppose (r,p) is in B and (s,p) is the new pair and lcm(s,p)#lcm(r,p)
2075 *if the leading term of s divides lcm(r,p) then (r,p) will be canceled
2076 *if the leading term of r divides lcm(s,p) then (s,p) will not enter B
2077 */
2078 for(j = strat->Bl;j>=0;j--)
2079 {
2080 compare=pDivComp(strat->B[j].lcm,Lp.lcm);
2081 if (compare==1)
2082 {
2083 strat->c3++;
2084 if ((strat->fromQ==NULL) || (isFromQ==0) || (strat->fromQ[i]==0))
2085 {
2086 pLmFree(Lp.lcm);
2087 return;
2088 }
2089 break;
2090 }
2091 else
2092 if (compare ==-1)
2093 {
2094 deleteInL(strat->B,&strat->Bl,j,strat);
2095 strat->c3++;
2096 }
2097 }
2098 }
2099 }
2100 /*
2101 *the pair (S[i],p) enters B if the spoly != 0
2102 */
2103 /*- compute the short s-polynomial -*/
2104 if (strat->fromT && !TEST_OPT_INTSTRATEGY)
2105 pNorm(p);
2106
2107 if ((strat->S[i]==NULL) || (p==NULL))
2108 return;
2109
2110 if ((strat->fromQ!=NULL) && (isFromQ!=0) && (strat->fromQ[i]!=0))
2111 Lp.p=NULL;
2112 else
2113 {
2114 #ifdef HAVE_PLURAL
2115 if ( rIsPluralRing(currRing) )
2116 {
2117 if(pHasNotCF(p, strat->S[i]))
2118 {
2119 if(ncRingType(currRing) == nc_lie)
2120 {
2121 // generalized prod-crit for lie-type
2122 strat->cp++;
2123 Lp.p = nc_p_Bracket_qq(pCopy(p),strat->S[i], currRing);
2124 }
2125 else
2126 if( ALLOW_PROD_CRIT(strat) )
2127 {
2128 // product criterion for homogeneous case in SCA
2129 strat->cp++;
2130 Lp.p = NULL;
2131 }
2132 else
2133 {
2134 Lp.p = // nc_CreateSpoly(strat->S[i],p,currRing);
2135 nc_CreateShortSpoly(strat->S[i], p, currRing);
2136 assume(pNext(Lp.p)==NULL); // TODO: this may be violated whenever ext.prod.crit. for Lie alg. is used
2137 pNext(Lp.p) = strat->tail; // !!!
2138 }
2139 }
2140 else
2141 {
2142 Lp.p = // nc_CreateSpoly(strat->S[i],p,currRing);
2143 nc_CreateShortSpoly(strat->S[i], p, currRing);
2144
2145 assume(pNext(Lp.p)==NULL); // TODO: this may be violated whenever ext.prod.crit. for Lie alg. is used
2146 pNext(Lp.p) = strat->tail; // !!!
2147 }
2148 }
2149 else
2150 #endif
2151 {
2152 assume(!rIsPluralRing(currRing));
2153 Lp.p = ksCreateShortSpoly(strat->S[i], p, strat->tailRing);
2154 }
2155 }
2156 if (Lp.p == NULL)
2157 {
2158 /*- the case that the s-poly is 0 -*/
2159 if (strat->pairtest==NULL) initPairtest(strat);
2160 strat->pairtest[i] = TRUE;/*- hint for spoly(S^[i],p)=0 -*/
2161 strat->pairtest[strat->sl+1] = TRUE;
2162 /*hint for spoly(S[i],p) == 0 for some i,0 <= i <= sl*/
2163 /*
2164 *suppose we have (s,r),(r,p),(s,p) and spoly(s,p) == 0 and (r,p) is
2165 *still in B (i.e. lcm(r,p) == lcm(s,p) or the leading term of s does not
2166 *divide lcm(r,p)). In the last case (s,r) can be canceled if the leading
2167 *term of p divides the lcm(s,r)
2168 *(this canceling should be done here because
2169 *the case lcm(s,p) == lcm(s,r) is not covered in chainCrit)
2170 *the first case is handled in chainCrit
2171 */
2172 if (Lp.lcm!=NULL) pLmFree(Lp.lcm);
2173 }
2174 else
2175 {
2176 /*- the pair (S[i],p) enters B -*/
2177 Lp.p1 = strat->S[i];
2178 Lp.p2 = p;
2179
2180 if (
2181 (!rIsPluralRing(currRing))
2182// || (rIsPluralRing(currRing) && (ncRingType(currRing) != nc_lie))
2183 )
2184 {
2185 assume(pNext(Lp.p)==NULL); // TODO: this may be violated whenever ext.prod.crit. for Lie alg. is used
2186 pNext(Lp.p) = strat->tail; // !!!
2187 }
2188
2189 if (atR >= 0)
2190 {
2191 Lp.i_r1 = strat->S_2_R[i];
2192 Lp.i_r2 = atR;
2193 }
2194 else
2195 {
2196 Lp.i_r1 = -1;
2197 Lp.i_r2 = -1;
2198 }
2199 strat->initEcartPair(&Lp,strat->S[i],p,strat->ecartS[i],ecart);
2200
2201 if (TEST_OPT_INTSTRATEGY)
2202 {
2203 if (!rIsPluralRing(currRing)
2204 && !rField_is_Ring(currRing)
2205 && (Lp.p->coef!=NULL))
2206 nDelete(&(Lp.p->coef));
2207 }
2208
2209 l = strat->posInL(strat->B,strat->Bl,&Lp,strat);
2210 enterL(&strat->B,&strat->Bl,&strat->Bmax,Lp,l);
2211 }
2212}
si_max
static int si_max(const int a, const int b)
Definition: auxiliary.h:124
skStrategy::cp
int cp
Definition: kutil.h:347
skStrategy::initEcartPair
void(* initEcartPair)(LObject *h, poly f, poly g, int ecartF, int ecartG)
Definition: kutil.h:287
skStrategy::Bmax
int Bmax
Definition: kutil.h:352
ksCreateShortSpoly
poly ksCreateShortSpoly(poly p1, poly p2, ring tailRing)
Definition: kspoly.cc:1453
initPairtest
void initPairtest(kStrategy strat)
Definition: kutil.cc:693
pDivComp
static int pDivComp(poly p, poly q)
Definition: kutil.cc:183
ALLOW_PROD_CRIT
#define ALLOW_PROD_CRIT(A)
Definition: kutil.h:395
nc_CreateShortSpoly
poly nc_CreateShortSpoly(poly p1, poly p2, const ring r)
Definition: old.gring.cc:1879
nc_lie
@ nc_lie
Definition: nc.h:18
ncRingType
static nc_type & ncRingType(nc_struct *p)
Definition: nc.h:159
nc_p_Bracket_qq
poly nc_p_Bracket_qq(poly p, const poly q, const ring r)
returns [p,q], destroys p
Definition: old.gring.cc:2251
pSetm
#define pSetm(p)
Definition: polys.h:271
pHasNotCF
#define pHasNotCF(p1, p2)
Definition: polys.h:263
pNorm
void pNorm(poly p)
Definition: polys.h:362
pCopy
#define pCopy(p)
return a copy of the poly
Definition: polys.h:185
pLcm
#define pLcm(a, b, m)
Definition: polys.h:295
pLcmRat
void pLcmRat(poly a, poly b, poly m, int rat_shift)
Definition: ratgring.cc:30
rIsPluralRing
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition: ring.h:400
rIsRatGRing
static BOOLEAN rIsRatGRing(const ring r)
Definition: ring.h:427

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

12235{
12236#ifdef CRITERION_DEBUG
12237 if (TEST_OPT_DEBUG)
12238 {
12239 PrintS("Consider pair ("); wrp(q); PrintS(", "); wrp(p); PrintS(")"); PrintLn();
12240 // also write the LMs in separate lines:
12241 poly lmq = pHead(q);
12242 poly lmp = pHead(p);
12243 pSetCoeff(lmq, n_Init(1, currRing->cf));
12244 pSetCoeff(lmp, n_Init(1, currRing->cf));
12245 Print(" %s\n", pString(lmq));
12246 Print(" %s\n", pString(lmp));
12247 pLmDelete(lmq);
12248 pLmDelete(lmp);
12249 }
12250#endif
12251
12252 /* Format: q and p are like strat->P.p, so lm in CR, tail in TR */
12253
12254 /* check this Formats: */
12255 assume(p_LmCheckIsFromRing(q,currRing));
12256 assume(p_CheckIsFromRing(pNext(q),strat->tailRing));
12257 assume(p_LmCheckIsFromRing(p,currRing));
12258 assume(p_CheckIsFromRing(pNext(p),strat->tailRing));
12259
12260 /* poly q stays for s[i], ecartq = ecart(q), qisFromQ = applies to q */
12261
12262 int qfromQ = qisFromQ;
12263
12264 /* need additionally: int up_to_degree, poly V0 with the variables in (0) or just the number lV = the length of the first block */
12265
12266 int l,j,compare;
12267 LObject Lp;
12268 Lp.i_r = -1;
12269
12270#ifdef KDEBUG
12271 Lp.ecart=0; Lp.length=0;
12272#endif
12273 /*- computes the lcm(s[i],p) -*/
12274 Lp.lcm = p_Lcm(p,q, currRing); // q is what was strat->S[i], so a poly in LM/TR presentation
12275
12276 /* the V criterion */
12277 if (!pmIsInV(Lp.lcm))
12278 {
12279 strat->cv++; // counter for applying the V criterion
12280 pLmFree(Lp.lcm);
12281#ifdef CRITERION_DEBUG
12282 if (TEST_OPT_DEBUG) PrintS("--- V crit\n");
12283#endif
12284 return TRUE;
12285 }
12286
12287 if (strat->sugarCrit && ALLOW_PROD_CRIT(strat))
12288 {
12289 if((!((ecartq>0)&&(ecart>0)))
12290 && pHasNotCF(p,q))
12291 {
12292 /*
12293 *the product criterion has applied for (s,p),
12294 *i.e. lcm(s,p)=product of the leading terms of s and p.
12295 *Suppose (s,r) is in L and the leading term
12296 *of p divides lcm(s,r)
12297 *(==> the leading term of p divides the leading term of r)
12298 *but the leading term of s does not divide the leading term of r
12299 *(notice that this condition is automatically satisfied if r is still
12300 *in S), then (s,r) can be cancelled.
12301 *This should be done here because the
12302 *case lcm(s,r)=lcm(s,p) is not covered by chainCrit.
12303 *
12304 *Moreover, skipping (s,r) holds also for the noncommutative case.
12305 */
12306 strat->cp++;
12307 pLmFree(Lp.lcm);
12308#ifdef CRITERION_DEBUG
12309 if (TEST_OPT_DEBUG) PrintS("--- prod crit\n");
12310#endif
12311 return TRUE;
12312 }
12313 else
12314 Lp.ecart = si_max(ecart,ecartq);
12315 if (strat->fromT && (ecartq>ecart))
12316 {
12317 pLmFree(Lp.lcm);
12318#ifdef CRITERION_DEBUG
12319 if (TEST_OPT_DEBUG) PrintS("--- ecartq > ecart\n");
12320#endif
12321 return TRUE;
12322 /*the pair is (s[i],t[.]), discard it if the ecart is too big*/
12323 }
12324 /*
12325 *the set B collects the pairs of type (S[j],p)
12326 *suppose (r,p) is in B and (s,p) is the new pair and lcm(s,p)#lcm(r,p)
12327 *if the leading term of s divides lcm(r,p) then (r,p) will be canceled
12328 *if the leading term of r divides lcm(s,p) then (s,p) will not enter B
12329 */
12330 {
12331 j = strat->Bl;
12332 loop
12333 {
12334 if (j < 0) break;
12335 compare=pLPDivComp(strat->B[j].lcm,Lp.lcm);
12336 if ((compare==1)
12337 &&(sugarDivisibleBy(strat->B[j].ecart,Lp.ecart)))
12338 {
12339 strat->c3++;
12340 if ((strat->fromQ==NULL) || (isFromQ==0) || (qfromQ==0))
12341 {
12342 pLmFree(Lp.lcm);
12343#ifdef CRITERION_DEBUG
12344 if (TEST_OPT_DEBUG)
12345 {
12346 Print("--- chain crit using B[%d].lcm=%s\n", j, pString(strat->B[j].lcm));
12347 }
12348#endif
12349 return TRUE;
12350 }
12351 break;
12352 }
12353 else
12354 if ((compare ==-1)
12355 && sugarDivisibleBy(Lp.ecart,strat->B[j].ecart))
12356 {
12357#ifdef CRITERION_DEBUG
12358 if (TEST_OPT_DEBUG)
12359 {
12360 Print("--- chain crit using pair to remove B[%d].lcm=%s\n", j, pString(strat->B[j].lcm));
12361 }
12362#endif
12363 deleteInL(strat->B,&strat->Bl,j,strat);
12364 strat->c3++;
12365 }
12366 j--;
12367 }
12368 }
12369 }
12370 else /*sugarcrit*/
12371 {
12372 if (ALLOW_PROD_CRIT(strat))
12373 {
12374 // if currRing->nc_type!=quasi (or skew)
12375 // TODO: enable productCrit for super commutative algebras...
12376 if(/*(strat->ak==0) && productCrit(p,strat->S[i])*/
12377 pHasNotCF(p,q))
12378 {
12379 /*
12380 *the product criterion has applied for (s,p),
12381 *i.e. lcm(s,p)=product of the leading terms of s and p.
12382 *Suppose (s,r) is in L and the leading term
12383 *of p divides lcm(s,r)
12384 *(==> the leading term of p divides the leading term of r)
12385 *but the leading term of s does not divide the leading term of r
12386 *(notice that tis condition is automatically satisfied if r is still
12387 *in S), then (s,r) can be canceled.
12388 *This should be done here because the
12389 *case lcm(s,r)=lcm(s,p) is not covered by chainCrit.
12390 */
12391 strat->cp++;
12392 pLmFree(Lp.lcm);
12393#ifdef CRITERION_DEBUG
12394 if (TEST_OPT_DEBUG) PrintS("--- prod crit\n");
12395#endif
12396 return TRUE;
12397 }
12398 if (strat->fromT && (ecartq>ecart))
12399 {
12400 pLmFree(Lp.lcm);
12401#ifdef CRITERION_DEBUG
12402 if (TEST_OPT_DEBUG) PrintS("--- ecartq > ecart\n");
12403#endif
12404 return TRUE;
12405 /*the pair is (s[i],t[.]), discard it if the ecart is too big*/
12406 }
12407 /*
12408 *the set B collects the pairs of type (S[j],p)
12409 *suppose (r,p) is in B and (s,p) is the new pair and lcm(s,p)#lcm(r,p)
12410 *if the leading term of s divides lcm(r,p) then (r,p) will be canceled
12411 *if the leading term of r divides lcm(s,p) then (s,p) will not enter B
12412 */
12413 for(j = strat->Bl;j>=0;j--)
12414 {
12415 compare=pLPDivComp(strat->B[j].lcm,Lp.lcm);
12416 if (compare==1)
12417 {
12418 strat->c3++;
12419 if ((strat->fromQ==NULL) || (isFromQ==0) || (qfromQ==0))
12420 {
12421 pLmFree(Lp.lcm);
12422#ifdef CRITERION_DEBUG
12423 if (TEST_OPT_DEBUG)
12424 {
12425 Print("--- chain crit using B[%d].lcm=%s\n", j, pString(strat->B[j].lcm));
12426 }
12427#endif
12428 return TRUE;
12429 }
12430 break;
12431 }
12432 else
12433 if (compare ==-1)
12434 {
12435#ifdef CRITERION_DEBUG
12436 if (TEST_OPT_DEBUG)
12437 {
12438 Print("--- chain crit using pair to remove B[%d].lcm=%s\n", j, pString(strat->B[j].lcm));
12439 }
12440#endif
12441 deleteInL(strat->B,&strat->Bl,j,strat);
12442 strat->c3++;
12443 }
12444 }
12445 }
12446 }
12447 /*
12448 *the pair (S[i],p) enters B if the spoly != 0
12449 */
12450 /*- compute the short s-polynomial -*/
12451 if (strat->fromT && !TEST_OPT_INTSTRATEGY)
12452 pNorm(p);
12453 if ((q==NULL) || (p==NULL))
12454 {
12455#ifdef CRITERION_DEBUG
12456 if (TEST_OPT_DEBUG) PrintS("--- q == NULL || p == NULL\n");
12457#endif
12458 return FALSE;
12459 }
12460 if ((strat->fromQ!=NULL) && (isFromQ!=0) && (qfromQ!=0))
12461 {
12462 Lp.p=NULL;
12463#ifdef CRITERION_DEBUG
12464 if (TEST_OPT_DEBUG) PrintS("--- pair is from Q\n");
12465#endif
12466 }
12467 else
12468 {
12469// if ( rIsPluralRing(currRing) )
12470// {
12471// if(pHasNotCF(p, q))
12472// {
12473// if(ncRingType(currRing) == nc_lie)
12474// {
12475// // generalized prod-crit for lie-type
12476// strat->cp++;
12477// Lp.p = nc_p_Bracket_qq(pCopy(p),q, currRing);
12478// }
12479// else
12480// if( ALLOW_PROD_CRIT(strat) )
12481// {
12482// // product criterion for homogeneous case in SCA
12483// strat->cp++;
12484// Lp.p = NULL;
12485// }
12486// else
12487// Lp.p = nc_CreateSpoly(q,p,currRing); // ?
12488// }
12489// else Lp.p = nc_CreateSpoly(q,p,currRing);
12490// }
12491// else
12492// {
12493
12494 /* ksCreateShortSpoly needs two Lobject-kind presentations */
12495 /* p is already in this form, so convert q */
12496 Lp.p = ksCreateShortSpoly(q, p, strat->tailRing);
12497 // }
12498 }
12499 if (Lp.p == NULL)
12500 {
12501 /*- the case that the s-poly is 0 -*/
12502 // TODO: currently ifromS is only > 0 if called from enterOnePairWithShifts
12503 if (ifromS > 0)
12504 {
12505 if (strat->pairtest==NULL) initPairtest(strat);
12506 strat->pairtest[ifromS] = TRUE;/*- hint for spoly(S^[i],p)=0 -*/
12507 strat->pairtest[strat->sl+1] = TRUE;
12508 }
12509 //if (TEST_OPT_DEBUG){Print("!");} // option teach
12510 /* END _ TEMPORARILY DISABLED FOR SHIFTS */
12511 /*hint for spoly(S[i],p) == 0 for some i,0 <= i <= sl*/
12512 /*
12513 *suppose we have (s,r),(r,p),(s,p) and spoly(s,p) == 0 and (r,p) is
12514 *still in B (i.e. lcm(r,p) == lcm(s,p) or the leading term of s does not
12515 *divide lcm(r,p)). In the last case (s,r) can be canceled if the leading
12516 *term of p divides the lcm(s,r)
12517 *(this canceling should be done here because
12518 *the case lcm(s,p) == lcm(s,r) is not covered in chainCrit)
12519 *the first case is handled in chainCrit
12520 */
12521 if (Lp.lcm!=NULL) pLmFree(Lp.lcm);
12522#ifdef CRITERION_DEBUG
12523 if (TEST_OPT_DEBUG) PrintS("--- S-poly = 0\n");
12524#endif
12525 return TRUE;
12526 }
12527 else
12528 {
12529 /*- the pair (S[i],p) enters B -*/
12530 /* both of them should have their LM in currRing and TAIL in tailring */
12531 Lp.p1 = q; // already in the needed form
12532 Lp.p2 = p; // already in the needed form
12533
12534 if ( !rIsPluralRing(currRing) )
12535 pNext(Lp.p) = strat->tail;
12536
12537 /* TEMPORARILY DISABLED FOR SHIFTS because there's no i*/
12538 /* at the beginning we DO NOT set atR = -1 ANYMORE*/
12539 if ( (atR >= 0) && (shiftcount==0) && (ifromS >=0) )
12540 {
12541 Lp.i_r1 = kFindInT(Lp.p1,strat); //strat->S_2_R[ifromS];
12542 Lp.i_r2 = atR;
12543 }
12544 else
12545 {
12546 /* END _ TEMPORARILY DISABLED FOR SHIFTS */
12547 Lp.i_r1 = -1;
12548 Lp.i_r2 = -1;
12549 }
12550 strat->initEcartPair(&Lp,q,p,ecartq,ecart);
12551
12552 if (TEST_OPT_INTSTRATEGY)
12553 {
12554 if (!rIsPluralRing(currRing)
12555 && !rField_is_Ring(currRing)
12556 && (Lp.p->coef!=NULL))
12557 nDelete(&(Lp.p->coef));
12558 }
12559
12560 l = strat->posInL(strat->B,strat->Bl,&Lp,strat);
12561 enterL(&strat->B,&strat->Bl,&strat->Bmax,Lp,l);
12562#ifdef CRITERION_DEBUG
12563 if (TEST_OPT_DEBUG) PrintS("+++ Entered pair\n");
12564#endif
12565 }
12566 return FALSE;
12567}
skStrategy::cv
int cv
Definition: kutil.h:368
pLPDivComp
static int pLPDivComp(poly p, poly q)
Definition: kutil.cc:232
p_Lcm
void p_Lcm(const poly a, const poly b, poly m, const ring r)
Definition: p_polys.cc:1651
p_CheckIsFromRing
BOOLEAN p_CheckIsFromRing(poly p, ring r)
Definition: pDebug.cc:102
p_LmCheckIsFromRing
BOOLEAN p_LmCheckIsFromRing(poly p, ring r)
Definition: pDebug.cc:71
pHead
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL
Definition: polys.h:67
wrp
void wrp(poly p)
Definition: polys.h:310
pString
char * pString(poly p)
Definition: polys.h:306
pmIsInV
#define pmIsInV(p)
Definition: shiftop.h:51

◆ enterpairs()

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

Definition at line 4509 of file kutil.cc.

4510{
4511 int j=pos;
4512
4513 assume (!rField_is_Ring(currRing));
4514 initenterpairs(h,k,ecart,0,strat, atR);
4515 if ( (!strat->fromT)
4516 && ((strat->syzComp==0)
4517 ||(pGetComp(h)<=strat->syzComp)))
4518 {
4519 unsigned long h_sev = pGetShortExpVector(h);
4520 loop
4521 {
4522 if (j > k) break;
4523 clearS(h,h_sev, &j,&k,strat);
4524 j++;
4525 }
4526 }
4527}
initenterpairs
void initenterpairs(poly h, int k, int ecart, int isFromQ, kStrategy strat, int atR)
Definition: kutil.cc:3822

◆ enterpairsShift()

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

Definition at line 13028 of file kutil.cc.

13029{
13030 /* h is strat->P.p, that is LObject with LM in currRing and Tail in tailRing */
13031 /* Q: what is exactly the strat->fromT ? A: a local case trick; don't need it yet*/
13032 int j=pos;
13033
13034 /* if (!(rField_is_Domain(currRing))) enterExtendedSpoly(h, strat); */ // TODO: enterExtendedSpoly not for LP yet
13035 initenterpairsShift(h,k,ecart,0,strat, atR);
13036 if ( (!strat->fromT)
13037 && ((strat->syzComp==0)
13038 ||(pGetComp(h)<=strat->syzComp)))
13039 {
13040 unsigned long h_sev = pGetShortExpVector(h);
13041 loop
13042 {
13043 if (j > k) break;
13044 // TODO this currently doesn't clear all possible elements because of commutative division
13045 if (!(strat->rightGB && strat->fromQ != NULL && strat->fromQ[j]))
13046 clearS(h,h_sev, &j,&k,strat);
13047 j++;
13048 }
13049 }
13050}
initenterpairsShift
void initenterpairsShift(poly h, int k, int ecart, int isFromQ, kStrategy strat, int atR)
Definition: kutil.cc:12576

◆ enterpairsSig()

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

Definition at line 4535 of file kutil.cc.

4536{
4537 int j=pos;
4538 assume (!rField_is_Ring(currRing));
4539 initenterpairsSig(h,hSig,hFrom,k,ecart,0,strat, atR);
4540 if ( (!strat->fromT)
4541 && ((strat->syzComp==0)
4542 ||(pGetComp(h)<=strat->syzComp)))
4543 {
4544 unsigned long h_sev = pGetShortExpVector(h);
4545 loop
4546 {
4547 if (j > k) break;
4548 clearS(h,h_sev, &j,&k,strat);
4549 j++;
4550 }
4551 }
4552}
initenterpairsSig
void initenterpairsSig(poly h, poly hSig, int hFrom, int k, int ecart, int isFromQ, kStrategy strat, int atR=-1)
Definition: kutil.cc:3887

◆ enterSBba()

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

Definition at line 8829 of file kutil.cc.

8830{
8831 strat->news = TRUE;
8832 /*- puts p to the standardbasis s at position at -*/
8833 if (strat->sl == IDELEMS(strat->Shdl)-1)
8834 {
8835 strat->sevS = (unsigned long*) omRealloc0Size(strat->sevS,
8836 IDELEMS(strat->Shdl)*sizeof(unsigned long),
8837 (IDELEMS(strat->Shdl)+setmaxTinc)
8838 *sizeof(unsigned long));
8839 strat->ecartS = (intset)omReallocSize(strat->ecartS,
8840 IDELEMS(strat->Shdl)*sizeof(int),
8841 (IDELEMS(strat->Shdl)+setmaxTinc)
8842 *sizeof(int));
8843 strat->S_2_R = (int*) omRealloc0Size(strat->S_2_R,
8844 IDELEMS(strat->Shdl)*sizeof(int),
8845 (IDELEMS(strat->Shdl)+setmaxTinc)
8846 *sizeof(int));
8847 if (strat->lenS!=NULL)
8848 strat->lenS=(int*)omRealloc0Size(strat->lenS,
8849 IDELEMS(strat->Shdl)*sizeof(int),
8850 (IDELEMS(strat->Shdl)+setmaxTinc)
8851 *sizeof(int));
8852 if (strat->lenSw!=NULL)
8853 strat->lenSw=(wlen_type*)omRealloc0Size(strat->lenSw,
8854 IDELEMS(strat->Shdl)*sizeof(wlen_type),
8855 (IDELEMS(strat->Shdl)+setmaxTinc)
8856 *sizeof(wlen_type));
8857 if (strat->fromQ!=NULL)
8858 {
8859 strat->fromQ = (intset)omReallocSize(strat->fromQ,
8860 IDELEMS(strat->Shdl)*sizeof(int),
8861 (IDELEMS(strat->Shdl)+setmaxTinc)*sizeof(int));
8862 }
8863 pEnlargeSet(&strat->S,IDELEMS(strat->Shdl),setmaxTinc);
8864 IDELEMS(strat->Shdl)+=setmaxTinc;
8865 strat->Shdl->m=strat->S;
8866 }
8867 if (atS <= strat->sl)
8868 {
8869#ifdef ENTER_USE_MEMMOVE
8870 memmove(&(strat->S[atS+1]), &(strat->S[atS]),
8871 (strat->sl - atS + 1)*sizeof(poly));
8872 memmove(&(strat->ecartS[atS+1]), &(strat->ecartS[atS]),
8873 (strat->sl - atS + 1)*sizeof(int));
8874 memmove(&(strat->sevS[atS+1]), &(strat->sevS[atS]),
8875 (strat->sl - atS + 1)*sizeof(unsigned long));
8876 memmove(&(strat->S_2_R[atS+1]), &(strat->S_2_R[atS]),
8877 (strat->sl - atS + 1)*sizeof(int));
8878 if (strat->lenS!=NULL)
8879 memmove(&(strat->lenS[atS+1]), &(strat->lenS[atS]),
8880 (strat->sl - atS + 1)*sizeof(int));
8881 if (strat->lenSw!=NULL)
8882 memmove(&(strat->lenSw[atS+1]), &(strat->lenSw[atS]),
8883 (strat->sl - atS + 1)*sizeof(wlen_type));
8884#else
8885 for (i=strat->sl+1; i>=atS+1; i--)
8886 {
8887 strat->S[i] = strat->S[i-1];
8888 strat->ecartS[i] = strat->ecartS[i-1];
8889 strat->sevS[i] = strat->sevS[i-1];
8890 strat->S_2_R[i] = strat->S_2_R[i-1];
8891 }
8892 if (strat->lenS!=NULL)
8893 for (i=strat->sl+1; i>=atS+1; i--)
8894 strat->lenS[i] = strat->lenS[i-1];
8895 if (strat->lenSw!=NULL)
8896 for (i=strat->sl+1; i>=atS+1; i--)
8897 strat->lenSw[i] = strat->lenSw[i-1];
8898#endif
8899 }
8900 if (strat->fromQ!=NULL)
8901 {
8902#ifdef ENTER_USE_MEMMOVE
8903 memmove(&(strat->fromQ[atS+1]), &(strat->fromQ[atS]),
8904 (strat->sl - atS + 1)*sizeof(int));
8905#else
8906 for (i=strat->sl+1; i>=atS+1; i--)
8907 {
8908 strat->fromQ[i] = strat->fromQ[i-1];
8909 }
8910#endif
8911 strat->fromQ[atS]=0;
8912 }
8913
8914 /*- save result -*/
8915 poly pp=p.p;
8916 strat->S[atS] = pp;
8917 if (strat->honey) strat->ecartS[atS] = p.ecart;
8918 if (p.sev == 0)
8919 p.sev = pGetShortExpVector(pp);
8920 else
8921 assume(p.sev == pGetShortExpVector(pp));
8922 strat->sevS[atS] = p.sev;
8923 strat->ecartS[atS] = p.ecart;
8924 strat->S_2_R[atS] = atR;
8925 strat->sl++;
8926}
pp
CanonicalForm FACTORY_PUBLIC pp(const CanonicalForm &)
CanonicalForm pp ( const CanonicalForm & f )
Definition: cf_gcd.cc:676
skStrategy::news
char news
Definition: kutil.h:400
setmaxTinc
#define setmaxTinc
Definition: kutil.h:34
intset
int * intset
Definition: kutil.h:53
omReallocSize
#define omReallocSize(addr, o_size, size)
Definition: omAllocDecl.h:220
omRealloc0Size
#define omRealloc0Size(addr, o_size, size)
Definition: omAllocDecl.h:221
pEnlargeSet
void pEnlargeSet(poly **p, int l, int increment)
Definition: p_polys.cc:3692

◆ enterSBbaShift()

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

Definition at line 8929 of file kutil.cc.

8930{
8931 enterSBba(p, atS, strat, atR);
8932
8933 int maxPossibleShift = p_mLPmaxPossibleShift(p.p, strat->tailRing);
8934 for (int i = maxPossibleShift; i > 0; i--)
8935 {
8936 // NOTE: don't use "shared tails" here. In rare cases it can cause problems
8937 // in `kNF2` because of lazy poly normalizations.
8938 LObject qq(p_Copy(p.p, strat->tailRing));
8939 p_mLPshift(qq.p, i, strat->tailRing);
8940 qq.shift = i;
8941 strat->initEcart(&qq); // initEcartBBA sets length, pLength, FDeg and ecart
8942 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
8943 enterSBba(qq, atS, strat, -1);
8944 }
8945}
enterSBba
void enterSBba(LObject &p, int atS, kStrategy strat, int atR)
Definition: kutil.cc:8829
p_mLPmaxPossibleShift
int p_mLPmaxPossibleShift(poly p, const ring r)
Definition: shiftgb.cc:45
p_mLPshift
void p_mLPshift(poly m, int sh, const ring ri)
Definition: shiftop.cc:362

◆ entersets()

void entersets ( LObject  h)

◆ enterSSba()

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

Definition at line 8952 of file kutil.cc.

8953{
8954 strat->news = TRUE;
8955 /*- puts p to the standardbasis s at position at -*/
8956 if (strat->sl == IDELEMS(strat->Shdl)-1)
8957 {
8958 strat->sevS = (unsigned long*) omRealloc0Size(strat->sevS,
8959 IDELEMS(strat->Shdl)*sizeof(unsigned long),
8960 (IDELEMS(strat->Shdl)+setmax)
8961 *sizeof(unsigned long));
8962 strat->sevSig = (unsigned long*) omRealloc0Size(strat->sevSig,
8963 IDELEMS(strat->Shdl)*sizeof(unsigned long),
8964 (IDELEMS(strat->Shdl)+setmax)
8965 *sizeof(unsigned long));
8966 strat->ecartS = (intset)omReallocSize(strat->ecartS,
8967 IDELEMS(strat->Shdl)*sizeof(int),
8968 (IDELEMS(strat->Shdl)+setmax)
8969 *sizeof(int));
8970 strat->S_2_R = (int*) omRealloc0Size(strat->S_2_R,
8971 IDELEMS(strat->Shdl)*sizeof(int),
8972 (IDELEMS(strat->Shdl)+setmax)
8973 *sizeof(int));
8974 if (strat->lenS!=NULL)
8975 strat->lenS=(int*)omRealloc0Size(strat->lenS,
8976 IDELEMS(strat->Shdl)*sizeof(int),
8977 (IDELEMS(strat->Shdl)+setmax)
8978 *sizeof(int));
8979 if (strat->lenSw!=NULL)
8980 strat->lenSw=(wlen_type*)omRealloc0Size(strat->lenSw,
8981 IDELEMS(strat->Shdl)*sizeof(wlen_type),
8982 (IDELEMS(strat->Shdl)+setmax)
8983 *sizeof(wlen_type));
8984 if (strat->fromQ!=NULL)
8985 {
8986 strat->fromQ = (intset)omReallocSize(strat->fromQ,
8987 IDELEMS(strat->Shdl)*sizeof(int),
8988 (IDELEMS(strat->Shdl)+setmax)*sizeof(int));
8989 }
8990 pEnlargeSet(&strat->S,IDELEMS(strat->Shdl),setmax);
8991 pEnlargeSet(&strat->sig,IDELEMS(strat->Shdl),setmax);
8992 IDELEMS(strat->Shdl)+=setmax;
8993 strat->Shdl->m=strat->S;
8994 }
8995 // in a signature-based algorithm the following situation will never
8996 // appear due to the fact that the critical pairs are already sorted
8997 // by increasing signature.
8998 // True. However, in the case of integers we need to put the element
8999 // that caused the signature drop on the first position
9000 if (atS <= strat->sl)
9001 {
9002#ifdef ENTER_USE_MEMMOVE
9003 memmove(&(strat->S[atS+1]), &(strat->S[atS]),
9004 (strat->sl - atS + 1)*sizeof(poly));
9005 memmove(&(strat->sig[atS+1]), &(strat->sig[atS]),
9006 (strat->sl - atS + 1)*sizeof(poly));
9007 memmove(&(strat->sevSig[atS+1]), &(strat->sevSig[atS]),
9008 (strat->sl - atS + 1)*sizeof(unsigned long));
9009 memmove(&(strat->ecartS[atS+1]), &(strat->ecartS[atS]),
9010 (strat->sl - atS + 1)*sizeof(int));
9011 memmove(&(strat->sevS[atS+1]), &(strat->sevS[atS]),
9012 (strat->sl - atS + 1)*sizeof(unsigned long));
9013 memmove(&(strat->S_2_R[atS+1]), &(strat->S_2_R[atS]),
9014 (strat->sl - atS + 1)*sizeof(int));
9015 if (strat->lenS!=NULL)
9016 memmove(&(strat->lenS[atS+1]), &(strat->lenS[atS]),
9017 (strat->sl - atS + 1)*sizeof(int));
9018 if (strat->lenSw!=NULL)
9019 memmove(&(strat->lenSw[atS+1]), &(strat->lenSw[atS]),
9020 (strat->sl - atS + 1)*sizeof(wlen_type));
9021#else
9022 for (i=strat->sl+1; i>=atS+1; i--)
9023 {
9024 strat->S[i] = strat->S[i-1];
9025 strat->ecartS[i] = strat->ecartS[i-1];
9026 strat->sevS[i] = strat->sevS[i-1];
9027 strat->S_2_R[i] = strat->S_2_R[i-1];
9028 strat->sig[i] = strat->sig[i-1];
9029 strat->sevSig[i] = strat->sevSig[i-1];
9030 }
9031 if (strat->lenS!=NULL)
9032 for (i=strat->sl+1; i>=atS+1; i--)
9033 strat->lenS[i] = strat->lenS[i-1];
9034 if (strat->lenSw!=NULL)
9035 for (i=strat->sl+1; i>=atS+1; i--)
9036 strat->lenSw[i] = strat->lenSw[i-1];
9037#endif
9038 }
9039 if (strat->fromQ!=NULL)
9040 {
9041#ifdef ENTER_USE_MEMMOVE
9042 memmove(&(strat->fromQ[atS+1]), &(strat->fromQ[atS]),
9043 (strat->sl - atS + 1)*sizeof(int));
9044#else
9045 for (i=strat->sl+1; i>=atS+1; i--)
9046 {
9047 strat->fromQ[i] = strat->fromQ[i-1];
9048 }
9049#endif
9050 strat->fromQ[atS]=0;
9051 }
9052
9053 /*- save result -*/
9054 strat->S[atS] = p.p;
9055 strat->sig[atS] = p.sig; // TODO: get the correct signature in here!
9056 if (strat->honey) strat->ecartS[atS] = p.ecart;
9057 if (p.sev == 0)
9058 p.sev = pGetShortExpVector(p.p);
9059 else
9060 assume(p.sev == pGetShortExpVector(p.p));
9061 strat->sevS[atS] = p.sev;
9062 // during the interreduction process of a signature-based algorithm we do not
9063 // compute the signature at this point, but when the whole interreduction
9064 // process finishes, i.e. f5c terminates!
9065 if (p.sig != NULL)
9066 {
9067 if (p.sevSig == 0)
9068 p.sevSig = pGetShortExpVector(p.sig);
9069 else
9070 assume(p.sevSig == pGetShortExpVector(p.sig));
9071 strat->sevSig[atS] = p.sevSig; // TODO: get the correct signature in here!
9072 }
9073 strat->ecartS[atS] = p.ecart;
9074 strat->S_2_R[atS] = atR;
9075 strat->sl++;
9076#ifdef DEBUGF5
9077 int k;
9078 Print("--- LIST S: %d ---\n",strat->sl);
9079 for(k=0;k<=strat->sl;k++)
9080 {
9081 pWrite(strat->sig[k]);
9082 }
9083 PrintS("--- LIST S END ---\n");
9084#endif
9085}
setmax
#define setmax
Definition: kutil.h:29
pWrite
void pWrite(poly p)
Definition: polys.h:308

◆ enterSyz()

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

Definition at line 9380 of file kutil.cc.

9381{
9382 int i;
9383 strat->newt = TRUE;
9384 if (strat->syzl == strat->syzmax-1)
9385 {
9386 pEnlargeSet(&strat->syz,strat->syzmax,setmax);
9387 strat->sevSyz = (unsigned long*) omRealloc0Size(strat->sevSyz,
9388 (strat->syzmax)*sizeof(unsigned long),
9389 ((strat->syzmax)+setmax)
9390 *sizeof(unsigned long));
9391 strat->syzmax += setmax;
9392 }
9393 if (atT < strat->syzl)
9394 {
9395#ifdef ENTER_USE_MEMMOVE
9396 memmove(&(strat->syz[atT+1]), &(strat->syz[atT]),
9397 (strat->syzl-atT+1)*sizeof(poly));
9398 memmove(&(strat->sevSyz[atT+1]), &(strat->sevSyz[atT]),
9399 (strat->syzl-atT+1)*sizeof(unsigned long));
9400#endif
9401 for (i=strat->syzl; i>=atT+1; i--)
9402 {
9403#ifndef ENTER_USE_MEMMOVE
9404 strat->syz[i] = strat->syz[i-1];
9405 strat->sevSyz[i] = strat->sevSyz[i-1];
9406#endif
9407 }
9408 }
9409 //i = strat->syzl;
9410 i = atT;
9411 //Makes sure the syz saves just the signature
9412 #ifdef HAVE_RINGS
9413 if(rField_is_Ring(currRing))
9414 pNext(p.sig) = NULL;
9415 #endif
9416 strat->syz[atT] = p.sig;
9417 strat->sevSyz[atT] = p.sevSig;
9418 strat->syzl++;
9419#if F5DEBUG
9420 Print("element in strat->syz: %d--%d ",atT+1,strat->syzmax);
9421 pWrite(strat->syz[atT]);
9422#endif
9423 // recheck pairs in strat->L with new rule and delete correspondingly
9424 int cc = strat->Ll;
9425 while (cc>-1)
9426 {
9427 //printf("\nCheck if syz is div by L\n");pWrite(strat->syz[atT]);pWrite(strat->L[cc].sig);
9428 //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);
9429 if (p_LmShortDivisibleBy( strat->syz[atT], strat->sevSyz[atT],
9430 strat->L[cc].sig, ~strat->L[cc].sevSig, currRing)
9431 #ifdef HAVE_RINGS
9432 &&((!rField_is_Ring(currRing))
9433 || (n_DivBy(pGetCoeff(strat->L[cc].sig),pGetCoeff(strat->syz[atT]),currRing->cf) && (pLtCmp(strat->L[cc].sig,strat->syz[atT])==1)))
9434 #endif
9435 )
9436 {
9437 //printf("\nYES!\n");
9438 deleteInL(strat->L,&strat->Ll,cc,strat);
9439 }
9440 cc--;
9441 }
9442//#if 1
9443#ifdef DEBUGF5
9444 PrintS("--- Syzygies ---\n");
9445 Print("syzl %d\n",strat->syzl);
9446 Print("syzmax %d\n",strat->syzmax);
9447 PrintS("--------------------------------\n");
9448 for(i=0;i<=strat->syzl-1;i++)
9449 {
9450 Print("%d - ",i);
9451 pWrite(strat->syz[i]);
9452 }
9453 PrintS("--------------------------------\n");
9454#endif
9455}
skStrategy::sevSyz
unsigned long * sevSyz
Definition: kutil.h:323
skStrategy::syzmax
int syzmax
Definition: kutil.h:349
skStrategy::syzl
int syzl
Definition: kutil.h:349
skStrategy::syz
polyset syz
Definition: kutil.h:307
skStrategy::newt
char newt
Definition: kutil.h:401
pLtCmp
#define pLtCmp(p, q)
Definition: polys.h:123

◆ enterT()

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

Definition at line 9178 of file kutil.cc.

9179{
9180 int i;
9181
9182#ifdef PDEBUG
9183#ifdef HAVE_SHIFTBBA
9184 if (currRing->isLPring && p.shift > 0)
9185 {
9186 // in this case, the order is not correct. test LM and tail separately
9187 p_LmTest(p.p, currRing);
9188 p_Test(pNext(p.p), currRing);
9189 }
9190 else
9191#endif
9192 {
9193 pp_Test(p.p, currRing, p.tailRing);
9194 }
9195#endif
9196 assume(strat->tailRing == p.tailRing);
9197 // redMoraNF complains about this -- but, we don't really
9198 // need this so far
9199 assume(p.pLength == 0 || pLength(p.p) == p.pLength || rIsSyzIndexRing(currRing)); // modulo syzring
9200 assume(!strat->homog || (p.FDeg == p.pFDeg()));
9201 assume(!p.is_normalized || nIsOne(pGetCoeff(p.p)));
9202
9203#ifdef KDEBUG
9204 // do not put an LObject twice into T:
9205 for(i=strat->tl;i>=0;i--)
9206 {
9207 if (p.p==strat->T[i].p)
9208 {
9209 printf("already in T at pos %d of %d, atT=%d\n",i,strat->tl,atT);
9210 return;
9211 }
9212 }
9213#endif
9214
9215#ifdef HAVE_TAIL_RING
9216 if (currRing!=strat->tailRing)
9217 {
9218 p.t_p=p.GetLmTailRing();
9219 }
9220#endif
9221 strat->newt = TRUE;
9222 if (atT < 0)
9223 atT = strat->posInT(strat->T, strat->tl, p);
9224 if (strat->tl == strat->tmax-1)
9225 enlargeT(strat->T,strat->R,strat->sevT,strat->tmax,setmaxTinc);
9226 if (atT <= strat->tl)
9227 {
9228#ifdef ENTER_USE_MEMMOVE
9229 memmove(&(strat->T[atT+1]), &(strat->T[atT]),
9230 (strat->tl-atT+1)*sizeof(TObject));
9231 memmove(&(strat->sevT[atT+1]), &(strat->sevT[atT]),
9232 (strat->tl-atT+1)*sizeof(unsigned long));
9233#endif
9234 for (i=strat->tl+1; i>=atT+1; i--)
9235 {
9236#ifndef ENTER_USE_MEMMOVE
9237 strat->T[i] = strat->T[i-1];
9238 strat->sevT[i] = strat->sevT[i-1];
9239#endif
9240 strat->R[strat->T[i].i_r] = &(strat->T[i]);
9241 }
9242 }
9243
9244 if ((strat->tailBin != NULL) && (pNext(p.p) != NULL))
9245 {
9246#ifdef HAVE_SHIFTBBA
9247 // letterplace: if p.shift > 0 then pNext(p.p) is already in the tailBin
9248 if (!(currRing->isLPring && p.shift > 0))
9249#endif
9250 {
9251 pNext(p.p)=p_ShallowCopyDelete(pNext(p.p),
9252 (strat->tailRing != NULL ?
9253 strat->tailRing : currRing),
9254 strat->tailBin);
9255 if (p.t_p != NULL) pNext(p.t_p) = pNext(p.p);
9256 }
9257 }
9258 strat->T[atT] = (TObject) p;
9259 //printf("\nenterT: add new: length = %i, ecart = %i\n",p.length,p.ecart);
9260
9261 if ((pNext(p.p) != NULL) && (!rIsLPRing(currRing)))
9262 strat->T[atT].max_exp = p_GetMaxExpP(pNext(p.p), strat->tailRing);
9263 else
9264 strat->T[atT].max_exp = NULL;
9265
9266 strat->tl++;
9267 strat->R[strat->tl] = &(strat->T[atT]);
9268 strat->T[atT].i_r = strat->tl;
9269 assume((p.sev == 0) || (pGetShortExpVector(p.p) == p.sev));
9270 strat->sevT[atT] = (p.sev == 0 ? pGetShortExpVector(p.p) : p.sev);
9271 kTest_T(&(strat->T[atT]),strat);
9272}
skStrategy::tmax
int tmax
Definition: kutil.h:350
skStrategy::tailBin
omBin tailBin
Definition: kutil.h:345
enlargeT
static void enlargeT(TSet &T, TObject **&R, unsigned long *&sevT, int &length, const int incr)
Definition: kutil.cc:544
kTest_T
BOOLEAN kTest_T(TObject *T, kStrategy strat, int i, char TN)
Definition: kutil.cc:801
pp_Test
#define pp_Test(p, lmRing, tailRing)
Definition: p_polys.h:161
p_ShallowCopyDelete
static poly p_ShallowCopyDelete(poly p, const ring r, omBin bin)
Definition: p_polys.h:926
p_LmTest
#define p_LmTest(p, r)
Definition: p_polys.h:160
rIsSyzIndexRing
static BOOLEAN rIsSyzIndexRing(const ring r)
Definition: ring.h:720

◆ enterT_strong()

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

Definition at line 9278 of file kutil.cc.

9279{
9280 assume(rField_is_Ring(currRing));
9281 int i;
9282
9283 pp_Test(p.p, currRing, p.tailRing);
9284 assume(strat->tailRing == p.tailRing);
9285 // redMoraNF complains about this -- but, we don't really
9286 // need this so far
9287 assume(p.pLength == 0 || (int)pLength(p.p) == p.pLength || rIsSyzIndexRing(currRing)); // modulo syzring
9288 assume(p.FDeg == p.pFDeg());
9289 assume(!p.is_normalized || nIsOne(pGetCoeff(p.p)));
9290
9291#ifdef KDEBUG
9292 // do not put an LObject twice into T:
9293 for(i=strat->tl;i>=0;i--)
9294 {
9295 if (p.p==strat->T[i].p)
9296 {
9297 printf("already in T at pos %d of %d, atT=%d\n",i,strat->tl,atT);
9298 return;
9299 }
9300 }
9301#endif
9302
9303#ifdef HAVE_TAIL_RING
9304 if (currRing!=strat->tailRing)
9305 {
9306 p.t_p=p.GetLmTailRing();
9307 }
9308#endif
9309 strat->newt = TRUE;
9310 if (atT < 0)
9311 atT = strat->posInT(strat->T, strat->tl, p);
9312 if (strat->tl == strat->tmax-1)
9313 enlargeT(strat->T,strat->R,strat->sevT,strat->tmax,setmaxTinc);
9314 if (atT <= strat->tl)
9315 {
9316#ifdef ENTER_USE_MEMMOVE
9317 memmove(&(strat->T[atT+1]), &(strat->T[atT]),
9318 (strat->tl-atT+1)*sizeof(TObject));
9319 memmove(&(strat->sevT[atT+1]), &(strat->sevT[atT]),
9320 (strat->tl-atT+1)*sizeof(unsigned long));
9321#endif
9322 for (i=strat->tl+1; i>=atT+1; i--)
9323 {
9324#ifndef ENTER_USE_MEMMOVE
9325 strat->T[i] = strat->T[i-1];
9326 strat->sevT[i] = strat->sevT[i-1];
9327#endif
9328 strat->R[strat->T[i].i_r] = &(strat->T[i]);
9329 }
9330 }
9331
9332 if ((strat->tailBin != NULL) && (pNext(p.p) != NULL))
9333 {
9334 pNext(p.p)=p_ShallowCopyDelete(pNext(p.p),
9335 (strat->tailRing != NULL ?
9336 strat->tailRing : currRing),
9337 strat->tailBin);
9338 if (p.t_p != NULL) pNext(p.t_p) = pNext(p.p);
9339 }
9340 strat->T[atT] = (TObject) p;
9341 //printf("\nenterT_strong: add new: length = %i, ecart = %i\n",p.length,p.ecart);
9342
9343 if (pNext(p.p) != NULL)
9344 strat->T[atT].max_exp = p_GetMaxExpP(pNext(p.p), strat->tailRing);
9345 else
9346 strat->T[atT].max_exp = NULL;
9347
9348 strat->tl++;
9349 strat->R[strat->tl] = &(strat->T[atT]);
9350 strat->T[atT].i_r = strat->tl;
9351 assume(p.sev == 0 || pGetShortExpVector(p.p) == p.sev);
9352 strat->sevT[atT] = (p.sev == 0 ? pGetShortExpVector(p.p) : p.sev);
9353 #if 1
9354 if(rHasLocalOrMixedOrdering(currRing)
9355 && !n_IsUnit(p.p->coef, currRing->cf))
9356 {
9357 for(i=strat->tl;i>=0;i--)
9358 {
9359 if(strat->T[i].ecart <= p.ecart && pLmDivisibleBy(strat->T[i].p,p.p))
9360 {
9361 enterOneStrongPoly(i,p.p,p.ecart,0,strat,0 , TRUE);
9362 }
9363 }
9364 }
9365 /*
9366 printf("\nThis is T:\n");
9367 for(i=strat->tl;i>=0;i--)
9368 {
9369 pWrite(strat->T[i].p);
9370 }
9371 //getchar();*/
9372 #endif
9373 kTest_T(&(strat->T[atT]),strat);
9374}
n_IsUnit
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:512
enterOneStrongPoly
static BOOLEAN enterOneStrongPoly(int i, poly p, int, int, kStrategy strat, int atR, bool enterTstrong)
Definition: kutil.cc:1550
pLmDivisibleBy
#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 = -1 
)

Definition at line 13058 of file kutil.cc.

13059{
13060 /* determine how many elements we have to insert */
13061 /* x(0)y(1)z(2) : lastVblock-1=2, to add until lastVblock=uptodeg-1 */
13062 /* hence, a total number of elt's to add is: */
13063 /* int toInsert = 1 + (uptodeg-1) - (pLastVblock(p.p, lV) -1); */
13064 pAssume(p.p != NULL);
13065
13066 int maxPossibleShift = p_mLPmaxPossibleShift(p.p, strat->tailRing);
13067
13068 for (int i = 1; i <= maxPossibleShift; i++)
13069 {
13070 LObject qq;
13071 qq.p = pLPCopyAndShiftLM(p.p, i); // don't use Set() because it'll test the poly order
13072 qq.shift = i;
13073 strat->initEcart(&qq); // initEcartBBA sets length, pLength, FDeg and ecart
13074
13075 enterT(qq, strat, atT); // enterT is modified, so it doesn't copy and delete the tail of shifted polys
13076 }
13077}
pAssume
#define pAssume(cond)
Definition: monomials.h:90
pLPCopyAndShiftLM
#define pLPCopyAndShiftLM(p, sh)
Definition: shiftgb.h:15

◆ exitBuchMora()

void exitBuchMora ( kStrategy  strat)

Definition at line 9885 of file kutil.cc.

9886{
9887 /*- release temp data -*/
9888 cleanT(strat);
9889 omFreeSize(strat->T,(strat->tmax)*sizeof(TObject));
9890 omFreeSize(strat->R,(strat->tmax)*sizeof(TObject*));
9891 omFreeSize(strat->sevT, (strat->tmax)*sizeof(unsigned long));
9892 omFreeSize(strat->ecartS,IDELEMS(strat->Shdl)*sizeof(int));
9893 omFreeSize((ADDRESS)strat->sevS,IDELEMS(strat->Shdl)*sizeof(unsigned long));
9894 omFreeSize(strat->S_2_R,IDELEMS(strat->Shdl)*sizeof(int));
9895 /*- set L: should be empty -*/
9896 omFreeSize(strat->L,(strat->Lmax)*sizeof(LObject));
9897 /*- set B: should be empty -*/
9898 omFreeSize(strat->B,(strat->Bmax)*sizeof(LObject));
9899 pLmFree(&strat->tail);
9900 strat->syzComp=0;
9901
9902#ifdef HAVE_SHIFTBBA
9903 if (rIsLPRing(currRing) && strat->rightGB)
9904 {
9905 if (strat->fromQ!=NULL) omFreeSize(strat->fromQ,IDELEMS(strat->Shdl)*sizeof(int));
9906 strat->fromQ=NULL;
9907 }
9908#endif
9909}
ADDRESS
void * ADDRESS
Definition: auxiliary.h:119

◆ exitSba()

void exitSba ( kStrategy  strat)

Definition at line 10088 of file kutil.cc.

10089{
10090 /*- release temp data -*/
10091 if(rField_is_Ring(currRing))
10092 cleanTSbaRing(strat);
10093 else
10094 cleanT(strat);
10095 omFreeSize(strat->T,(strat->tmax)*sizeof(TObject));
10096 omFreeSize(strat->R,(strat->tmax)*sizeof(TObject*));
10097 omFreeSize(strat->sevT, (strat->tmax)*sizeof(unsigned long));
10098 omFreeSize(strat->ecartS,IDELEMS(strat->Shdl)*sizeof(int));
10099 omFreeSize((ADDRESS)strat->sevS,IDELEMS(strat->Shdl)*sizeof(unsigned long));
10100 omFreeSize((ADDRESS)strat->sevSig,IDELEMS(strat->Shdl)*sizeof(unsigned long));
10101 if(strat->syzmax>0)
10102 {
10103 omFreeSize((ADDRESS)strat->syz,(strat->syzmax)*sizeof(poly));
10104 omFreeSize((ADDRESS)strat->sevSyz,(strat->syzmax)*sizeof(unsigned long));
10105 if (strat->sbaOrder == 1)
10106 {
10107 omFreeSize(strat->syzIdx,(strat->syzidxmax)*sizeof(int));
10108 }
10109 }
10110 omFreeSize(strat->S_2_R,IDELEMS(strat->Shdl)*sizeof(int));
10111 /*- set L: should be empty -*/
10112 omFreeSize(strat->L,(strat->Lmax)*sizeof(LObject));
10113 /*- set B: should be empty -*/
10114 omFreeSize(strat->B,(strat->Bmax)*sizeof(LObject));
10115 /*- set sig: no need for the signatures anymore -*/
10116 omFreeSize(strat->sig,IDELEMS(strat->Shdl)*sizeof(poly));
10117 pLmDelete(&strat->tail);
10118 strat->syzComp=0;
10119}
skStrategy::syzidxmax
int syzidxmax
Definition: kutil.h:349
skStrategy::syzIdx
intset syzIdx
Definition: kutil.h:313
skStrategy::sbaOrder
unsigned sbaOrder
Definition: kutil.h:316
cleanTSbaRing
void cleanTSbaRing(kStrategy strat)
Definition: kutil.cc:624

◆ f5c()

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

Definition at line 4296 of file kstd2.cc.

4299{
4300 int Ll_old, red_result = 1;
4301 int pos = 0;
4302 hilbeledeg=1;
4303 hilbcount=0;
4304 minimcnt=0;
4305 srmax = 0; // strat->sl is 0 at this point
4306 reduc = olddeg = lrmax = 0;
4307 // we cannot use strat->T anymore
4308 //cleanT(strat);
4309 //strat->tl = -1;
4310 Ll_old = strat->Ll;
4311 while (strat->tl >= 0)
4312 {
4313 if(!strat->T[strat->tl].is_redundant)
4314 {
4315 LObject h;
4316 h.p = strat->T[strat->tl].p;
4317 h.tailRing = strat->T[strat->tl].tailRing;
4318 h.t_p = strat->T[strat->tl].t_p;
4319 if (h.p!=NULL)
4320 {
4321 if (currRing->OrdSgn==-1)
4322 {
4323 cancelunit(&h);
4324 deleteHC(&h, strat);
4325 }
4326 if (h.p!=NULL)
4327 {
4328 if (TEST_OPT_INTSTRATEGY)
4329 {
4330 h.pCleardenom(); // also does remove Content
4331 }
4332 else
4333 {
4334 h.pNorm();
4335 }
4336 strat->initEcart(&h);
4337 if(rField_is_Ring(currRing))
4338 pos = posInLF5CRing(strat->L, Ll_old+1,strat->Ll,&h,strat);
4339 else
4340 pos = strat->Ll+1;
4341 h.sev = pGetShortExpVector(h.p);
4342 enterL(&strat->L,&strat->Ll,&strat->Lmax,h,pos);
4343 }
4344 }
4345 }
4346 strat->tl--;
4347 }
4348 strat->sl = -1;
4349#if 0
4350//#ifdef HAVE_TAIL_RING
4351 if(!rField_is_Ring()) // create strong gcd poly computes with tailring and S[i] ->to be fixed
4352 kStratInitChangeTailRing(strat);
4353#endif
4354 //enterpairs(pOne(),0,0,-1,strat,strat->tl);
4355 //strat->sl = -1;
4356 /* picks the last element from the lazyset L */
4357 while (strat->Ll>Ll_old)
4358 {
4359 strat->P = strat->L[strat->Ll];
4360 strat->Ll--;
4361//#if 1
4362#ifdef DEBUGF5
4363 PrintS("NEXT PAIR TO HANDLE IN INTERRED ALGORITHM\n");
4364 PrintS("-------------------------------------------------\n");
4365 pWrite(pHead(strat->P.p));
4366 pWrite(pHead(strat->P.p1));
4367 pWrite(pHead(strat->P.p2));
4368 printf("%d\n",strat->tl);
4369 PrintS("-------------------------------------------------\n");
4370#endif
4371 if (pNext(strat->P.p) == strat->tail)
4372 {
4373 // deletes the short spoly
4374 if (rField_is_Ring(currRing))
4375 pLmDelete(strat->P.p);
4376 else
4377 pLmFree(strat->P.p);
4378
4379 // TODO: needs some masking
4380 // TODO: masking needs to vanish once the signature
4381 // sutff is completely implemented
4382 strat->P.p = NULL;
4383 poly m1 = NULL, m2 = NULL;
4384
4385 // check that spoly creation is ok
4386 while (strat->tailRing != currRing &&
4387 !kCheckSpolyCreation(&(strat->P), strat, m1, m2))
4388 {
4389 assume(m1 == NULL && m2 == NULL);
4390 // if not, change to a ring where exponents are at least
4391 // large enough
4392 if (!kStratChangeTailRing(strat))
4393 {
4394 WerrorS("OVERFLOW...");
4395 break;
4396 }
4397 }
4398 // create the real one
4399 ksCreateSpoly(&(strat->P), NULL, strat->use_buckets,
4400 strat->tailRing, m1, m2, strat->R);
4401 }
4402 else if (strat->P.p1 == NULL)
4403 {
4404 if (strat->minim > 0)
4405 strat->P.p2=p_Copy(strat->P.p, currRing, strat->tailRing);
4406 // for input polys, prepare reduction
4407 if(!rField_is_Ring(currRing))
4408 strat->P.PrepareRed(strat->use_buckets);
4409 }
4410
4411 if (strat->P.p == NULL && strat->P.t_p == NULL)
4412 {
4413 red_result = 0;
4414 }
4415 else
4416 {
4417 if (TEST_OPT_PROT)
4418 message((strat->honey ? strat->P.ecart : 0) + strat->P.pFDeg(),
4419 &olddeg,&reduc,strat, red_result);
4420
4421#ifdef DEBUGF5
4422 PrintS("Poly before red: ");
4423 pWrite(strat->P.p);
4424#endif
4425 /* complete reduction of the element chosen from L */
4426 red_result = strat->red2(&strat->P,strat);
4427 if (errorreported) break;
4428 }
4429
4430 if (strat->overflow)
4431 {
4432 if (!kStratChangeTailRing(strat)) { WerrorS("OVERFLOW.."); break;}
4433 }
4434
4435 // reduction to non-zero new poly
4436 if (red_result == 1)
4437 {
4438 // get the polynomial (canonicalize bucket, make sure P.p is set)
4439 strat->P.GetP(strat->lmBin);
4440 // in the homogeneous case FDeg >= pFDeg (sugar/honey)
4441 // but now, for entering S, T, we reset it
4442 // in the inhomogeneous case: FDeg == pFDeg
4443 if (strat->homog) strat->initEcart(&(strat->P));
4444
4445 /* statistic */
4446 if (TEST_OPT_PROT) PrintS("s");
4447 int pos;
4448 #if 1
4449 if(!rField_is_Ring(currRing))
4450 pos = posInS(strat,strat->sl,strat->P.p,strat->P.ecart);
4451 else
4452 pos = posInSMonFirst(strat,strat->sl,strat->P.p);
4453 #else
4454 pos = posInS(strat,strat->sl,strat->P.p,strat->P.ecart);
4455 #endif
4456 // reduce the tail and normalize poly
4457 // in the ring case we cannot expect LC(f) = 1,
4458#if F5CTAILRED
4459 BOOLEAN withT = TRUE;
4460 if (TEST_OPT_INTSTRATEGY)
4461 {
4462 strat->P.pCleardenom();
4463 if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
4464 {
4465 strat->P.p = redtailBba(&(strat->P),pos-1,strat, withT);
4466 strat->P.pCleardenom();
4467 }
4468 }
4469 else
4470 {
4471 strat->P.pNorm();
4472 if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
4473 strat->P.p = redtailBba(&(strat->P),pos-1,strat, withT);
4474 }
4475#endif
4476#ifdef KDEBUG
4477 if (TEST_OPT_DEBUG){PrintS("new s:");strat->P.wrp();PrintLn();}
4478#endif /* KDEBUG */
4479
4480 // min_std stuff
4481 if ((strat->P.p1==NULL) && (strat->minim>0))
4482 {
4483 if (strat->minim==1)
4484 {
4485 strat->M->m[minimcnt]=p_Copy(strat->P.p,currRing,strat->tailRing);
4486 p_Delete(&strat->P.p2, currRing, strat->tailRing);
4487 }
4488 else
4489 {
4490 strat->M->m[minimcnt]=strat->P.p2;
4491 strat->P.p2=NULL;
4492 }
4493 if (strat->tailRing!=currRing && pNext(strat->M->m[minimcnt])!=NULL)
4494 pNext(strat->M->m[minimcnt])
4495 = strat->p_shallow_copy_delete(pNext(strat->M->m[minimcnt]),
4496 strat->tailRing, currRing,
4497 currRing->PolyBin);
4498 minimcnt++;
4499 }
4500
4501 // enter into S, L, and T
4502 // here we need to recompute new signatures, but those are trivial ones
4503 if ((!TEST_OPT_IDLIFT) || (pGetComp(strat->P.p) <= strat->syzComp))
4504 {
4505 enterT(strat->P, strat);
4506 // posInS only depends on the leading term
4507 strat->enterS(strat->P, pos, strat, strat->tl);
4508//#if 1
4509#ifdef DEBUGF5
4510 PrintS("ELEMENT ADDED TO GCURR DURING INTERRED: ");
4511 pWrite(pHead(strat->S[strat->sl]));
4512 pWrite(strat->sig[strat->sl]);
4513#endif
4514 if (hilb!=NULL) khCheck(Q,w,hilb,hilbeledeg,hilbcount,strat);
4515 }
4516 // Print("[%d]",hilbeledeg);
4517 kDeleteLcm(&strat->P);
4518 if (strat->sl>srmax) srmax = strat->sl;
4519 }
4520 else
4521 {
4522 // adds signature of the zero reduction to
4523 // strat->syz. This is the leading term of
4524 // syzygy and can be used in syzCriterion()
4525 // the signature is added if and only if the
4526 // pair was not detected by the rewritten criterion in strat->red = redSig
4527 if (strat->P.p1 == NULL && strat->minim > 0)
4528 {
4529 p_Delete(&strat->P.p2, currRing, strat->tailRing);
4530 }
4531 }
4532
4533#ifdef KDEBUG
4534 memset(&(strat->P), 0, sizeof(strat->P));
4535#endif /* KDEBUG */
4536 }
4537 int cc = 0;
4538 while (cc<strat->tl+1)
4539 {
4540 strat->T[cc].sig = pOne();
4541 p_SetComp(strat->T[cc].sig,cc+1,currRing);
4542 strat->T[cc].sevSig = pGetShortExpVector(strat->T[cc].sig);
4543 strat->sig[cc] = strat->T[cc].sig;
4544 strat->sevSig[cc] = strat->T[cc].sevSig;
4545 strat->T[cc].is_sigsafe = TRUE;
4546 cc++;
4547 }
4548 strat->max_lower_index = strat->tl;
4549 // set current signature index of upcoming iteration step
4550 // NOTE: this needs to be set here, as otherwise initSyzRules cannot compute
4551 // the corresponding syzygy rules correctly
4552 strat->currIdx = cc+1;
4553 for (int cd=strat->Ll; cd>=0; cd--)
4554 {
4555 p_SetComp(strat->L[cd].sig,cc+1,currRing);
4556 cc++;
4557 }
4558 for (cc=strat->sl+1; cc<IDELEMS(strat->Shdl); ++cc)
4559 strat->Shdl->m[cc] = NULL;
4560 #if 0
4561 printf("\nAfter f5c sorting\n");
4562 for(int i=0;i<=strat->sl;i++)
4563 pWrite(pHead(strat->S[i]));
4564 getchar();
4565 #endif
4566//#if 1
4567#if DEBUGF5
4568 PrintS("------------------- STRAT S ---------------------\n");
4569 cc = 0;
4570 while (cc<strat->tl+1)
4571 {
4572 pWrite(pHead(strat->S[cc]));
4573 pWrite(strat->sig[cc]);
4574 printf("- - - - - -\n");
4575 cc++;
4576 }
4577 PrintS("-------------------------------------------------\n");
4578 PrintS("------------------- STRAT T ---------------------\n");
4579 cc = 0;
4580 while (cc<strat->tl+1)
4581 {
4582 pWrite(pHead(strat->T[cc].p));
4583 pWrite(strat->T[cc].sig);
4584 printf("- - - - - -\n");
4585 cc++;
4586 }
4587 PrintS("-------------------------------------------------\n");
4588 PrintS("------------------- STRAT L ---------------------\n");
4589 cc = 0;
4590 while (cc<strat->Ll+1)
4591 {
4592 pWrite(pHead(strat->L[cc].p));
4593 pWrite(pHead(strat->L[cc].p1));
4594 pWrite(pHead(strat->L[cc].p2));
4595 pWrite(strat->L[cc].sig);
4596 printf("- - - - - -\n");
4597 cc++;
4598 }
4599 PrintS("-------------------------------------------------\n");
4600 printf("F5C DONE\nSTRAT SL: %d -- %d\n",strat->sl, strat->currIdx);
4601#endif
4602
4603}
cd
CanonicalForm cd(bCommonDen(FF))
Definition: cfModGcd.cc:4089
skStrategy::currIdx
int currIdx
Definition: kutil.h:317
skStrategy::red2
int(* red2)(LObject *L, kStrategy strat)
Definition: kutil.h:279
skStrategy::max_lower_index
int max_lower_index
Definition: kutil.h:318
posInSMonFirst
int posInSMonFirst(const kStrategy strat, const int length, const poly p)
Definition: kutil.cc:4786
posInLF5CRing
int posInLF5CRing(const LSet set, int start, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:5910
cancelunit
void cancelunit(LObject *L, BOOLEAN inNF)
Definition: kutil.cc:373

◆ faugereRewCriterion()

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

Definition at line 6605 of file kutil.cc.

6606{
6607 //printf("Faugere Rewritten Criterion\n");
6608 if(rField_is_Ring(currRing))
6609 return FALSE;
6610//#if 1
6611#ifdef DEBUGF5
6612 PrintS("rewritten criterion checks: ");
6613 pWrite(sig);
6614#endif
6615 for(int k = strat->sl; k>=start; k--)
6616 {
6617//#if 1
6618#ifdef DEBUGF5
6619 PrintS("checking with: ");
6620 pWrite(strat->sig[k]);
6621 pWrite(pHead(strat->S[k]));
6622#endif
6623 if (p_LmShortDivisibleBy(strat->sig[k], strat->sevSig[k], sig, not_sevSig, currRing))
6624 {
6625//#if 1
6626#ifdef DEBUGF5
6627 PrintS("DELETE!\n");
6628#endif
6629 strat->nrrewcrit++;
6630 return TRUE;
6631 }
6632 //k--;
6633 }
6634#ifdef DEBUGF5
6635 PrintS("ALL ELEMENTS OF S\n----------------------------------------\n");
6636 for(int kk = 0; kk<strat->sl+1; kk++)
6637 {
6638 pWrite(pHead(strat->S[kk]));
6639 }
6640 PrintS("------------------------------\n");
6641#endif
6642 return FALSE;
6643}
skStrategy::nrrewcrit
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 10928 of file kutil.cc.

10929{
10930 assume(strat->tl<0); /* can only be called with no elements in T:
10931 i.e. after exitBuchMora */
10932 /* do not use strat->S, strat->sl as they may be out of sync*/
10933 if(!nCoeff_is_Z(currRing->cf))
10934 return;
10935 poly p,pp;
10936 for(int j = 0; j<IDELEMS(strat->Shdl); j++)
10937 {
10938 if((strat->Shdl->m[j]!=NULL)&&(pNext(strat->Shdl->m[j]) == NULL))
10939 {
10940 for(int i = 0; i<IDELEMS(strat->Shdl); i++)
10941 {
10942 if((i != j) && (strat->Shdl->m[i] != NULL))
10943 {
10944 p = strat->Shdl->m[i];
10945 while((p!=NULL) && (pLmDivisibleBy(strat->Shdl->m[j], p)
10946#if HAVE_SHIFTBBA
10947 || (rIsLPRing(currRing) && pLPLmDivisibleBy(strat->Shdl->m[j], p))
10948#endif
10949 ))
10950 {
10951 number dummy = n_IntMod(p->coef, strat->Shdl->m[j]->coef, currRing->cf);
10952 if (!nEqual(dummy,p->coef))
10953 {
10954 if (nIsZero(dummy))
10955 {
10956 nDelete(&dummy);
10957 pLmDelete(&strat->Shdl->m[i]);
10958 p=strat->Shdl->m[i];
10959 }
10960 else
10961 {
10962 p_SetCoeff(p,dummy,currRing);
10963 break;
10964 }
10965 }
10966 else
10967 {
10968 nDelete(&dummy);
10969 break;
10970 }
10971 }
10972 if (p!=NULL)
10973 {
10974 pp = pNext(p);
10975 while(pp != NULL)
10976 {
10977 if(pLmDivisibleBy(strat->Shdl->m[j], pp)
10978#if HAVE_SHIFTBBA
10979 || (rIsLPRing(currRing) && pLPLmDivisibleBy(strat->Shdl->m[j], pp))
10980#endif
10981 )
10982 {
10983 number dummy = n_IntMod(pp->coef, strat->Shdl->m[j]->coef, currRing->cf);
10984 if (!nEqual(dummy,pp->coef))
10985 {
10986 p_SetCoeff(pp,dummy,currRing);
10987 if(nIsZero(pp->coef))
10988 {
10989 pLmDelete(&pNext(p));
10990 pp = pNext(p);
10991 }
10992 else
10993 {
10994 p = pp;
10995 pp = pNext(p);
10996 }
10997 }
10998 else
10999 {
11000 nDelete(&dummy);
11001 p = pp;
11002 pp = pNext(p);
11003 }
11004 }
11005 else
11006 {
11007 p = pp;
11008 pp = pNext(p);
11009 }
11010 }
11011 }
11012 }
11013 }
11014 //idPrint(strat->Shdl);
11015 }
11016 }
11017 idSkipZeroes(strat->Shdl);
11018}
nCoeff_is_Z
static FORCE_INLINE BOOLEAN nCoeff_is_Z(const coeffs r)
Definition: coeffs.h:813
n_IntMod
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:625
nEqual
#define nEqual(n1, n2)
Definition: numbers.h:20
p_SetCoeff
static number p_SetCoeff(poly p, number n, ring r)
Definition: p_polys.h:410
pLPLmDivisibleBy
#define pLPLmDivisibleBy(a, b)
Definition: shiftop.h:58
idSkipZeroes
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
Definition: simpleideals.cc:181

◆ findMinLMPair()

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

◆ HEckeTest()

void HEckeTest ( poly  pp,
kStrategy  strat 
)

Definition at line 501 of file kutil.cc.

502{
503 int j,/*k,*/p;
504
505 if (currRing->pLexOrder
506 || rHasMixedOrdering(currRing)
507 || (strat->ak >1)
508 || (rField_is_Ring(currRing) && (!n_IsUnit(pGetCoeff(pp),currRing->cf))))
509 {
510 return;
511 }
512 p=pIsPurePower(pp);
513 if (p!=0)
514 strat->NotUsedAxis[p] = FALSE;
515 /*- the leading term of pp is a power of the p-th variable -*/
516 for (j=(currRing->N);j>0; j--)
517 {
518 if (strat->NotUsedAxis[j])
519 {
520 strat->kAllAxis=FALSE;
521 return;
522 }
523 }
524 strat->kAllAxis=TRUE;
525}
skStrategy::NotUsedAxis
BOOLEAN * NotUsedAxis
Definition: kutil.h:332
skStrategy::kAllAxis
char kAllAxis
Definition: kutil.h:376
pIsPurePower
#define pIsPurePower(p)
Definition: polys.h:248
rHasMixedOrdering
BOOLEAN rHasMixedOrdering(const ring r)
Definition: ring.h:761

◆ homogTest()

BOOLEAN homogTest ( polyset  F,
int  Fmax 
)

◆ initBba()

void initBba ( kStrategy  strat)

Definition at line 1689 of file kstd1.cc.

1690{
1691 /* setting global variables ------------------- */
1692 strat->enterS = enterSBba;
1693 strat->red = redHoney;
1694 if (strat->honey)
1695 strat->red = redHoney;
1696 else if (currRing->pLexOrder && !strat->homog)
1697 strat->red = redLazy;
1698 else
1699 {
1700 strat->LazyPass *=4;
1701 strat->red = redHomog;
1702 }
1703 if (rField_is_Ring(currRing))
1704 {
1705 if (rField_is_Z(currRing))
1706 strat->red = redRing_Z;
1707 else
1708 strat->red = redRing;
1709 }
1710 if (TEST_OPT_IDLIFT)
1711 strat->red=redLiftstd;
1712 if (currRing->pLexOrder && strat->honey)
1713 strat->initEcart = initEcartNormal;
1714 else
1715 strat->initEcart = initEcartBBA;
1716 if (strat->honey)
1717 strat->initEcartPair = initEcartPairMora;
1718 else
1719 strat->initEcartPair = initEcartPairBba;
1720// if ((TEST_OPT_WEIGHTM)&&(F!=NULL))
1721// {
1722// //interred machen Aenderung
1723// strat->pOrigFDeg=pFDeg;
1724// strat->pOrigLDeg=pLDeg;
1725// //h=ggetid("ecart");
1726// //if ((h!=NULL) /*&& (IDTYP(h)==INTVEC_CMD)*/)
1727// //{
1728// // ecartWeights=iv2array(IDINTVEC(h));
1729// //}
1730// //else
1731// {
1732// ecartWeights=(short *)omAlloc(((currRing->N)+1)*sizeof(short));
1733// /*uses automatic computation of the ecartWeights to set them*/
1734// kEcartWeights(F->m,IDELEMS(F)-1,ecartWeights);
1735// }
1736// pRestoreDegProcs(currRing,totaldegreeWecart, maxdegreeWecart);
1737// if (TEST_OPT_PROT)
1738// {
1739// for(i=1; i<=(currRing->N); i++)
1740// Print(" %d",ecartWeights[i]);
1741// PrintLn();
1742// mflush();
1743// }
1744// }
1745}
skStrategy::LazyPass
int LazyPass
Definition: kutil.h:353
redLiftstd
int redLiftstd(LObject *h, kStrategy strat)
Definition: kLiftstd.cc:167
redRing_Z
int redRing_Z(LObject *h, kStrategy strat)
Definition: kstd2.cc:683
redHoney
int redHoney(LObject *h, kStrategy strat)
Definition: kstd2.cc:2088
redHomog
int redHomog(LObject *h, kStrategy strat)
Definition: kstd2.cc:1121
redLazy
int redLazy(LObject *h, kStrategy strat)
Definition: kstd2.cc:1881
initEcartPairMora
void initEcartPairMora(LObject *Lp, poly, poly, int ecartF, int ecartG)
Definition: kutil.cc:1326
initEcartNormal
void initEcartNormal(TObject *h)
Definition: kutil.cc:1304
initEcartBBA
void initEcartBBA(TObject *h)
Definition: kutil.cc:1312
initEcartPairBba
void initEcartPairBba(LObject *Lp, poly, poly, int, int)
Definition: kutil.cc:1319

◆ initBuchMora()

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

Definition at line 9800 of file kutil.cc.

9801{
9802 strat->interpt = BTEST1(OPT_INTERRUPT);
9803 /*- creating temp data structures------------------- -*/
9804 //strat->cp = 0; // already by skStragy()
9805 //strat->c3 = 0; // already by skStragy()
9806#ifdef HAVE_SHIFTBBA
9807 strat->cv = 0; // already by skStragy()
9808#endif
9809 strat->tail = pInit();
9810 /*- set s -*/
9811 strat->sl = -1;
9812 /*- set L -*/
9813 strat->Lmax = ((IDELEMS(F)+setmaxLinc-1)/setmaxLinc)*setmaxLinc;
9814 strat->Ll = -1;
9815 strat->L = initL(strat->Lmax);
9816 /*- set B -*/
9817 strat->Bmax = setmaxL;
9818 strat->Bl = -1;
9819 strat->B = initL();
9820 /*- set T -*/
9821 strat->tl = -1;
9822 strat->tmax = setmaxT;
9823 strat->T = initT();
9824 strat->R = initR();
9825 strat->sevT = initsevT();
9826 /*- init local data struct.---------------------------------------- -*/
9827 //strat->P.ecart=0; // already by skStragy()
9828 //strat->P.length=0; // already by skStragy()
9829 //strat->P.pLength=0; // already by skStragy()
9830 if (rHasLocalOrMixedOrdering(currRing))
9831 {
9832 if (strat->kNoether!=NULL)
9833 {
9834 pSetComp(strat->kNoether, strat->ak);
9835 pSetComp(strat->kNoetherTail(), strat->ak);
9836 }
9837 }
9838 if(rField_is_Ring(currRing))
9839 {
9840 /*Shdl=*/initSL(F, Q,strat); /*sets also S, ecartS, fromQ */
9841 }
9842 else
9843 {
9844 if(TEST_OPT_SB_1)
9845 {
9846 int i;
9847 ideal P=idInit(IDELEMS(F)-strat->newIdeal,F->rank);
9848 for (i=strat->newIdeal;i<IDELEMS(F);i++)
9849 {
9850 P->m[i-strat->newIdeal] = F->m[i];
9851 F->m[i] = NULL;
9852 }
9853 initSSpecial(F,Q,P,strat);
9854 for (i=strat->newIdeal;i<IDELEMS(F);i++)
9855 {
9856 F->m[i] = P->m[i-strat->newIdeal];
9857 P->m[i-strat->newIdeal] = NULL;
9858 }
9859 idDelete(&P);
9860 }
9861 else
9862 {
9863 /*Shdl=*/initSL(F, Q,strat); /*sets also S, ecartS, fromQ */
9864 // /*Shdl=*/initS(F, Q,strat); /*sets also S, ecartS, fromQ */
9865 }
9866 }
9867 strat->fromT = FALSE;
9868 strat->noTailReduction = !TEST_OPT_REDTAIL;
9869 if ((!TEST_OPT_SB_1)
9870 || (rField_is_Ring(currRing))
9871 )
9872 {
9873 updateS(TRUE,strat);
9874 }
9875#ifdef HAVE_SHIFTBBA
9876 if (!(rIsLPRing(currRing) && strat->rightGB)) // for right GB, we need to check later whether a poly is from Q
9877#endif
9878 {
9879 if (strat->fromQ!=NULL) omFreeSize(strat->fromQ,IDELEMS(strat->Shdl)*sizeof(int));
9880 strat->fromQ=NULL;
9881 }
9882 assume(kTest_TS(strat));
9883}
skStrategy::newIdeal
int newIdeal
Definition: kutil.h:356
idDelete
#define idDelete(H)
delete an ideal
Definition: ideals.h:29
initT
KINLINE TSet initT()
Definition: kInline.h:84
initR
KINLINE TObject ** initR()
Definition: kInline.h:95
initsevT
KINLINE unsigned long * initsevT()
Definition: kInline.h:100
initSSpecial
void initSSpecial(ideal F, ideal Q, ideal P, kStrategy strat)
Definition: kutil.cc:8131
updateS
void updateS(BOOLEAN toT, kStrategy strat)
Definition: kutil.cc:8594
initSL
void initSL(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:7729
setmaxL
#define setmaxL
Definition: kutil.h:30
initL
static LSet initL(int nr=setmaxL)
Definition: kutil.h:420
setmaxT
#define setmaxT
Definition: kutil.h:33
OPT_INTERRUPT
#define OPT_INTERRUPT
Definition: options.h:80
BTEST1
#define BTEST1(a)
Definition: options.h:34
pSetComp
#define pSetComp(p, v)
Definition: polys.h:38

◆ initBuchMoraCrit()

void initBuchMoraCrit ( kStrategy  strat)

Definition at line 9476 of file kutil.cc.

9477{
9478 strat->enterOnePair=enterOnePairNormal;
9479 strat->chainCrit=chainCritNormal;
9480 if (TEST_OPT_SB_1)
9481 strat->chainCrit=chainCritOpt_1;
9482#ifdef HAVE_RINGS
9483 if (rField_is_Ring(currRing))
9484 {
9485 strat->enterOnePair=enterOnePairRing;
9486 strat->chainCrit=chainCritRing;
9487 }
9488#endif
9489#ifdef HAVE_RATGRING
9490 if (rIsRatGRing(currRing))
9491 {
9492 strat->chainCrit=chainCritPart;
9493 /* enterOnePairNormal get rational part in it */
9494 }
9495#endif
9496 if (TEST_OPT_IDLIFT
9497 && (strat->syzComp==1)
9498 && (!rIsPluralRing(currRing)))
9499 strat->enterOnePair=enterOnePairLift;
9500
9501 strat->sugarCrit = TEST_OPT_SUGARCRIT;
9502 strat->Gebauer = strat->homog || strat->sugarCrit;
9503 strat->honey = !strat->homog || strat->sugarCrit || TEST_OPT_WEIGHTM;
9504 if (TEST_OPT_NOT_SUGAR) strat->honey = FALSE;
9505 strat->pairtest = NULL;
9506 /* always use tailreduction, except:
9507 * - in local rings, - in lex order case, -in ring over extensions */
9508 strat->noTailReduction = !TEST_OPT_REDTAIL;
9509 //if(rHasMixedOrdering(currRing)==2)
9510 //{
9511 // strat->noTailReduction =TRUE;
9512 //}
9513
9514#ifdef HAVE_PLURAL
9515 // and r is plural_ring
9516 // hence this holds for r a rational_plural_ring
9517 if( rIsPluralRing(currRing) || (rIsSCA(currRing) && !strat->z2homog) )
9518 { //or it has non-quasi-comm type... later
9519 strat->sugarCrit = FALSE;
9520 strat->Gebauer = FALSE;
9521 strat->honey = FALSE;
9522 }
9523#endif
9524
9525 // Coefficient ring?
9526 if (rField_is_Ring(currRing))
9527 {
9528 strat->sugarCrit = FALSE;
9529 strat->Gebauer = FALSE;
9530 strat->honey = FALSE;
9531 }
9532 #ifdef KDEBUG
9533 if (TEST_OPT_DEBUG)
9534 {
9535 if (strat->homog) PrintS("ideal/module is homogeneous\n");
9536 else PrintS("ideal/module is not homogeneous\n");
9537 }
9538 #endif
9539}
skStrategy::chainCrit
void(* chainCrit)(poly p, int ecart, kStrategy strat)
Definition: kutil.h:291
skStrategy::z2homog
char z2homog
Definition: kutil.h:374
skStrategy::enterOnePair
void(* enterOnePair)(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR)
Definition: kutil.h:290
enterOnePairNormal
void enterOnePairNormal(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR=-1)
Definition: kutil.cc:1952
chainCritOpt_1
void chainCritOpt_1(poly, int, kStrategy strat)
Definition: kutil.cc:3458
enterOnePairRing
static void enterOnePairRing(int i, poly p, int, int isFromQ, kStrategy strat, int atR)
Definition: kutil.cc:1346
enterOnePairLift
static void enterOnePairLift(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR=-1)
Definition: kutil.cc:2234
chainCritPart
void chainCritPart(poly p, int ecart, kStrategy strat)
Definition: kutil.cc:3533
chainCritNormal
void chainCritNormal(poly p, int ecart, kStrategy strat)
Definition: kutil.cc:3217
chainCritRing
void chainCritRing(poly p, int, kStrategy strat)
Definition: kutil.cc:4009
rIsSCA
static bool rIsSCA(const ring r)
Definition: nc.h:190
TEST_OPT_WEIGHTM
#define TEST_OPT_WEIGHTM
Definition: options.h:122
TEST_OPT_SUGARCRIT
#define TEST_OPT_SUGARCRIT
Definition: options.h:108
TEST_OPT_NOT_SUGAR
#define TEST_OPT_NOT_SUGAR
Definition: options.h:107

◆ initBuchMoraPos()

void initBuchMoraPos ( kStrategy  strat)

Definition at line 9627 of file kutil.cc.

9628{
9629 if (rHasGlobalOrdering(currRing))
9630 {
9631 if (strat->honey)
9632 {
9633 strat->posInL = posInL15;
9634 // ok -- here is the deal: from my experiments for Singular-2-0
9635 // I conclude that that posInT_EcartpLength is the best of
9636 // posInT15, posInT_EcartFDegpLength, posInT_FDegLength, posInT_pLength
9637 // see the table at the end of this file
9638 if (TEST_OPT_OLDSTD)
9639 strat->posInT = posInT15;
9640 else
9641 strat->posInT = posInT_EcartpLength;
9642 }
9643 else if (currRing->pLexOrder && !TEST_OPT_INTSTRATEGY)
9644 {
9645 strat->posInL = posInL11;
9646 strat->posInT = posInT11;
9647 }
9648 else if (TEST_OPT_INTSTRATEGY)
9649 {
9650 strat->posInL = posInL11;
9651 strat->posInT = posInT11;
9652 }
9653 else
9654 {
9655 strat->posInL = posInL0;
9656 strat->posInT = posInT0;
9657 }
9658 //if (strat->minim>0) strat->posInL =posInLSpecial;
9659 if (strat->homog)
9660 {
9661 strat->posInL = posInL110;
9662 strat->posInT = posInT110;
9663 }
9664 }
9665 else /* local/mixed ordering */
9666 {
9667 if (strat->homog)
9668 {
9669 strat->posInL = posInL11;
9670 strat->posInT = posInT11;
9671 }
9672 else
9673 {
9674 if ((currRing->order[0]==ringorder_c)
9675 ||(currRing->order[0]==ringorder_C))
9676 {
9677 strat->posInL = posInL17_c;
9678 strat->posInT = posInT17_c;
9679 }
9680 else
9681 {
9682 strat->posInL = posInL17;
9683 strat->posInT = posInT17;
9684 }
9685 }
9686 }
9687 if (strat->minim>0) strat->posInL =posInLSpecial;
9688 // for further tests only
9689 if ((BTEST1(11)) || (BTEST1(12)))
9690 strat->posInL = posInL11;
9691 else if ((BTEST1(13)) || (BTEST1(14)))
9692 strat->posInL = posInL13;
9693 else if ((BTEST1(15)) || (BTEST1(16)))
9694 strat->posInL = posInL15;
9695 else if ((BTEST1(17)) || (BTEST1(18)))
9696 strat->posInL = posInL17;
9697 if (BTEST1(11))
9698 strat->posInT = posInT11;
9699 else if (BTEST1(13))
9700 strat->posInT = posInT13;
9701 else if (BTEST1(15))
9702 strat->posInT = posInT15;
9703 else if ((BTEST1(17)))
9704 strat->posInT = posInT17;
9705 else if ((BTEST1(19)))
9706 strat->posInT = posInT19;
9707 else if (BTEST1(12) || BTEST1(14) || BTEST1(16) || BTEST1(18))
9708 strat->posInT = posInT1;
9709 strat->posInLDependsOnLength = kPosInLDependsOnLength(strat->posInL);
9710}
skStrategy::posInLDependsOnLength
char posInLDependsOnLength
Definition: kutil.h:389
posInL110
int posInL110(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:6093
posInT17
int posInT17(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5306
posInT11
int posInT11(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4975
posInT1
int posInT1(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4918
posInT_EcartpLength
int posInT_EcartpLength(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5172
posInT0
int posInT0(const TSet, const int length, LObject &)
Definition: kutil.cc:4907
posInL13
int posInL13(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:6182
kPosInLDependsOnLength
BOOLEAN kPosInLDependsOnLength(int(*pos_in_l)(const LSet set, const int length, LObject *L, const kStrategy strat))
Definition: kutil.cc:9612
posInT13
int posInT13(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5143
posInL0
int posInL0(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:5643
posInL15
int posInL15(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:6217
posInT17_c
int posInT17_c(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5414
posInT15
int posInT15(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5210
posInLSpecial
int posInLSpecial(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:5599
posInL17
int posInL17(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:6294
posInT110
int posInT110(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5053
posInT19
int posInT19(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5542
posInL17_c
int posInL17_c(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:6389
posInL11
int posInL11(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:5833
ringorder_C
@ ringorder_C
Definition: ring.h:73
ringorder_c
@ ringorder_c
Definition: ring.h:72

◆ initBuchMoraPosRing()

void initBuchMoraPosRing ( kStrategy  strat)

Definition at line 9713 of file kutil.cc.

9714{
9715 if (rHasGlobalOrdering(currRing))
9716 {
9717 if (strat->honey)
9718 {
9719 strat->posInL = posInL15Ring;
9720 // ok -- here is the deal: from my experiments for Singular-2-0
9721 // I conclude that that posInT_EcartpLength is the best of
9722 // posInT15, posInT_EcartFDegpLength, posInT_FDegLength, posInT_pLength
9723 // see the table at the end of this file
9724 if (TEST_OPT_OLDSTD)
9725 strat->posInT = posInT15Ring;
9726 else
9727 strat->posInT = posInT_EcartpLength;
9728 }
9729 else if (currRing->pLexOrder && !TEST_OPT_INTSTRATEGY)
9730 {
9731 strat->posInL = posInL11Ring;
9732 strat->posInT = posInT11;
9733 }
9734 else if (TEST_OPT_INTSTRATEGY)
9735 {
9736 strat->posInL = posInL11Ring;
9737 strat->posInT = posInT11;
9738 }
9739 else
9740 {
9741 strat->posInL = posInL0Ring;
9742 strat->posInT = posInT0;
9743 }
9744 //if (strat->minim>0) strat->posInL =posInLSpecial;
9745 if (strat->homog)
9746 {
9747 strat->posInL = posInL110Ring;
9748 strat->posInT = posInT110Ring;
9749 }
9750 }
9751 else
9752 {
9753 if (strat->homog)
9754 {
9755 //printf("\nHere 3\n");
9756 strat->posInL = posInL11Ring;
9757 strat->posInT = posInT11Ring;
9758 }
9759 else
9760 {
9761 if ((currRing->order[0]==ringorder_c)
9762 ||(currRing->order[0]==ringorder_C))
9763 {
9764 strat->posInL = posInL17_cRing;
9765 strat->posInT = posInT17_cRing;
9766 }
9767 else
9768 {
9769 strat->posInL = posInL11Ringls;
9770 strat->posInT = posInT17Ring;
9771 }
9772 }
9773 }
9774 if (strat->minim>0) strat->posInL =posInLSpecial;
9775 // for further tests only
9776 if ((BTEST1(11)) || (BTEST1(12)))
9777 strat->posInL = posInL11Ring;
9778 else if ((BTEST1(13)) || (BTEST1(14)))
9779 strat->posInL = posInL13;
9780 else if ((BTEST1(15)) || (BTEST1(16)))
9781 strat->posInL = posInL15Ring;
9782 else if ((BTEST1(17)) || (BTEST1(18)))
9783 strat->posInL = posInL17Ring;
9784 if (BTEST1(11))
9785 strat->posInT = posInT11Ring;
9786 else if (BTEST1(13))
9787 strat->posInT = posInT13;
9788 else if (BTEST1(15))
9789 strat->posInT = posInT15Ring;
9790 else if ((BTEST1(17)))
9791 strat->posInT = posInT17Ring;
9792 else if ((BTEST1(19)))
9793 strat->posInT = posInT19;
9794 else if (BTEST1(12) || BTEST1(14) || BTEST1(16) || BTEST1(18))
9795 strat->posInT = posInT1;
9796 strat->posInLDependsOnLength = kPosInLDependsOnLength(strat->posInL);
9797}
posInL17Ring
int posInL17Ring(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:6339
posInL17_cRing
int posInL17_cRing(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:6454
posInL11Ring
int posInL11Ring(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:5876
posInT110Ring
int posInT110Ring(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5096
posInL110Ring
int posInL110Ring(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:6135
posInL0Ring
int posInL0Ring(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:5671
posInT11Ring
int posInT11Ring(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5012
posInL11Ringls
int posInL11Ringls(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:5946
posInL15Ring
int posInL15Ring(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:6253
posInT15Ring
int posInT15Ring(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5265
posInT17Ring
int posInT17Ring(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5368
posInT17_cRing
int posInT17_cRing(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5476

◆ initEcartBBA()

void initEcartBBA ( TObject *  h)

Definition at line 1312 of file kutil.cc.

1313{
1314 h->FDeg = h->pFDeg();
1315 (*h).ecart = 0;
1316 h->length=h->pLength=pLength(h->p);
1317}

◆ initEcartNormal()

void initEcartNormal ( TObject *  h)

Definition at line 1304 of file kutil.cc.

1305{
1306 h->FDeg = h->pFDeg();
1307 h->ecart = h->pLDeg() - h->FDeg;
1308 // h->length is set by h->pLDeg
1309 h->length=h->pLength=pLength(h->p);
1310}

◆ initEcartPairBba()

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

Definition at line 1319 of file kutil.cc.

1320{
1321 Lp->FDeg = Lp->pFDeg();
1322 (*Lp).ecart = 0;
1323 (*Lp).length = 0;
1324}

◆ initEcartPairMora()

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

Definition at line 1326 of file kutil.cc.

1327{
1328 Lp->FDeg = Lp->pFDeg();
1329 (*Lp).ecart = si_max(ecartF,ecartG);
1330 (*Lp).ecart = (*Lp).ecart- (Lp->FDeg -p_FDeg((*Lp).lcm,currRing));
1331 (*Lp).length = 0;
1332}
p_FDeg
static long p_FDeg(const poly p, const ring r)
Definition: p_polys.h:378

◆ initenterpairs()

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

Definition at line 3822 of file kutil.cc.

3823{
3824
3825 if ((strat->syzComp==0)
3826 || (pGetComp(h)<=strat->syzComp))
3827 {
3828 int j;
3829 BOOLEAN new_pair=FALSE;
3830
3831 if (pGetComp(h)==0)
3832 {
3833 /* for Q!=NULL: build pairs (f,q),(f1,f2), but not (q1,q2)*/
3834 if ((isFromQ)&&(strat->fromQ!=NULL))
3835 {
3836 for (j=0; j<=k; j++)
3837 {
3838 if (!strat->fromQ[j])
3839 {
3840 new_pair=TRUE;
3841 strat->enterOnePair(j,h,ecart,isFromQ,strat, atR);
3842 //Print("j:%d, Ll:%d\n",j,strat->Ll);
3843 }
3844 }
3845 }
3846 else
3847 {
3848 new_pair=TRUE;
3849 for (j=0; j<=k; j++)
3850 {
3851 strat->enterOnePair(j,h,ecart,isFromQ,strat, atR);
3852 //Print("j:%d, Ll:%d\n",j,strat->Ll);
3853 }
3854 }
3855 }
3856 else
3857 {
3858 for (j=0; j<=k; j++)
3859 {
3860 if ((pGetComp(h)==pGetComp(strat->S[j]))
3861 || (pGetComp(strat->S[j])==0))
3862 {
3863 new_pair=TRUE;
3864 strat->enterOnePair(j,h,ecart,isFromQ,strat, atR);
3865 //Print("j:%d, Ll:%d\n",j,strat->Ll);
3866 }
3867 }
3868 }
3869 if (new_pair)
3870 {
3871 #ifdef HAVE_RATGRING
3872 if (currRing->real_var_start>0)
3873 chainCritPart(h,ecart,strat);
3874 else
3875 #endif
3876 strat->chainCrit(h,ecart,strat);
3877 }
3878 kMergeBintoL(strat);
3879 }
3880}

◆ initHilbCrit()

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

Definition at line 9458 of file kutil.cc.

9459{
9460
9461 //if the ordering is local, then hilb criterion
9462 //can be used also if the ideal is not homogeneous
9463 if((rHasLocalOrMixedOrdering(currRing)) && (rHasMixedOrdering(currRing)==FALSE))
9464 {
9465 if(rField_is_Ring(currRing))
9466 *hilb=NULL;
9467 else
9468 return;
9469 }
9470 if (strat->homog!=isHomog)
9471 {
9472 *hilb=NULL;
9473 }
9474}
isHomog
@ isHomog
Definition: structs.h:37

◆ initL()

static LSet initL ( int  nr = setmaxL)
inlinestatic

Definition at line 420 of file kutil.h.

421{ return (LSet)omAlloc(nr*sizeof(LObject)); }
LSet
LObject * LSet
Definition: kutil.h:60

◆ initR()

KINLINE TObject ** initR ( )

Definition at line 95 of file kInline.h.

96{
97 return (TObject**) omAlloc0(setmaxT*sizeof(TObject*));
98}
omAlloc0
#define omAlloc0(size)
Definition: omAllocDecl.h:211

◆ initS()

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

Definition at line 7635 of file kutil.cc.

7636{
7637 int i,pos;
7638
7639 if (Q!=NULL) i=((IDELEMS(F)+IDELEMS(Q)+(setmaxTinc-1))/setmaxTinc)*setmaxTinc;
7640 else i=((IDELEMS(F)+(setmaxTinc-1))/setmaxTinc)*setmaxTinc;
7641 strat->ecartS=initec(i);
7642 strat->sevS=initsevS(i);
7643 strat->S_2_R=initS_2_R(i);
7644 strat->fromQ=NULL;
7645 strat->Shdl=idInit(i,F->rank);
7646 strat->S=strat->Shdl->m;
7647 /*- put polys into S -*/
7648 if (Q!=NULL)
7649 {
7650 strat->fromQ=initec(i);
7651 memset(strat->fromQ,0,i*sizeof(int));
7652 for (i=0; i<IDELEMS(Q); i++)
7653 {
7654 if (Q->m[i]!=NULL)
7655 {
7656 LObject h;
7657 h.p = pCopy(Q->m[i]);
7658 if (TEST_OPT_INTSTRATEGY)
7659 {
7660 h.pCleardenom(); // also does remove Content
7661 }
7662 else
7663 {
7664 h.pNorm();
7665 }
7666 if (rHasLocalOrMixedOrdering(currRing))
7667 {
7668 deleteHC(&h, strat);
7669 }
7670 if (h.p!=NULL)
7671 {
7672 strat->initEcart(&h);
7673 if (strat->sl==-1)
7674 pos =0;
7675 else
7676 {
7677 pos = posInS(strat,strat->sl,h.p,h.ecart);
7678 }
7679 h.sev = pGetShortExpVector(h.p);
7680 strat->enterS(h,pos,strat,-1);
7681 strat->fromQ[pos]=1;
7682 }
7683 }
7684 }
7685 }
7686 for (i=0; i<IDELEMS(F); i++)
7687 {
7688 if (F->m[i]!=NULL)
7689 {
7690 LObject h;
7691 h.p = pCopy(F->m[i]);
7692 if (rHasLocalOrMixedOrdering(currRing))
7693 {
7694 cancelunit(&h); /*- tries to cancel a unit -*/
7695 deleteHC(&h, strat);
7696 }
7697 if (h.p!=NULL)
7698 // do not rely on the input being a SB!
7699 {
7700 if (TEST_OPT_INTSTRATEGY)
7701 {
7702 h.pCleardenom(); // also does remove Content
7703 }
7704 else
7705 {
7706 h.pNorm();
7707 }
7708 strat->initEcart(&h);
7709 if (strat->sl==-1)
7710 pos =0;
7711 else
7712 pos = posInS(strat,strat->sl,h.p,h.ecart);
7713 h.sev = pGetShortExpVector(h.p);
7714 strat->enterS(h,pos,strat,-1);
7715 }
7716 }
7717 }
7718 /*- test, if a unit is in F -*/
7719 if ((strat->sl>=0)
7720#ifdef HAVE_RINGS
7721 && n_IsUnit(pGetCoeff(strat->S[0]),currRing->cf)
7722#endif
7723 && pIsConstant(strat->S[0]))
7724 {
7725 while (strat->sl>0) deleteInS(strat->sl,strat);
7726 }
7727}
initec
static intset initec(const int maxnr)
Definition: kutil.cc:530
initS_2_R
static int * initS_2_R(const int maxnr)
Definition: kutil.cc:539
initsevS
static unsigned long * initsevS(const int maxnr)
Definition: kutil.cc:535
pIsConstant
#define pIsConstant(p)
like above, except that Comp must be 0
Definition: polys.h:238

◆ initSba()

void initSba ( ideal  F,
kStrategy  strat 
)

Definition at line 1747 of file kstd1.cc.

1748{
1749 int i;
1750 //idhdl h;
1751 /* setting global variables ------------------- */
1752 strat->enterS = enterSSba;
1753 strat->red2 = redHoney;
1754 if (strat->honey)
1755 strat->red2 = redHoney;
1756 else if (currRing->pLexOrder && !strat->homog)
1757 strat->red2 = redLazy;
1758 else
1759 {
1760 strat->LazyPass *=4;
1761 strat->red2 = redHomog;
1762 }
1763 if (rField_is_Ring(currRing))
1764 {
1765 if(rHasLocalOrMixedOrdering(currRing))
1766 {strat->red2 = redRiloc;}
1767 else
1768 {strat->red2 = redRing;}
1769 }
1770 if (currRing->pLexOrder && strat->honey)
1771 strat->initEcart = initEcartNormal;
1772 else
1773 strat->initEcart = initEcartBBA;
1774 if (strat->honey)
1775 strat->initEcartPair = initEcartPairMora;
1776 else
1777 strat->initEcartPair = initEcartPairBba;
1778 //strat->kIdeal = NULL;
1779 //if (strat->ak==0) strat->kIdeal->rtyp=IDEAL_CMD;
1780 //else strat->kIdeal->rtyp=MODUL_CMD;
1781 //strat->kIdeal->data=(void *)strat->Shdl;
1782 if ((TEST_OPT_WEIGHTM)&&(F!=NULL))
1783 {
1784 //interred machen Aenderung
1785 strat->pOrigFDeg = currRing->pFDeg;
1786 strat->pOrigLDeg = currRing->pLDeg;
1787 //h=ggetid("ecart");
1788 //if ((h!=NULL) /*&& (IDTYP(h)==INTVEC_CMD)*/)
1789 //{
1790 // ecartWeights=iv2array(IDINTVEC(h));
1791 //}
1792 //else
1793 {
1794 ecartWeights=(short *)omAlloc(((currRing->N)+1)*sizeof(short));
1795 /*uses automatic computation of the ecartWeights to set them*/
1796 kEcartWeights(F->m,IDELEMS(F)-1,ecartWeights, currRing);
1797 }
1798 pRestoreDegProcs(currRing, totaldegreeWecart, maxdegreeWecart);
1799 if (TEST_OPT_PROT)
1800 {
1801 for(i=1; i<=(currRing->N); i++)
1802 Print(" %d",ecartWeights[i]);
1803 PrintLn();
1804 mflush();
1805 }
1806 }
1807 // for sig-safe reductions in signature-based
1808 // standard basis computations
1809 if(rField_is_Ring(currRing))
1810 strat->red = redSigRing;
1811 else
1812 strat->red = redSig;
1813 //strat->sbaOrder = 1;
1814 strat->currIdx = 1;
1815}
skStrategy::pOrigFDeg
pFDegProc pOrigFDeg
Definition: kutil.h:296
skStrategy::pOrigLDeg
pLDegProc pOrigLDeg
Definition: kutil.h:297
redRiloc
int redRiloc(LObject *h, kStrategy strat)
Definition: kstd1.cc:387
redSigRing
int redSigRing(LObject *h, kStrategy strat)
Definition: kstd2.cc:1511
redSig
int redSig(LObject *h, kStrategy strat)
Definition: kstd2.cc:1343
enterSSba
void enterSSba(LObject &p, int atS, kStrategy strat, int atR)
Definition: kutil.cc:8952
pRestoreDegProcs
void pRestoreDegProcs(ring r, pFDegProc old_FDeg, pLDegProc old_lDeg)
Definition: p_polys.cc:3645
totaldegreeWecart
long totaldegreeWecart(poly p, ring r)
Definition: weight.cc:217
maxdegreeWecart
long maxdegreeWecart(poly p, int *l, ring r)
Definition: weight.cc:247
kEcartWeights
void kEcartWeights(poly *s, int sl, short *eweight, const ring R)
Definition: weight.cc:182
ecartWeights
EXTERN_VAR short * ecartWeights
Definition: weight.h:12

◆ initSbaBuchMora()

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

Definition at line 10013 of file kutil.cc.

10014{
10015 strat->interpt = BTEST1(OPT_INTERRUPT);
10016 //strat->kNoether=NULL; // done by skStrategy
10017 /*- creating temp data structures------------------- -*/
10018 //strat->cp = 0; // done by skStrategy
10019 //strat->c3 = 0; // done by skStrategy
10020 strat->tail = pInit();
10021 /*- set s -*/
10022 strat->sl = -1;
10023 /*- set ps -*/
10024 strat->syzl = -1;
10025 /*- set L -*/
10026 strat->Lmax = ((IDELEMS(F)+setmaxLinc-1)/setmaxLinc)*setmaxLinc;
10027 strat->Ll = -1;
10028 strat->L = initL(strat->Lmax);
10029 /*- set B -*/
10030 strat->Bmax = setmaxL;
10031 strat->Bl = -1;
10032 strat->B = initL();
10033 /*- set T -*/
10034 strat->tl = -1;
10035 strat->tmax = setmaxT;
10036 strat->T = initT();
10037 strat->R = initR();
10038 strat->sevT = initsevT();
10039 /*- init local data struct.---------------------------------------- -*/
10040 //strat->P.ecart=0; // done by skStrategy
10041 //strat->P.length=0; // done by skStrategy
10042 if (rHasLocalOrMixedOrdering(currRing))
10043 {
10044 if (strat->kNoether!=NULL)
10045 {
10046 pSetComp(strat->kNoether, strat->ak);
10047 pSetComp(strat->kNoetherTail(), strat->ak);
10048 }
10049 }
10050 if(rField_is_Ring(currRing))
10051 {
10052 /*Shdl=*/initSLSba(F, Q,strat); /*sets also S, ecartS, fromQ */
10053 }
10054 else
10055 {
10056 if(TEST_OPT_SB_1)
10057 {
10058 int i;
10059 ideal P=idInit(IDELEMS(F)-strat->newIdeal,F->rank);
10060 for (i=strat->newIdeal;i<IDELEMS(F);i++)
10061 {
10062 P->m[i-strat->newIdeal] = F->m[i];
10063 F->m[i] = NULL;
10064 }
10065 initSSpecialSba(F,Q,P,strat);
10066 for (i=strat->newIdeal;i<IDELEMS(F);i++)
10067 {
10068 F->m[i] = P->m[i-strat->newIdeal];
10069 P->m[i-strat->newIdeal] = NULL;
10070 }
10071 idDelete(&P);
10072 }
10073 else
10074 {
10075 initSLSba(F, Q,strat); /*sets also S, ecartS, fromQ */
10076 }
10077 }
10078 //strat->fromT = FALSE; // done by skStrategy
10079 if (!TEST_OPT_SB_1)
10080 {
10081 if(!rField_is_Ring(currRing)) updateS(TRUE,strat);
10082 }
10083 //if (strat->fromQ!=NULL) omFreeSize(strat->fromQ,IDELEMS(strat->Shdl)*sizeof(int));
10084 //strat->fromQ=NULL;
10085 assume(kTest_TS(strat));
10086}
initSLSba
void initSLSba(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:7826
initSSpecialSba
void initSSpecialSba(ideal F, ideal Q, ideal P, kStrategy strat)
Definition: kutil.cc:8275

◆ initSbaCrit()

void initSbaCrit ( kStrategy  strat)

Definition at line 9541 of file kutil.cc.

9542{
9543 //strat->enterOnePair=enterOnePairNormal;
9544 strat->enterOnePair = enterOnePairNormal;
9545 //strat->chainCrit=chainCritNormal;
9546 strat->chainCrit = chainCritSig;
9547 /******************************************
9548 * rewCrit1 and rewCrit2 are already set in
9549 * kSba() in kstd1.cc
9550 *****************************************/
9551 //strat->rewCrit1 = faugereRewCriterion;
9552 if (strat->sbaOrder == 1)
9553 {
9554 strat->syzCrit = syzCriterionInc;
9555 }
9556 else
9557 {
9558 strat->syzCrit = syzCriterion;
9559 }
9560#ifdef HAVE_RINGS
9561 if (rField_is_Ring(currRing))
9562 {
9563 strat->enterOnePair=enterOnePairRing;
9564 strat->chainCrit=chainCritRing;
9565 }
9566#endif
9567#ifdef HAVE_RATGRING
9568 if (rIsRatGRing(currRing))
9569 {
9570 strat->chainCrit=chainCritPart;
9571 /* enterOnePairNormal get rational part in it */
9572 }
9573#endif
9574
9575 strat->sugarCrit = TEST_OPT_SUGARCRIT;
9576 strat->Gebauer = strat->homog || strat->sugarCrit;
9577 strat->honey = !strat->homog || strat->sugarCrit || TEST_OPT_WEIGHTM;
9578 if (TEST_OPT_NOT_SUGAR) strat->honey = FALSE;
9579 strat->pairtest = NULL;
9580 /* always use tailreduction, except:
9581 * - in local rings, - in lex order case, -in ring over extensions */
9582 strat->noTailReduction = !TEST_OPT_REDTAIL;
9583 if(rHasMixedOrdering(currRing)) strat->noTailReduction =TRUE;
9584
9585#ifdef HAVE_PLURAL
9586 // and r is plural_ring
9587 // hence this holds for r a rational_plural_ring
9588 if( rIsPluralRing(currRing) || (rIsSCA(currRing) && !strat->z2homog) )
9589 { //or it has non-quasi-comm type... later
9590 strat->sugarCrit = FALSE;
9591 strat->Gebauer = FALSE;
9592 strat->honey = FALSE;
9593 }
9594#endif
9595
9596 // Coefficient ring?
9597 if (rField_is_Ring(currRing))
9598 {
9599 strat->sugarCrit = FALSE;
9600 strat->Gebauer = FALSE ;
9601 strat->honey = FALSE;
9602 }
9603 #ifdef KDEBUG
9604 if (TEST_OPT_DEBUG)
9605 {
9606 if (strat->homog) PrintS("ideal/module is homogeneous\n");
9607 else PrintS("ideal/module is not homogeneous\n");
9608 }
9609 #endif
9610}
skStrategy::syzCrit
BOOLEAN(* syzCrit)(poly sig, unsigned long not_sevSig, kStrategy strat)
Definition: kutil.h:292
syzCriterionInc
BOOLEAN syzCriterionInc(poly sig, unsigned long not_sevSig, kStrategy strat)
Definition: kutil.cc:6556
chainCritSig
void chainCritSig(poly p, int, kStrategy strat)
Definition: kutil.cc:3474
syzCriterion
BOOLEAN syzCriterion(poly sig, unsigned long not_sevSig, kStrategy strat)
Definition: kutil.cc:6521

◆ initSbaPos()

void initSbaPos ( kStrategy  strat)

Definition at line 9911 of file kutil.cc.

9912{
9913 if (rHasGlobalOrdering(currRing))
9914 {
9915 if (strat->honey)
9916 {
9917 strat->posInL = posInL15;
9918 // ok -- here is the deal: from my experiments for Singular-2-0
9919 // I conclude that that posInT_EcartpLength is the best of
9920 // posInT15, posInT_EcartFDegpLength, posInT_FDegLength, posInT_pLength
9921 // see the table at the end of this file
9922 if (TEST_OPT_OLDSTD)
9923 strat->posInT = posInT15;
9924 else
9925 strat->posInT = posInT_EcartpLength;
9926 }
9927 else if (currRing->pLexOrder && !TEST_OPT_INTSTRATEGY)
9928 {
9929 strat->posInL = posInL11;
9930 strat->posInT = posInT11;
9931 }
9932 else if (TEST_OPT_INTSTRATEGY)
9933 {
9934 strat->posInL = posInL11;
9935 strat->posInT = posInT11;
9936 }
9937 else
9938 {
9939 strat->posInL = posInL0;
9940 strat->posInT = posInT0;
9941 }
9942 //if (strat->minim>0) strat->posInL =posInLSpecial;
9943 if (strat->homog)
9944 {
9945 strat->posInL = posInL110;
9946 strat->posInT = posInT110;
9947 }
9948 }
9949 else
9950 {
9951 if (strat->homog)
9952 {
9953 strat->posInL = posInL11;
9954 strat->posInT = posInT11;
9955 }
9956 else
9957 {
9958 if ((currRing->order[0]==ringorder_c)
9959 ||(currRing->order[0]==ringorder_C))
9960 {
9961 strat->posInL = posInL17_c;
9962 strat->posInT = posInT17_c;
9963 }
9964 else
9965 {
9966 strat->posInL = posInL17;
9967 strat->posInT = posInT17;
9968 }
9969 }
9970 }
9971 if (strat->minim>0) strat->posInL =posInLSpecial;
9972 // for further tests only
9973 if ((BTEST1(11)) || (BTEST1(12)))
9974 strat->posInL = posInL11;
9975 else if ((BTEST1(13)) || (BTEST1(14)))
9976 strat->posInL = posInL13;
9977 else if ((BTEST1(15)) || (BTEST1(16)))
9978 strat->posInL = posInL15;
9979 else if ((BTEST1(17)) || (BTEST1(18)))
9980 strat->posInL = posInL17;
9981 if (BTEST1(11))
9982 strat->posInT = posInT11;
9983 else if (BTEST1(13))
9984 strat->posInT = posInT13;
9985 else if (BTEST1(15))
9986 strat->posInT = posInT15;
9987 else if ((BTEST1(17)))
9988 strat->posInT = posInT17;
9989 else if ((BTEST1(19)))
9990 strat->posInT = posInT19;
9991 else if (BTEST1(12) || BTEST1(14) || BTEST1(16) || BTEST1(18))
9992 strat->posInT = posInT1;
9993 if (rField_is_Ring(currRing))
9994 {
9995 strat->posInL = posInL11Ring;
9996 if(rHasLocalOrMixedOrdering(currRing) && currRing->pLexOrder == TRUE)
9997 strat->posInL = posInL11Ringls;
9998 strat->posInT = posInT11;
9999 }
10000 strat->posInLDependsOnLength = FALSE;
10001 strat->posInLSba = posInLSig;
10002 //strat->posInL = posInLSig;
10003 strat->posInL = posInLF5C;
10004 /*
10005 if (rField_is_Ring(currRing))
10006 {
10007 strat->posInLSba = posInLSigRing;
10008 strat->posInL = posInL11Ring;
10009 }*/
10010 //strat->posInT = posInTSig;
10011}
posInLSig
int posInLSig(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:5703
posInLF5C
int posInLF5C(const LSet, const int, LObject *, const kStrategy strat)
Definition: kutil.cc:5821

◆ initsevT()

KINLINE unsigned long * initsevT ( )

Definition at line 100 of file kInline.h.

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

◆ initSL()

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

Definition at line 7729 of file kutil.cc.

7730{
7731 int i,pos;
7732
7733 if (Q!=NULL) i=((IDELEMS(Q)+(setmaxTinc-1))/setmaxTinc)*setmaxTinc;
7734 else i=setmaxT;
7735 strat->ecartS=initec(i);
7736 strat->sevS=initsevS(i);
7737 strat->S_2_R=initS_2_R(i);
7738 strat->fromQ=NULL;
7739 strat->Shdl=idInit(i,F->rank);
7740 strat->S=strat->Shdl->m;
7741 /*- put polys into S -*/
7742 if (Q!=NULL)
7743 {
7744 strat->fromQ=initec(i);
7745 memset(strat->fromQ,0,i*sizeof(int));
7746 for (i=0; i<IDELEMS(Q); i++)
7747 {
7748 if (Q->m[i]!=NULL)
7749 {
7750 LObject h;
7751 h.p = pCopy(Q->m[i]);
7752 if (rHasLocalOrMixedOrdering(currRing))
7753 {
7754 deleteHC(&h,strat);
7755 }
7756 if (TEST_OPT_INTSTRATEGY)
7757 {
7758 h.pCleardenom(); // also does remove Content
7759 }
7760 else
7761 {
7762 h.pNorm();
7763 }
7764 if (h.p!=NULL)
7765 {
7766 strat->initEcart(&h);
7767 if (strat->sl==-1)
7768 pos =0;
7769 else
7770 {
7771 pos = posInS(strat,strat->sl,h.p,h.ecart);
7772 }
7773 h.sev = pGetShortExpVector(h.p);
7774 strat->enterS(h,pos,strat,-1);
7775 strat->fromQ[pos]=1;
7776 }
7777 }
7778 }
7779 }
7780 for (i=0; i<IDELEMS(F); i++)
7781 {
7782 if (F->m[i]!=NULL)
7783 {
7784 LObject h;
7785 h.p = pCopy(F->m[i]);
7786 if (h.p!=NULL)
7787 {
7788 if (rHasLocalOrMixedOrdering(currRing))
7789 {
7790 cancelunit(&h); /*- tries to cancel a unit -*/
7791 deleteHC(&h, strat);
7792 }
7793 if (h.p!=NULL)
7794 {
7795 if (TEST_OPT_INTSTRATEGY)
7796 {
7797 h.pCleardenom(); // also does remove Content
7798 }
7799 else
7800 {
7801 h.pNorm();
7802 }
7803 strat->initEcart(&h);
7804 if (strat->Ll==-1)
7805 pos =0;
7806 else
7807 pos = strat->posInL(strat->L,strat->Ll,&h,strat);
7808 h.sev = pGetShortExpVector(h.p);
7809 enterL(&strat->L,&strat->Ll,&strat->Lmax,h,pos);
7810 }
7811 }
7812 }
7813 }
7814 /*- test, if a unit is in F -*/
7815
7816 if ((strat->Ll>=0)
7817#ifdef HAVE_RINGS
7818 && n_IsUnit(pGetCoeff(strat->L[strat->Ll].p), currRing->cf)
7819#endif
7820 && pIsConstant(strat->L[strat->Ll].p))
7821 {
7822 while (strat->Ll>0) deleteInL(strat->L,&strat->Ll,strat->Ll-1,strat);
7823 }
7824}

◆ initSLSba()

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

Definition at line 7826 of file kutil.cc.

7827{
7828 int i,pos;
7829 if (Q!=NULL) i=((IDELEMS(Q)+(setmaxTinc-1))/setmaxTinc)*setmaxTinc;
7830 else i=setmaxT;
7831 strat->ecartS = initec(i);
7832 strat->sevS = initsevS(i);
7833 strat->sevSig = initsevS(i);
7834 strat->S_2_R = initS_2_R(i);
7835 strat->fromQ = NULL;
7836 strat->Shdl = idInit(i,F->rank);
7837 strat->S = strat->Shdl->m;
7838 strat->sig = (poly *)omAlloc0(i*sizeof(poly));
7839 if (strat->sbaOrder != 1)
7840 {
7841 strat->syz = (poly *)omAlloc0(i*sizeof(poly));
7842 strat->sevSyz = initsevS(i);
7843 strat->syzmax = i;
7844 strat->syzl = 0;
7845 }
7846 /*- put polys into S -*/
7847 if (Q!=NULL)
7848 {
7849 strat->fromQ=initec(i);
7850 memset(strat->fromQ,0,i*sizeof(int));
7851 for (i=0; i<IDELEMS(Q); i++)
7852 {
7853 if (Q->m[i]!=NULL)
7854 {
7855 LObject h;
7856 h.p = pCopy(Q->m[i]);
7857 if (rHasLocalOrMixedOrdering(currRing))
7858 {
7859 deleteHC(&h,strat);
7860 }
7861 if (TEST_OPT_INTSTRATEGY)
7862 {
7863 h.pCleardenom(); // also does remove Content
7864 }
7865 else
7866 {
7867 h.pNorm();
7868 }
7869 if (h.p!=NULL)
7870 {
7871 strat->initEcart(&h);
7872 if (strat->sl==-1)
7873 pos =0;
7874 else
7875 {
7876 pos = posInS(strat,strat->sl,h.p,h.ecart);
7877 }
7878 h.sev = pGetShortExpVector(h.p);
7879 strat->enterS(h,pos,strat,-1);
7880 strat->fromQ[pos]=1;
7881 }
7882 }
7883 }
7884 }
7885 for (i=0; i<IDELEMS(F); i++)
7886 {
7887 if (F->m[i]!=NULL)
7888 {
7889 LObject h;
7890 h.p = pCopy(F->m[i]);
7891 h.sig = pOne();
7892 //h.sig = pInit();
7893 //p_SetCoeff(h.sig,nInit(1),currRing);
7894 p_SetComp(h.sig,i+1,currRing);
7895 // if we are working with the Schreyer order we generate it
7896 // by multiplying the initial signatures with the leading monomial
7897 // of the corresponding initial polynomials generating the ideal
7898 // => we can keep the underlying monomial order and get a Schreyer
7899 // order without any bigger overhead
7900 if (strat->sbaOrder == 0 || strat->sbaOrder == 3)
7901 {
7902 p_ExpVectorAdd (h.sig,F->m[i],currRing);
7903 }
7904 h.sevSig = pGetShortExpVector(h.sig);
7905#ifdef DEBUGF5
7906 pWrite(h.p);
7907 pWrite(h.sig);
7908#endif
7909 if (h.p!=NULL)
7910 {
7911 if (rHasLocalOrMixedOrdering(currRing))
7912 {
7913 cancelunit(&h); /*- tries to cancel a unit -*/
7914 deleteHC(&h, strat);
7915 }
7916 if (h.p!=NULL)
7917 {
7918 if (TEST_OPT_INTSTRATEGY)
7919 {
7920 h.pCleardenom(); // also does remove Content
7921 }
7922 else
7923 {
7924 h.pNorm();
7925 }
7926 strat->initEcart(&h);
7927 if (strat->Ll==-1)
7928 pos =0;
7929 else
7930 pos = strat->posInLSba(strat->L,strat->Ll,&h,strat);
7931 h.sev = pGetShortExpVector(h.p);
7932 enterL(&strat->L,&strat->Ll,&strat->Lmax,h,pos);
7933 }
7934 }
7935 /*
7936 if (strat->sbaOrder != 1)
7937 {
7938 for(j=0;j<i;j++)
7939 {
7940 strat->syz[ctr] = pCopy(F->m[j]);
7941 p_SetCompP(strat->syz[ctr],i+1,currRing);
7942 // add LM(F->m[i]) to the signature to get a Schreyer order
7943 // without changing the underlying polynomial ring at all
7944 p_ExpVectorAdd (strat->syz[ctr],F->m[i],currRing);
7945 // since p_Add_q() destroys all input
7946 // data we need to recreate help
7947 // each time
7948 poly help = pCopy(F->m[i]);
7949 p_SetCompP(help,j+1,currRing);
7950 pWrite(strat->syz[ctr]);
7951 pWrite(help);
7952 printf("%d\n",pLmCmp(strat->syz[ctr],help));
7953 strat->syz[ctr] = p_Add_q(strat->syz[ctr],help,currRing);
7954 printf("%d. SYZ ",ctr);
7955 pWrite(strat->syz[ctr]);
7956 strat->sevSyz[ctr] = p_GetShortExpVector(strat->syz[ctr],currRing);
7957 ctr++;
7958 }
7959 strat->syzl = ps;
7960 }
7961 */
7962 }
7963 }
7964 /*- test, if a unit is in F -*/
7965
7966 if ((strat->Ll>=0)
7967#ifdef HAVE_RINGS
7968 && n_IsUnit(pGetCoeff(strat->L[strat->Ll].p), currRing->cf)
7969#endif
7970 && pIsConstant(strat->L[strat->Ll].p))
7971 {
7972 while (strat->Ll>0) deleteInL(strat->L,&strat->Ll,strat->Ll-1,strat);
7973 }
7974}
p_ExpVectorAdd
static void p_ExpVectorAdd(poly p1, poly p2, const ring r)
Definition: p_polys.h:1409

◆ initSyzRules()

void initSyzRules ( kStrategy  strat)

Definition at line 7976 of file kutil.cc.

7977{
7978 if( strat->S[0] )
7979 {
7980 if( strat->S[1] && !rField_is_Ring(currRing))
7981 {
7982 omFreeSize(strat->syzIdx,(strat->syzidxmax)*sizeof(int));
7983 omFreeSize(strat->sevSyz,(strat->syzmax)*sizeof(unsigned long));
7984 omFreeSize(strat->syz,(strat->syzmax)*sizeof(poly));
7985 }
7986 int i, j, k, diff, comp, comp_old, ps=0, ctr=0;
7987 /************************************************************
7988 * computing the length of the syzygy array needed
7989 ***********************************************************/
7990 for(i=1; i<=strat->sl; i++)
7991 {
7992 if (pGetComp(strat->sig[i-1]) != pGetComp(strat->sig[i]))
7993 {
7994 ps += i;
7995 }
7996 }
7997 ps += strat->sl+1;
7998 //comp = pGetComp (strat->P.sig);
7999 comp = strat->currIdx;
8000 strat->syzIdx = initec(comp);
8001 strat->sevSyz = initsevS(ps);
8002 strat->syz = (poly *)omAlloc(ps*sizeof(poly));
8003 strat->syzmax = ps;
8004 strat->syzl = 0;
8005 strat->syzidxmax = comp;
8006#if defined(DEBUGF5) || defined(DEBUGF51)
8007 PrintS("------------- GENERATING SYZ RULES NEW ---------------\n");
8008#endif
8009 i = 1;
8010 j = 0;
8011 /************************************************************
8012 * generating the leading terms of the principal syzygies
8013 ***********************************************************/
8014 while (i <= strat->sl)
8015 {
8016 /**********************************************************
8017 * principal syzygies start with component index 2
8018 * the array syzIdx starts with index 0
8019 * => the rules for a signature with component comp start
8020 * at strat->syz[strat->syzIdx[comp-2]] !
8021 *********************************************************/
8022 if (pGetComp(strat->sig[i-1]) != pGetComp(strat->sig[i]))
8023 {
8024 comp = pGetComp(strat->sig[i]);
8025 comp_old = pGetComp(strat->sig[i-1]);
8026 diff = comp - comp_old - 1;
8027 // diff should be zero, but sometimes also the initial generating
8028 // elements of the input ideal reduce to zero. then there is an
8029 // index-gap between the signatures. for these in-between signatures we
8030 // can safely set syzIdx[j] = 0 as no such element will be ever computed
8031 // in the following.
8032 // doing this, we keep the relation "j = comp - 2" alive, which makes
8033 // jumps way easier when checking criteria
8034 while (diff>0)
8035 {
8036 strat->syzIdx[j] = 0;
8037 diff--;
8038 j++;
8039 }
8040 strat->syzIdx[j] = ctr;
8041 j++;
8042 LObject Q;
8043 int pos;
8044 for (k = 0; k<i; k++)
8045 {
8046 Q.sig = pOne();
8047 if(rField_is_Ring(currRing))
8048 p_SetCoeff(Q.sig,nCopy(p_GetCoeff(strat->S[k],currRing)),currRing);
8049 p_ExpVectorCopy(Q.sig,strat->S[k],currRing);
8050 p_SetCompP (Q.sig, comp, currRing);
8051 poly q = p_One(currRing);
8052 if(rField_is_Ring(currRing))
8053 p_SetCoeff(q,nCopy(p_GetCoeff(strat->S[i],currRing)),currRing);
8054 p_ExpVectorCopy(q,strat->S[i],currRing);
8055 q = p_Neg (q, currRing);
8056 p_SetCompP (q, __p_GetComp(strat->sig[k], currRing), currRing);
8057 Q.sig = p_Add_q (Q.sig, q, currRing);
8058 Q.sevSig = p_GetShortExpVector(Q.sig,currRing);
8059 pos = posInSyz(strat, Q.sig);
8060 enterSyz(Q, strat, pos);
8061 ctr++;
8062 }
8063 }
8064 i++;
8065 }
8066 /**************************************************************
8067 * add syzygies for upcoming first element of new iteration step
8068 **************************************************************/
8069 comp = strat->currIdx;
8070 comp_old = pGetComp(strat->sig[i-1]);
8071 diff = comp - comp_old - 1;
8072 // diff should be zero, but sometimes also the initial generating
8073 // elements of the input ideal reduce to zero. then there is an
8074 // index-gap between the signatures. for these in-between signatures we
8075 // can safely set syzIdx[j] = 0 as no such element will be ever computed
8076 // in the following.
8077 // doing this, we keep the relation "j = comp - 2" alive, which makes
8078 // jumps way easier when checking criteria
8079 while (diff>0)
8080 {
8081 strat->syzIdx[j] = 0;
8082 diff--;
8083 j++;
8084 }
8085 strat->syzIdx[j] = ctr;
8086 LObject Q;
8087 int pos;
8088 for (k = 0; k<strat->sl+1; k++)
8089 {
8090 Q.sig = pOne();
8091 if(rField_is_Ring(currRing))
8092 p_SetCoeff(Q.sig,nCopy(p_GetCoeff(strat->S[k],currRing)),currRing);
8093 p_ExpVectorCopy(Q.sig,strat->S[k],currRing);
8094 p_SetCompP (Q.sig, comp, currRing);
8095 poly q = p_One(currRing);
8096 if(rField_is_Ring(currRing))
8097 p_SetCoeff(q,nCopy(p_GetCoeff(strat->L[strat->Ll].p,currRing)),currRing);
8098 p_ExpVectorCopy(q,strat->L[strat->Ll].p,currRing);
8099 q = p_Neg (q, currRing);
8100 p_SetCompP (q, __p_GetComp(strat->sig[k], currRing), currRing);
8101 Q.sig = p_Add_q (Q.sig, q, currRing);
8102 Q.sevSig = p_GetShortExpVector(Q.sig,currRing);
8103 pos = posInSyz(strat, Q.sig);
8104 enterSyz(Q, strat, pos);
8105 ctr++;
8106 }
8107//#if 1
8108#ifdef DEBUGF5
8109 PrintS("Principal syzygies:\n");
8110 Print("syzl %d\n",strat->syzl);
8111 Print("syzmax %d\n",strat->syzmax);
8112 Print("ps %d\n",ps);
8113 PrintS("--------------------------------\n");
8114 for(i=0;i<=strat->syzl-1;i++)
8115 {
8116 Print("%d - ",i);
8117 pWrite(strat->syz[i]);
8118 }
8119 for(i=0;i<strat->currIdx;i++)
8120 {
8121 Print("%d - %d\n",i,strat->syzIdx[i]);
8122 }
8123 PrintS("--------------------------------\n");
8124#endif
8125 }
8126}
comp
int comp(const CanonicalForm &A, const CanonicalForm &B)
compare polynomials
Definition: facSparseHensel.h:25
enterSyz
void enterSyz(LObject &p, kStrategy strat, int atT)
Definition: kutil.cc:9380
posInSyz
int posInSyz(const kStrategy strat, poly sig)
Definition: kutil.cc:5792
p_GetCoeff
#define p_GetCoeff(p, r)
Definition: monomials.h:50
diff
STATIC_VAR gmp_float * diff
Definition: mpr_complex.cc:45
p_GetShortExpVector
unsigned long p_GetShortExpVector(const poly p, const ring r)
Definition: p_polys.cc:4776
p_One
poly p_One(const ring r)
Definition: p_polys.cc:1313
p_Neg
static poly p_Neg(poly p, const ring r)
Definition: p_polys.h:1105
p_Add_q
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:934
p_ExpVectorCopy
static void p_ExpVectorCopy(poly d_p, poly s_p, const ring r)
Definition: p_polys.h:1311
p_SetCompP
static void p_SetCompP(poly p, int i, ring r)
Definition: p_polys.h:252

◆ initT()

KINLINE TSet initT ( )

Definition at line 84 of file kInline.h.

85{
86 TSet T = (TSet)omAlloc0(setmaxT*sizeof(TObject));
87 for (int i=setmaxT-1; i>=0; i--)
88 {
89 T[i].tailRing = currRing;
90 T[i].i_r = -1;
91 }
92 return T;
93}
T
STATIC_VAR jList * T
Definition: janet.cc:30
TSet
TObject * TSet
Definition: kutil.h:59

◆ k_GetLeadTerms()

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

Definition at line 1018 of file kInline.h.

1020{
1021 p_LmCheckPolyRing(p1, p_r);
1022 p_LmCheckPolyRing(p2, p_r);
1023
1024 int i;
1025 long x;
1026 m1 = p_Init(m_r,m_r->PolyBin);
1027 m2 = p_Init(m_r,m_r->PolyBin);
1028
1029 for (i = p_r->N; i; i--)
1030 {
1031 x = p_GetExpDiff(p1, p2, i, p_r);
1032 if (x > 0)
1033 {
1034 if (x > (long) m_r->bitmask) goto false_return;
1035 p_SetExp(m2,i,x, m_r);
1036 p_SetExp(m1,i,0, m_r);
1037 }
1038 else
1039 {
1040 if (-x > (long) m_r->bitmask) goto false_return;
1041 p_SetExp(m1,i,-x, m_r);
1042 p_SetExp(m2,i,0, m_r);
1043 }
1044 }
1045
1046 p_Setm(m1, m_r);
1047 p_Setm(m2, m_r);
1048 return TRUE;
1049
1050 false_return:
1051 p_LmFree(m1, m_r);
1052 p_LmFree(m2, m_r);
1053 m1 = m2 = NULL;
1054 return FALSE;
1055}
x
Variable x
Definition: cfModGcd.cc:4082
p_GetExpDiff
static long p_GetExpDiff(poly p1, poly p2, int i, ring r)
Definition: p_polys.h:633
p_LmCheckPolyRing
BOOLEAN p_LmCheckPolyRing(poly p, ring r)
Definition: pDebug.cc:120
p_SetExp
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent @Note: VarOffset encodes the position in p->exp
Definition: p_polys.h:486
p_Init
static poly p_Init(const ring r, omBin bin)
Definition: p_polys.h:1318

◆ k_GetStrongLeadTerms()

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

Definition at line 1061 of file kInline.h.

1063{
1064 p_LmCheckPolyRing(p1, leadRing);
1065 p_LmCheckPolyRing(p2, leadRing);
1066
1067 int i;
1068 int x;
1069 int e1;
1070 int e2;
1071 int s;
1072 m1 = p_Init(tailRing,tailRing->PolyBin);
1073 m2 = p_Init(tailRing,tailRing->PolyBin);
1074 lcm = p_Init(leadRing,leadRing->PolyBin);
1075
1076 for (i = leadRing->N; i>=0; i--)
1077 {
1078 e1 = p_GetExp(p1,i,leadRing);
1079 e2 = p_GetExp(p2,i,leadRing);
1080 x = e1 - e2;
1081 if (x > 0)
1082 {
1083 p_SetExp(m2,i,x, tailRing);
1084 //p_SetExp(m1,i,0, tailRing); // done by p_Init
1085 s = e1;
1086 }
1087 else if (x<0)
1088 {
1089 p_SetExp(m1,i,-x, tailRing);
1090 //p_SetExp(m2,i,0, tailRing); // done by p_Init
1091 s = e2;
1092 }
1093 else
1094 s = e1; // e1==e2
1095 p_SetExp(lcm,i,s, leadRing);
1096 }
1097
1098 p_Setm(m1, tailRing);
1099 p_Setm(m2, tailRing);
1100 p_Setm(lcm, leadRing);
1101}
s
const CanonicalForm int s
Definition: facAbsFact.cc:51

◆ k_LmInit_currRing_2_tailRing() [1/2]

KINLINE poly k_LmInit_currRing_2_tailRing ( poly  p,
ring  tailRing 
)

Definition at line 991 of file kInline.h.

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

◆ k_LmInit_currRing_2_tailRing() [2/2]

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

Definition at line 959 of file kInline.h.

960{
961
962 poly t_p = p_LmInit(p, currRing, tailRing, tailBin);
963 pNext(t_p) = pNext(p);
964 pSetCoeff0(t_p, pGetCoeff(p));
965 return t_p;
966}
p_LmInit
static poly p_LmInit(poly p, const ring r)
Definition: p_polys.h:1333

◆ k_LmInit_tailRing_2_currRing() [1/2]

KINLINE poly k_LmInit_tailRing_2_currRing ( poly  p,
ring  tailRing 
)

Definition at line 996 of file kInline.h.

997{
998 return k_LmInit_tailRing_2_currRing(p, tailRing, currRing->PolyBin);
999}
k_LmInit_tailRing_2_currRing
KINLINE poly k_LmInit_tailRing_2_currRing(poly t_p, ring tailRing, omBin lmBin)
Definition: kInline.h:968

◆ k_LmInit_tailRing_2_currRing() [2/2]

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

Definition at line 968 of file kInline.h.

969{
970 poly p = p_LmInit(t_p, tailRing, currRing, lmBin);
971 pNext(p) = pNext(t_p);
972 pSetCoeff0(p, pGetCoeff(t_p));
973 return p;
974}

◆ k_LmShallowCopyDelete_currRing_2_tailRing() [1/2]

KINLINE poly k_LmShallowCopyDelete_currRing_2_tailRing ( poly  p,
ring  tailRing 
)

Definition at line 1001 of file kInline.h.

1002{
1003 return k_LmShallowCopyDelete_currRing_2_tailRing(p, tailRing, tailRing->PolyBin);
1004}
k_LmShallowCopyDelete_currRing_2_tailRing
KINLINE poly k_LmShallowCopyDelete_currRing_2_tailRing(poly p, ring tailRing, omBin tailBin)
Definition: kInline.h:977

◆ k_LmShallowCopyDelete_currRing_2_tailRing() [2/2]

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

Definition at line 977 of file kInline.h.

978{
979 poly np = k_LmInit_currRing_2_tailRing(p, tailRing, tailBin);
980 p_LmFree(p, currRing);
981 return np;
982}

◆ k_LmShallowCopyDelete_tailRing_2_currRing() [1/2]

KINLINE poly k_LmShallowCopyDelete_tailRing_2_currRing ( poly  p,
ring  tailRing 
)

Definition at line 1006 of file kInline.h.

1007{
1008 return k_LmShallowCopyDelete_tailRing_2_currRing(p, tailRing, currRing->PolyBin);
1009}
k_LmShallowCopyDelete_tailRing_2_currRing
KINLINE poly k_LmShallowCopyDelete_tailRing_2_currRing(poly p, ring tailRing, omBin lmBin)
Definition: kInline.h:984

◆ k_LmShallowCopyDelete_tailRing_2_currRing() [2/2]

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

Definition at line 984 of file kInline.h.

985{
986 poly np = k_LmInit_tailRing_2_currRing(p, tailRing, lmBin);
987 p_LmFree(p, tailRing);
988 return np;
989}

◆ kCheckSpolyCreation()

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

Definition at line 10534 of file kutil.cc.

10535{
10536 if (strat->overflow) return FALSE;
10537 assume(L->p1 != NULL && L->p2 != NULL);
10538 // shift changes: from 0 to -1
10539 assume(L->i_r1 >= -1 && L->i_r1 <= strat->tl);
10540 assume(L->i_r2 >= -1 && L->i_r2 <= strat->tl);
10541
10542 if (! k_GetLeadTerms(L->p1, L->p2, currRing, m1, m2, strat->tailRing))
10543 return FALSE;
10544 // shift changes: extra case inserted
10545 if ((L->i_r1 == -1) || (L->i_r2 == -1) )
10546 {
10547 return TRUE;
10548 }
10549 poly p1_max=NULL;
10550 if ((L->i_r1>=0)&&(strat->R[L->i_r1]!=NULL)) p1_max = (strat->R[L->i_r1])->max_exp;
10551 poly p2_max=NULL;
10552 if ((L->i_r2>=0)&&(strat->R[L->i_r2]!=NULL)) p2_max = (strat->R[L->i_r2])->max_exp;
10553
10554 if (((p1_max != NULL) && !p_LmExpVectorAddIsOk(m1, p1_max, strat->tailRing)) ||
10555 ((p2_max != NULL) && !p_LmExpVectorAddIsOk(m2, p2_max, strat->tailRing)))
10556 {
10557 p_LmFree(m1, strat->tailRing);
10558 p_LmFree(m2, strat->tailRing);
10559 m1 = NULL;
10560 m2 = NULL;
10561 return FALSE;
10562 }
10563 return TRUE;
10564}
k_GetLeadTerms
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:1018
p_LmExpVectorAddIsOk
static BOOLEAN p_LmExpVectorAddIsOk(const poly p1, const poly p2, const ring r)
Definition: p_polys.h:1997

◆ kCheckStrongCreation()

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

Definition at line 10573 of file kutil.cc.

10574{
10575 assume(strat->S_2_R[atS] >= -1 && strat->S_2_R[atS] <= strat->tl);
10576 //assume(strat->tailRing != currRing);
10577
10578 poly p1_max = (strat->R[atR])->max_exp;
10579 poly p2_max = (strat->R[strat->S_2_R[atS]])->max_exp;
10580
10581 if (((p1_max != NULL) && !p_LmExpVectorAddIsOk(m1, p1_max, strat->tailRing)) ||
10582 ((p2_max != NULL) && !p_LmExpVectorAddIsOk(m2, p2_max, strat->tailRing)))
10583 {
10584 return FALSE;
10585 }
10586 return TRUE;
10587}

◆ kDebugPrint()

void kDebugPrint ( kStrategy  strat)

Output some debug info about a given strategy.

Definition at line 11560 of file kutil.cc.

11561{
11562 printf("red: ");
11563 if (strat->red==redFirst) printf("redFirst\n");
11564 else if (strat->red==redHoney) printf("redHoney\n");
11565 else if (strat->red==redEcart) printf("redEcart\n");
11566 else if (strat->red==redHomog) printf("redHomog\n");
11567 else if (strat->red==redLazy) printf("redLazy\n");
11568 else if (strat->red==redLiftstd) printf("redLiftstd\n");
11569 else printf("%p\n",(void*)strat->red);
11570 printf("posInT: ");
11571 if (strat->posInT==posInT0) printf("posInT0\n");
11572 else if (strat->posInT==posInT1) printf("posInT1\n");
11573 else if (strat->posInT==posInT11) printf("posInT11\n");
11574 else if (strat->posInT==posInT110) printf("posInT110\n");
11575 else if (strat->posInT==posInT13) printf("posInT13\n");
11576 else if (strat->posInT==posInT15) printf("posInT15\n");
11577 else if (strat->posInT==posInT17) printf("posInT17\n");
11578 else if (strat->posInT==posInT17_c) printf("posInT17_c\n");
11579 else if (strat->posInT==posInT19) printf("posInT19\n");
11580 else if (strat->posInT==posInT2) printf("posInT2\n");
11581 #ifdef HAVE_RINGS
11582 else if (strat->posInT==posInT11Ring) printf("posInT11Ring\n");
11583 else if (strat->posInT==posInT110Ring) printf("posInT110Ring\n");
11584 else if (strat->posInT==posInT15Ring) printf("posInT15Ring\n");
11585 else if (strat->posInT==posInT17Ring) printf("posInT17Ring\n");
11586 else if (strat->posInT==posInT17_cRing) printf("posInT17_cRing\n");
11587 #endif
11588#ifdef HAVE_MORE_POS_IN_T
11589 else if (strat->posInT==posInT_EcartFDegpLength) printf("posInT_EcartFDegpLength\n");
11590 else if (strat->posInT==posInT_FDegpLength) printf("posInT_FDegpLength\n");
11591 else if (strat->posInT==posInT_pLength) printf("posInT_pLength\n");
11592#endif
11593 else if (strat->posInT==posInT_EcartpLength) printf("posInT_EcartpLength\n");
11594 else printf("%p\n",(void*)strat->posInT);
11595 printf("posInL: ");
11596 if (strat->posInL==posInL0) printf("posInL0\n");
11597 else if (strat->posInL==posInL10) printf("posInL10\n");
11598 else if (strat->posInL==posInL11) printf("posInL11\n");
11599 else if (strat->posInL==posInL110) printf("posInL110\n");
11600 else if (strat->posInL==posInL13) printf("posInL13\n");
11601 else if (strat->posInL==posInL15) printf("posInL15\n");
11602 else if (strat->posInL==posInL17) printf("posInL17\n");
11603 else if (strat->posInL==posInL17_c) printf("posInL17_c\n");
11604 #ifdef HAVE_RINGS
11605 else if (strat->posInL==posInL0) printf("posInL0Ring\n");
11606 else if (strat->posInL==posInL11Ring) printf("posInL11Ring\n");
11607 else if (strat->posInL==posInL11Ringls) printf("posInL11Ringls\n");
11608 else if (strat->posInL==posInL110Ring) printf("posInL110Ring\n");
11609 else if (strat->posInL==posInL15Ring) printf("posInL15Ring\n");
11610 else if (strat->posInL==posInL17Ring) printf("posInL17Ring\n");
11611 else if (strat->posInL==posInL17_cRing) printf("posInL17_cRing\n");
11612 #endif
11613 else if (strat->posInL==posInLSpecial) printf("posInLSpecial\n");
11614 else printf("%p\n",(void*)strat->posInL);
11615 printf("enterS: ");
11616 if (strat->enterS==enterSBba) printf("enterSBba\n");
11617 else if (strat->enterS==enterSMora) printf("enterSMora\n");
11618 else if (strat->enterS==enterSMoraNF) printf("enterSMoraNF\n");
11619 else printf("%p\n",(void*)strat->enterS);
11620 printf("initEcart: ");
11621 if (strat->initEcart==initEcartBBA) printf("initEcartBBA\n");
11622 else if (strat->initEcart==initEcartNormal) printf("initEcartNormal\n");
11623 else printf("%p\n",(void*)strat->initEcart);
11624 printf("initEcartPair: ");
11625 if (strat->initEcartPair==initEcartPairBba) printf("initEcartPairBba\n");
11626 else if (strat->initEcartPair==initEcartPairMora) printf("initEcartPairMora\n");
11627 else printf("%p\n",(void*)strat->initEcartPair);
11628 printf("homog=%d, LazyDegree=%d, LazyPass=%d, ak=%d,\n",
11629 strat->homog, strat->LazyDegree,strat->LazyPass, strat->ak);
11630 printf("honey=%d, sugarCrit=%d, Gebauer=%d, noTailReduction=%d, use_buckets=%d\n",
11631 strat->honey,strat->sugarCrit,strat->Gebauer,strat->noTailReduction,strat->use_buckets);
11632 printf("chainCrit: ");
11633 if (strat->chainCrit==chainCritNormal) printf("chainCritNormal\n");
11634 else if (strat->chainCrit==chainCritOpt_1) printf("chainCritOpt_1\n");
11635 else printf("%p\n",(void*)strat->chainCrit);
11636 printf("posInLDependsOnLength=%d\n",
11637 strat->posInLDependsOnLength);
11638 printf("%s\n",showOption());
11639 printf("LDeg: ");
11640 if (currRing->pLDeg==pLDeg0) printf("pLDeg0");
11641 else if (currRing->pLDeg==pLDeg0c) printf("pLDeg0c");
11642 else if (currRing->pLDeg==pLDegb) printf("pLDegb");
11643 else if (currRing->pLDeg==pLDeg1) printf("pLDeg1");
11644 else if (currRing->pLDeg==pLDeg1c) printf("pLDeg1c");
11645 else if (currRing->pLDeg==pLDeg1_Deg) printf("pLDeg1_Deg");
11646 else if (currRing->pLDeg==pLDeg1c_Deg) printf("pLDeg1c_Deg");
11647 else if (currRing->pLDeg==pLDeg1_Totaldegree) printf("pLDeg1_Totaldegree");
11648 else if (currRing->pLDeg==pLDeg1c_Totaldegree) printf("pLDeg1c_Totaldegree");
11649 else if (currRing->pLDeg==pLDeg1_WFirstTotalDegree) printf("pLDeg1_WFirstTotalDegree");
11650 else if (currRing->pLDeg==pLDeg1c_WFirstTotalDegree) printf("pLDeg1c_WFirstTotalDegree");
11651 else if (currRing->pLDeg==maxdegreeWecart) printf("maxdegreeWecart");
11652 else printf("? (%lx)", (long)currRing->pLDeg);
11653 printf(" / ");
11654 if (strat->tailRing->pLDeg==pLDeg0) printf("pLDeg0");
11655 else if (strat->tailRing->pLDeg==pLDeg0c) printf("pLDeg0c");
11656 else if (strat->tailRing->pLDeg==pLDegb) printf("pLDegb");
11657 else if (strat->tailRing->pLDeg==pLDeg1) printf("pLDeg1");
11658 else if (strat->tailRing->pLDeg==pLDeg1c) printf("pLDeg1c");
11659 else if (strat->tailRing->pLDeg==pLDeg1_Deg) printf("pLDeg1_Deg");
11660 else if (strat->tailRing->pLDeg==pLDeg1c_Deg) printf("pLDeg1c_Deg");
11661 else if (strat->tailRing->pLDeg==pLDeg1_Totaldegree) printf("pLDeg1_Totaldegree");
11662 else if (strat->tailRing->pLDeg==pLDeg1c_Totaldegree) printf("pLDeg1c_Totaldegree");
11663 else if (strat->tailRing->pLDeg==pLDeg1_WFirstTotalDegree) printf("pLDeg1_WFirstTotalDegree");
11664 else if (strat->tailRing->pLDeg==pLDeg1c_WFirstTotalDegree) printf("pLDeg1c_WFirstTotalDegree");
11665 else if (strat->tailRing->pLDeg==maxdegreeWecart) printf("maxdegreeWecart");
11666 else printf("? (%lx)", (long)strat->tailRing->pLDeg);
11667 printf("\n");
11668 printf("currRing->pFDeg: ");
11669 if (currRing->pFDeg==p_Totaldegree) printf("p_Totaldegree");
11670 else if (currRing->pFDeg==p_WFirstTotalDegree) printf("pWFirstTotalDegree");
11671 else if (currRing->pFDeg==p_Deg) printf("p_Deg");
11672 else if (currRing->pFDeg==kHomModDeg) printf("kHomModDeg");
11673 else if (currRing->pFDeg==totaldegreeWecart) printf("totaldegreeWecart");
11674 else if (currRing->pFDeg==p_WTotaldegree) printf("p_WTotaldegree");
11675 else printf("? (%lx)", (long)currRing->pFDeg);
11676 printf("\n");
11677 printf(" syzring:%d, syzComp(strat):%d limit:%d\n",rIsSyzIndexRing(currRing),strat->syzComp,rGetCurrSyzLimit(currRing));
11678 if(TEST_OPT_DEGBOUND)
11679 printf(" degBound: %d\n", Kstd1_deg);
11680
11681 if( ecartWeights != NULL )
11682 {
11683 printf("ecartWeights: ");
11684 for (int i = rVar(currRing); i > 0; i--)
11685 printf("%hd ", ecartWeights[i]);
11686 printf("\n");
11687 assume( TEST_OPT_WEIGHTM );
11688 }
11689
11690#ifndef SING_NDEBUG
11691 rDebugPrint(currRing);
11692#endif
11693}
skStrategy::LazyDegree
int LazyDegree
Definition: kutil.h:353
posInL10
int posInL10(const LSet set, const int length, LObject *p, const kStrategy strat)
Definition: kstd1.cc:1365
kHomModDeg
long kHomModDeg(poly p, ring r)
Definition: kstd1.cc:2434
redFirst
int redFirst(LObject *h, kStrategy strat)
Definition: kstd1.cc:797
redEcart
int redEcart(LObject *h, kStrategy strat)
Definition: kstd1.cc:169
enterSMoraNF
void enterSMoraNF(LObject &p, int atS, kStrategy strat, int atR=-1)
Definition: kstd1.cc:1681
posInT2
int posInT2(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4947
posInT_pLength
int posInT_pLength(const TSet set, const int length, LObject &p)
Definition: kutil.cc:11526
posInT_EcartFDegpLength
int posInT_EcartFDegpLength(const TSet set, const int length, LObject &p)
Definition: kutil.cc:11435
Kstd1_deg
VAR int Kstd1_deg
Definition: kutil.cc:247
enterSMora
void enterSMora(LObject &p, int atS, kStrategy strat, int atR=-1)
Definition: kstd1.cc:1628
posInT_FDegpLength
int posInT_FDegpLength(const TSet set, const int length, LObject &p)
Definition: kutil.cc:11489
showOption
char * showOption()
Definition: misc_ip.cc:709
pLDegb
long pLDegb(poly p, int *l, const ring r)
Definition: p_polys.cc:811
pLDeg1_Totaldegree
long pLDeg1_Totaldegree(poly p, int *l, const ring r)
Definition: p_polys.cc:975
p_WFirstTotalDegree
long p_WFirstTotalDegree(poly p, const ring r)
Definition: p_polys.cc:596
pLDeg1_WFirstTotalDegree
long pLDeg1_WFirstTotalDegree(poly p, int *l, const ring r)
Definition: p_polys.cc:1038
pLDeg1c_WFirstTotalDegree
long pLDeg1c_WFirstTotalDegree(poly p, int *l, const ring r)
Definition: p_polys.cc:1068
pLDeg1c_Deg
long pLDeg1c_Deg(poly p, int *l, const ring r)
Definition: p_polys.cc:941
pLDeg1
long pLDeg1(poly p, int *l, const ring r)
Definition: p_polys.cc:841
pLDeg1_Deg
long pLDeg1_Deg(poly p, int *l, const ring r)
Definition: p_polys.cc:910
p_WTotaldegree
long p_WTotaldegree(poly p, const ring r)
Definition: p_polys.cc:613
pLDeg1c
long pLDeg1c(poly p, int *l, const ring r)
Definition: p_polys.cc:877
pLDeg1c_Totaldegree
long pLDeg1c_Totaldegree(poly p, int *l, const ring r)
Definition: p_polys.cc:1005
pLDeg0c
long pLDeg0c(poly p, int *l, const ring r)
Definition: p_polys.cc:770
pLDeg0
long pLDeg0(poly p, int *l, const ring r)
Definition: p_polys.cc:739
p_Totaldegree
static long p_Totaldegree(poly p, const ring r)
Definition: p_polys.h:1505
rDebugPrint
void rDebugPrint(const ring r)
Definition: ring.cc:4122
rGetCurrSyzLimit
static int rGetCurrSyzLimit(const ring r)
Definition: ring.h:723

◆ kDeleteLcm()

static void kDeleteLcm ( LObject *  P)
inlinestatic

Definition at line 880 of file kutil.h.

881{
882 if (P->lcm!=NULL)
883 {
884 #ifdef HAVE_RINGS
885 if (rField_is_Ring(currRing))
886 pLmDelete(P->lcm);
887 else
888 #endif
889 pLmFree(P->lcm);
890 P->lcm=NULL;
891 }
892}

◆ kFindDivisibleByInS()

int kFindDivisibleByInS ( const kStrategy  strat,
int *  max_ind,
LObject *  L 
)

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

Definition at line 421 of file kstd2.cc.

422{
423 unsigned long not_sev = ~L->sev;
424 poly p = L->GetLmCurrRing();
425 int j = 0;
426
427 pAssume(~not_sev == p_GetShortExpVector(p, currRing));
428
429 BOOLEAN is_Ring=rField_is_Ring(currRing);
430#if 1
431 int ende;
432 if (is_Ring
433 || (strat->ak>0)
434 || currRing->pLexOrder)
435 ende=strat->sl;
436 else
437 {
438 ende=posInS(strat,*max_ind,p,0)+1;
439 if (ende>(*max_ind)) ende=(*max_ind);
440 }
441#else
442 int ende=strat->sl;
443#endif
444 if(is_Ring)
445 {
446 loop
447 {
448 if (j > ende) return -1;
449#if defined(PDEBUG) || defined(PDIV_DEBUG)
450 if (p_LmShortDivisibleBy(strat->S[j], strat->sevS[j],
451 p, not_sev, currRing))
452#else
453 if ( !(strat->sevS[j] & not_sev) &&
454 p_LmDivisibleBy(strat->S[j], p, currRing))
455#endif
456 {
457 if(n_DivBy(pGetCoeff(p), pGetCoeff(strat->S[j]), currRing->cf))
458 return j;
459 }
460 j++;
461 }
462 }
463 else
464 {
465 loop
466 {
467 if (j > ende) return -1;
468#if defined(PDEBUG) || defined(PDIV_DEBUG)
469 if (p_LmShortDivisibleBy(strat->S[j], strat->sevS[j],
470 p, not_sev, currRing))
471#else
472 if ( !(strat->sevS[j] & not_sev) &&
473 p_LmDivisibleBy(strat->S[j], p, currRing))
474#endif
475 {
476 return j;
477 }
478 j++;
479 }
480 }
481}
p_LmDivisibleBy
static BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
Definition: p_polys.h:1889

◆ kFindDivisibleByInS_T()

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

Definition at line 6740 of file kutil.cc.

6741{
6742 int j = 0;
6743 const unsigned long not_sev = ~L->sev;
6744 const unsigned long* sev = strat->sevS;
6745 poly p;
6746 ring r;
6747 L->GetLm(p, r);
6748
6749 assume(~not_sev == p_GetShortExpVector(p, r));
6750
6751 if (r == currRing)
6752 {
6753 if(!rField_is_Ring(r))
6754 {
6755 loop
6756 {
6757 if (j > end_pos) return NULL;
6758 #if defined(PDEBUG) || defined(PDIV_DEBUG)
6759 if (strat->S[j]!= NULL && p_LmShortDivisibleBy(strat->S[j], sev[j], p, not_sev, r) &&
6760 (ecart== LONG_MAX || ecart>= strat->ecartS[j]))
6761 #else
6762 if (!(sev[j] & not_sev) &&
6763 (ecart== LONG_MAX || ecart>= strat->ecartS[j]) &&
6764 p_LmDivisibleBy(strat->S[j], p, r))
6765 #endif
6766 {
6767 break;
6768 }
6769 j++;
6770 }
6771 }
6772 #ifdef HAVE_RINGS
6773 else
6774 {
6775 loop
6776 {
6777 if (j > end_pos) return NULL;
6778 #if defined(PDEBUG) || defined(PDIV_DEBUG)
6779 if (strat->S[j]!= NULL
6780 && p_LmShortDivisibleBy(strat->S[j], sev[j], p, not_sev, r)
6781 && (ecart== LONG_MAX || ecart>= strat->ecartS[j])
6782 && n_DivBy(pGetCoeff(p), pGetCoeff(strat->S[j]), r->cf))
6783 #else
6784 if (!(sev[j] & not_sev)
6785 && (ecart== LONG_MAX || ecart>= strat->ecartS[j])
6786 && p_LmDivisibleBy(strat->S[j], p, r)
6787 && n_DivBy(pGetCoeff(p), pGetCoeff(strat->S[j]), r->cf))
6788 #endif
6789 {
6790 break; // found
6791 }
6792 j++;
6793 }
6794 }
6795 #endif
6796 // if called from NF, T objects do not exist:
6797 if (strat->tl < 0 || strat->S_2_R[j] == -1)
6798 {
6799 T->Set(strat->S[j], r, strat->tailRing);
6800 assume(T->GetpLength()==pLength(T->p != __null ? T->p : T->t_p));
6801 return T;
6802 }
6803 else
6804 {
6805///// assume (j >= 0 && j <= strat->tl && strat->S_2_T(j) != NULL
6806///// && strat->S_2_T(j)->p == strat->S[j]); // wrong?
6807// assume (j >= 0 && j <= strat->sl && strat->S_2_T(j) != NULL && strat->S_2_T(j)->p == strat->S[j]);
6808 return strat->S_2_T(j);
6809 }
6810 }
6811 else
6812 {
6813 TObject* t;
6814 if(!rField_is_Ring(r))
6815 {
6816 loop
6817 {
6818 if (j > end_pos) return NULL;
6819 assume(strat->S_2_R[j] != -1);
6820 #if defined(PDEBUG) || defined(PDIV_DEBUG)
6821 t = strat->S_2_T(j);
6822 assume(t != NULL && t->t_p != NULL && t->tailRing == r);
6823 if (p_LmShortDivisibleBy(t->t_p, sev[j], p, not_sev, r)
6824 && (ecart== LONG_MAX || ecart>= strat->ecartS[j]))
6825 {
6826 t->pLength=pLength(t->t_p);
6827 return t;
6828 }
6829 #else
6830 if (! (sev[j] & not_sev)
6831 && (ecart== LONG_MAX || ecart>= strat->ecartS[j]))
6832 {
6833 t = strat->S_2_T(j);
6834 assume(t != NULL && t->t_p != NULL && t->tailRing == r && t->p == strat->S[j]);
6835 if (p_LmDivisibleBy(t->t_p, p, r))
6836 {
6837 t->pLength=pLength(t->t_p);
6838 return t;
6839 }
6840 }
6841 #endif
6842 j++;
6843 }
6844 }
6845 #ifdef HAVE_RINGS
6846 else
6847 {
6848 loop
6849 {
6850 if (j > end_pos) return NULL;
6851 assume(strat->S_2_R[j] != -1);
6852 #if defined(PDEBUG) || defined(PDIV_DEBUG)
6853 t = strat->S_2_T(j);
6854 assume(t != NULL && t->t_p != NULL && t->tailRing == r);
6855 if (p_LmShortDivisibleBy(t->t_p, sev[j], p, not_sev, r)
6856 && (ecart== LONG_MAX || ecart>= strat->ecartS[j])
6857 && n_DivBy(pGetCoeff(p), pGetCoeff(t->t_p), r->cf))
6858 {
6859 t->pLength=pLength(t->t_p);
6860 return t;
6861 }
6862 #else
6863 if (! (sev[j] & not_sev)
6864 && (ecart== LONG_MAX || ecart>= strat->ecartS[j]))
6865 {
6866 t = strat->S_2_T(j);
6867 assume(t != NULL && t->t_p != NULL && t->tailRing == r && t->p == strat->S[j]);
6868 if (p_LmDivisibleBy(t->t_p, p, r)
6869 && n_DivBy(pGetCoeff(p), pGetCoeff(t->t_p), r->cf))
6870 {
6871 t->pLength=pLength(t->t_p);
6872 return t;
6873 }
6874 }
6875 #endif
6876 j++;
6877 }
6878 }
6879 #endif
6880 }
6881}
skStrategy::S_2_T
KINLINE TObject * S_2_T(int i)
Definition: kInline.h:38

◆ kFindDivisibleByInT()

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

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

Definition at line 321 of file kstd2.cc.

322{
323 unsigned long not_sev = ~L->sev;
324 int j = start;
325
326 const TSet T=strat->T;
327 const unsigned long* sevT=strat->sevT;
328 const ring r=currRing;
329 const BOOLEAN is_Ring=rField_is_Ring(r);
330 if (L->p!=NULL)
331 {
332 const poly p=L->p;
333
334 pAssume(~not_sev == p_GetShortExpVector(p, r));
335
336 if(is_Ring)
337 {
338 loop
339 {
340 if (j > strat->tl) return -1;
341#if defined(PDEBUG) || defined(PDIV_DEBUG)
342 if ((T[j].p!=NULL)
343 && p_LmShortDivisibleBy(T[j].p, sevT[j],p, not_sev, r))
344#else
345 if (!(sevT[j] & not_sev)
346 && (T[j].p!=NULL)
347 && p_LmDivisibleBy(T[j].p, p, r))
348#endif
349 {
350 if(n_DivBy(pGetCoeff(p), pGetCoeff(T[j].p), r->cf))
351 return j;
352 }
353 j++;
354 }
355 }
356 else
357 {
358 loop
359 {
360 if (j > strat->tl) return -1;
361#if defined(PDEBUG) || defined(PDIV_DEBUG)
362 if ((T[j].p!=NULL)
363 && p_LmShortDivisibleBy(T[j].p, sevT[j],p, not_sev, r))
364#else
365 if (!(sevT[j] & not_sev)
366 && (T[j].p!=NULL)
367 && p_LmDivisibleBy(T[j].p, p, r))
368#endif
369 {
370 return j;
371 }
372 j++;
373 }
374 }
375 }
376 else
377 {
378 const poly p=L->t_p;
379 const ring r=strat->tailRing;
380 if(is_Ring)
381 {
382 loop
383 {
384 if (j > strat->tl) return -1;
385#if defined(PDEBUG) || defined(PDIV_DEBUG)
386 if (p_LmShortDivisibleBy(T[j].t_p, sevT[j],
387 p, not_sev, r))
388#else
389 if (!(sevT[j] & not_sev) &&
390 p_LmDivisibleBy(T[j].t_p, p, r))
391#endif
392 {
393 if(n_DivBy(pGetCoeff(p), pGetCoeff(T[j].t_p), r->cf))
394 return j;
395 }
396 j++;
397 }
398 }
399 else
400 {
401 loop
402 {
403 if (j > strat->tl) return -1;
404#if defined(PDEBUG) || defined(PDIV_DEBUG)
405 if (p_LmShortDivisibleBy(T[j].t_p, sevT[j],
406 p, not_sev, r))
407#else
408 if (!(sevT[j] & not_sev) &&
409 p_LmDivisibleBy(T[j].t_p, p, r))
410#endif
411 {
412 return j;
413 }
414 j++;
415 }
416 }
417 }
418}

◆ kFindDivisibleByInT_Z()

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

Definition at line 213 of file kstd2.cc.

214{
215 unsigned long not_sev = ~L->sev;
216 int j = start;
217 int o = -1;
218
219 const TSet T=strat->T;
220 const unsigned long* sevT=strat->sevT;
221 number rest, orest, mult;
222 if (L->p!=NULL)
223 {
224 const ring r=currRing;
225 const poly p=L->p;
226 orest = pGetCoeff(p);
227
228 pAssume(~not_sev == p_GetShortExpVector(p, r));
229
230 loop
231 {
232 if (j > strat->tl) return o;
233#if defined(PDEBUG) || defined(PDIV_DEBUG)
234 if (p_LmShortDivisibleBy(T[j].p, sevT[j],p, not_sev, r))
235#else
236 if (!(sevT[j] & not_sev) && p_LmDivisibleBy(T[j].p, p, r))
237#endif
238 {
239 mult= n_QuotRem(pGetCoeff(p), pGetCoeff(T[j].p), &rest, r->cf);
240 if (!n_IsZero(mult, r->cf) && n_Greater(n_EucNorm(orest, r->cf), n_EucNorm(rest, r->cf), r->cf))
241 {
242 o = j;
243 orest = rest;
244 }
245 }
246 j++;
247 }
248 }
249 else
250 {
251 const ring r=strat->tailRing;
252 const poly p=L->t_p;
253 orest = pGetCoeff(p);
254 loop
255 {
256 if (j > strat->tl) return o;
257#if defined(PDEBUG) || defined(PDIV_DEBUG)
258 if (p_LmShortDivisibleBy(T[j].t_p, sevT[j],
259 p, not_sev, r))
260#else
261 if (!(sevT[j] & not_sev) && p_LmDivisibleBy(T[j].t_p, p, r))
262#endif
263 {
264 mult = n_QuotRem(pGetCoeff(p), pGetCoeff(T[j].t_p), &rest, r->cf);
265 if (!n_IsZero(mult, r->cf) && n_Greater(n_EucNorm(orest, r->cf), n_EucNorm(rest, r->cf), r->cf))
266 {
267 o = j;
268 orest = rest;
269 }
270 }
271 j++;
272 }
273 }
274}
n_EucNorm
static FORCE_INLINE number n_EucNorm(number a, const coeffs r)
Definition: coeffs.h:672
n_QuotRem
static FORCE_INLINE number n_QuotRem(number a, number b, number *q, const coeffs r)
Definition: coeffs.h:678
n_Greater
static FORCE_INLINE BOOLEAN n_Greater(number a, number b, const coeffs r)
ordered fields: TRUE iff 'a' is larger than 'b'; in Z/pZ: TRUE iff la > lb, where la and lb are the l...
Definition: coeffs.h:508
n_IsZero
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
Definition: coeffs.h:461
mult
void mult(unsigned long *result, unsigned long *a, unsigned long *b, unsigned long p, int dega, int degb)
Definition: minpoly.cc:647

◆ kFindInL1()

static int kFindInL1 ( const poly  p,
const kStrategy  strat 
)
inlinestatic

Definition at line 851 of file kutil.h.

852{
853 for(int i=strat->Ll;i>=0;i--)
854 {
855 if (p==strat->L[i].p1) return i;
856 }
857 return -1;
858}

◆ kFindInT()

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

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

Definition at line 718 of file kutil.cc.

719{
720 int i;
721
722 for (i=0; i<=tlength; i++)
723 {
724 if (T[i].p == p) return i;
725 }
726 return -1;
727}

◆ kFindInTShift()

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

Definition at line 743 of file kutil.cc.

744{
745 int i;
746
747 for (i=0; i<=tlength; i++)
748 {
749 // in the Letterplace ring the LMs in T and L are copies thus we have to use pEqualPolys() instead of ==
750 if (pEqualPolys(T[i].p, p)) return i;
751 }
752 return -1;
753}
pEqualPolys
#define pEqualPolys(p1, p2)
Definition: polys.h:399

◆ kFindNextDivisibleByInS()

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

Definition at line 524 of file kstd2.cc.

525{
526 unsigned long not_sev = ~L->sev;
527 poly p = L->GetLmCurrRing();
528 int j = start;
529
530 pAssume(~not_sev == p_GetShortExpVector(p, currRing));
531#if 1
532 int ende=max_ind;
533#else
534 int ende=strat->sl;
535#endif
536 loop
537 {
538 if (j > ende) return -1;
539#if defined(PDEBUG) || defined(PDIV_DEBUG)
540 if (p_LmShortDivisibleBy(strat->S[j], strat->sevS[j],
541 p, not_sev, currRing))
542#else
543 if ( !(strat->sevS[j] & not_sev) &&
544 p_LmDivisibleBy(strat->S[j], p, currRing))
545#endif
546 {
547 return j;
548 }
549 j++;
550 }
551}

◆ kFindSameLMInT_Z()

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

◆ kFindZeroPoly()

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

Definition at line 569 of file kstd2.cc.

570{
571 // m = currRing->ch
572
573 if (input_p == NULL) return NULL;
574
575 poly p = input_p;
576 poly zeroPoly = NULL;
577 unsigned long a = (unsigned long) pGetCoeff(p);
578
579 int k_ind2 = 0;
580 int a_ind2 = SI_LOG2_LONG(a);
581
582 // unsigned long k = 1;
583 // of interest is only k_ind2, special routine for improvement ... TODO OLIVER
584 for (int i = 1; i <= leadRing->N; i++)
585 {
586 k_ind2 = k_ind2 + ind_fact_2(p_GetExp(p, i, leadRing));
587 }
588
589 a = (unsigned long) pGetCoeff(p);
590
591 number tmp1;
592 poly tmp2, tmp3;
593 poly lead_mult = p_ISet(1, tailRing);
594 if (n_GetChar(leadRing->cf) <= k_ind2 + a_ind2)
595 {
596 int too_much = k_ind2 + a_ind2 - n_GetChar(leadRing->cf);
597 int s_exp;
598 zeroPoly = p_ISet(a, tailRing);
599 for (int i = 1; i <= leadRing->N; i++)
600 {
601 s_exp = p_GetExp(p, i,leadRing);
602 if (s_exp % 2 != 0)
603 {
604 s_exp = s_exp - 1;
605 }
606 while ( (0 < SI_LOG2_LONG(s_exp)) && (SI_LOG2_LONG(s_exp) <= too_much) )
607 {
608 too_much = too_much - SI_LOG2_LONG(s_exp);
609 s_exp = s_exp - 2;
610 }
611 p_SetExp(lead_mult, i, p_GetExp(p, i,leadRing) - s_exp, tailRing);
612 for (int j = 1; j <= s_exp; j++)
613 {
614 tmp1 = nInit(j);
615 tmp2 = p_ISet(1, tailRing);
616 p_SetExp(tmp2, i, 1, tailRing);
617 p_Setm(tmp2, tailRing);
618 if (nIsZero(tmp1))
619 { // should nowbe obsolet, test ! TODO OLIVER
620 zeroPoly = p_Mult_q(zeroPoly, tmp2, tailRing);
621 }
622 else
623 {
624 tmp3 = p_NSet(nCopy(tmp1), tailRing);
625 zeroPoly = p_Mult_q(zeroPoly, p_Add_q(tmp3, tmp2, tailRing), tailRing);
626 }
627 }
628 }
629 p_Setm(lead_mult, tailRing);
630 zeroPoly = p_Mult_mm(zeroPoly, lead_mult, tailRing);
631 tmp2 = p_NSet(nCopy(pGetCoeff(zeroPoly)), leadRing);
632 for (int i = 1; i <= leadRing->N; i++)
633 {
634 pSetExp(tmp2, i, p_GetExp(zeroPoly, i, tailRing));
635 }
636 p_Setm(tmp2, leadRing);
637 zeroPoly = p_LmDeleteAndNext(zeroPoly, tailRing);
638 pNext(tmp2) = zeroPoly;
639 return tmp2;
640 }
641/* unsigned long alpha_k = twoPow(leadRing->ch - k_ind2);
642 if (1 == 0 && alpha_k <= a)
643 { // Temporarily disabled, reducing coefficients not compatible with std TODO Oliver
644 zeroPoly = p_ISet((a / alpha_k)*alpha_k, tailRing);
645 for (int i = 1; i <= leadRing->N; i++)
646 {
647 for (unsigned long j = 1; j <= p_GetExp(p, i, leadRing); j++)
648 {
649 tmp1 = nInit(j);
650 tmp2 = p_ISet(1, tailRing);
651 p_SetExp(tmp2, i, 1, tailRing);
652 p_Setm(tmp2, tailRing);
653 if (nIsZero(tmp1))
654 {
655 zeroPoly = p_Mult_q(zeroPoly, tmp2, tailRing);
656 }
657 else
658 {
659 tmp3 = p_ISet((unsigned long) tmp1, tailRing);
660 zeroPoly = p_Mult_q(zeroPoly, p_Add_q(tmp2, tmp3, tailRing), tailRing);
661 }
662 }
663 }
664 tmp2 = p_ISet((unsigned long) pGetCoeff(zeroPoly), leadRing);
665 for (int i = 1; i <= leadRing->N; i++)
666 {
667 pSetExp(tmp2, i, p_GetExp(zeroPoly, i, tailRing));
668 }
669 p_Setm(tmp2, leadRing);
670 zeroPoly = p_LmDeleteAndNext(zeroPoly, tailRing);
671 pNext(tmp2) = zeroPoly;
672 return tmp2;
673 } */
674 return NULL;
675}
n_GetChar
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:441
tmp1
CFList tmp1
Definition: facFqBivar.cc:72
tmp2
CFList tmp2
Definition: facFqBivar.cc:72
ind_fact_2
static long ind_fact_2(long arg)
Definition: kstd2.cc:554
p_ISet
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
Definition: p_polys.cc:1297
p_NSet
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
Definition: p_polys.cc:1469
p_Mult_q
static poly p_Mult_q(poly p, poly q, const ring r)
Definition: p_polys.h:1112
p_Mult_mm
static poly p_Mult_mm(poly p, poly m, const ring r)
Definition: p_polys.h:1049
p_LmDeleteAndNext
static poly p_LmDeleteAndNext(poly p, const ring r)
Definition: p_polys.h:753
SI_LOG2_LONG
static int SI_LOG2_LONG(long v)
Definition: si_log2.h:22

◆ kFreeStrat()

void kFreeStrat ( kStrategy  strat)

◆ kNF2() [1/2]

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

Definition at line 4123 of file kstd2.cc.

4124{
4125 assume(!idIs0(q));
4126 assume(!(idIs0(F)&&(Q==NULL)));
4127// lazy_reduce flags: can be combined by |
4128//#define KSTD_NF_LAZY 1
4129 // do only a reduction of the leading term
4130//#define KSTD_NF_NONORM 4
4131 // only global: avoid normalization, return a multiply of NF
4132 poly p;
4133 int i;
4134 ideal res;
4135 int max_ind;
4136
4137 //if (idIs0(q))
4138 // return idInit(IDELEMS(q),si_max(q->rank,F->rank));
4139 //if ((idIs0(F))&&(Q==NULL))
4140 // return idCopy(q); /*F=0*/
4141 //strat->ak = idRankFreeModule(F);
4142 /*- creating temp data structures------------------- -*/
4143 BITSET save1;
4144 SI_SAVE_OPT1(save1);
4145 si_opt_1|=Sy_bit(OPT_REDTAIL);
4146 initBuchMoraCrit(strat);
4147 strat->initEcart = initEcartBBA;
4148#ifdef HAVE_SHIFTBBA
4149 if (rIsLPRing(currRing))
4150 {
4151 strat->enterS = enterSBbaShift;
4152 }
4153 else
4154#endif
4155 {
4156 strat->enterS = enterSBba;
4157 }
4158 /*- set S -*/
4159 strat->sl = -1;
4160#ifndef NO_BUCKETS
4161 strat->use_buckets = (!TEST_OPT_NOT_BUCKETS) && (!rIsPluralRing(currRing));
4162#endif
4163 /*- init local data struct.---------------------------------------- -*/
4164 /*Shdl=*/initS(F,Q,strat);
4165 /*- compute------------------------------------------------------- -*/
4166 res=idInit(IDELEMS(q),si_max(q->rank,F->rank));
4167 for (i=IDELEMS(q)-1; i>=0; i--)
4168 {
4169 if (q->m[i]!=NULL)
4170 {
4171 if (TEST_OPT_PROT) { PrintS("r");mflush(); }
4172 p = redNF(pCopy(q->m[i]),max_ind,
4173 (lazyReduce & KSTD_NF_NONORM)==KSTD_NF_NONORM,strat);
4174 if ((p!=NULL)&&((lazyReduce & KSTD_NF_LAZY)==0))
4175 {
4176 if (TEST_OPT_PROT) { PrintS("t"); mflush(); }
4177 if (rField_is_Ring(currRing))
4178 {
4179 p = redtailBba_NF(p,strat);
4180 }
4181 else
4182 {
4183 si_opt_1 &= ~Sy_bit(OPT_INTSTRATEGY);
4184 p = redtailBba(p,max_ind,strat,(lazyReduce & KSTD_NF_NONORM)==0);
4185 }
4186 }
4187 res->m[i]=p;
4188 }
4189 //else
4190 // res->m[i]=NULL;
4191 }
4192 /*- release temp data------------------------------- -*/
4193 assume(strat->L==NULL); /* strat->L unused */
4194 assume(strat->B==NULL); /* strat->B unused */
4195 omFree(strat->sevS);
4196 omFree(strat->ecartS);
4197 assume(strat->T==NULL);//omfree(strat->T);
4198 assume(strat->sevT==NULL);//omfree(strat->sevT);
4199 assume(strat->R==NULL);//omfree(strat->R);
4200 omfree(strat->S_2_R);
4201 omfree(strat->fromQ);
4202 idDelete(&strat->Shdl);
4203 SI_RESTORE_OPT1(save1);
4204 if (TEST_OPT_PROT) PrintLn();
4205 return res;
4206}
res
CanonicalForm res
Definition: facAbsFact.cc:60
KSTD_NF_LAZY
#define KSTD_NF_LAZY
Definition: kstd1.h:17
KSTD_NF_NONORM
#define KSTD_NF_NONORM
Definition: kstd1.h:21
redNF
poly redNF(poly h, int &max_ind, int nonorm, kStrategy strat)
Definition: kstd2.cc:2325
initS
void initS(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:7635
redtailBba_NF
poly redtailBba_NF(poly p, kStrategy strat)
Definition: kutil.cc:7398
enterSBbaShift
void enterSBbaShift(LObject &p, int atS, kStrategy strat, int atR)
Definition: kutil.cc:8929
omfree
#define omfree(addr)
Definition: omAllocDecl.h:237
omFree
#define omFree(addr)
Definition: omAllocDecl.h:261
si_opt_1
VAR unsigned si_opt_1
Definition: options.c:5
OPT_INTSTRATEGY
#define OPT_INTSTRATEGY
Definition: options.h:93
OPT_REDTAIL
#define OPT_REDTAIL
Definition: options.h:92
Sy_bit
#define Sy_bit(x)
Definition: options.h:31

◆ kNF2() [2/2]

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

Definition at line 3967 of file kstd2.cc.

3968{
3969 assume(q!=NULL);
3970 assume(!(idIs0(F)&&(Q==NULL))); // NF(q, std(0) in polynomial ring?
3971
3972// lazy_reduce flags: can be combined by |
3973//#define KSTD_NF_LAZY 1
3974 // do only a reduction of the leading term
3975//#define KSTD_NF_NONORM 4
3976 // only global: avoid normalization, return a multiply of NF
3977 poly p;
3978
3979 //if ((idIs0(F))&&(Q==NULL))
3980 // return pCopy(q); /*F=0*/
3981 //strat->ak = idRankFreeModule(F);
3982 /*- creating temp data structures------------------- -*/
3983 BITSET save1;
3984 SI_SAVE_OPT1(save1);
3985 si_opt_1|=Sy_bit(OPT_REDTAIL);
3986 initBuchMoraCrit(strat);
3987 strat->initEcart = initEcartBBA;
3988#ifdef HAVE_SHIFTBBA
3989 if (rIsLPRing(currRing))
3990 {
3991 strat->enterS = enterSBbaShift;
3992 }
3993 else
3994#endif
3995 {
3996 strat->enterS = enterSBba;
3997 }
3998#ifndef NO_BUCKETS
3999 strat->use_buckets = (!TEST_OPT_NOT_BUCKETS) && (!rIsPluralRing(currRing));
4000#endif
4001 /*- set S -*/
4002 strat->sl = -1;
4003 /*- init local data struct.---------------------------------------- -*/
4004 /*Shdl=*/initS(F,Q,strat);
4005 /*- compute------------------------------------------------------- -*/
4006 //if ((TEST_OPT_INTSTRATEGY)&&(lazyReduce==0))
4007 //{
4008 // for (i=strat->sl;i>=0;i--)
4009 // pNorm(strat->S[i]);
4010 //}
4011 kTest(strat);
4012 if (TEST_OPT_PROT) { PrintS("r"); mflush(); }
4013 if (BVERBOSE(23)) kDebugPrint(strat);
4014 int max_ind;
4015 p = redNF(pCopy(q),max_ind,(lazyReduce & KSTD_NF_NONORM)==KSTD_NF_NONORM,strat);
4016 if ((p!=NULL)&&((lazyReduce & KSTD_NF_LAZY)==0))
4017 {
4018 if (TEST_OPT_PROT) { PrintS("t"); mflush(); }
4019 if (rField_is_Z(currRing)||(rField_is_Zn(currRing)))
4020 {
4021 p = redtailBba_NF(p,strat);
4022 }
4023 else if (rField_is_Ring(currRing))
4024 {
4025 p = redtailBba_Ring(p,max_ind,strat);
4026 }
4027 else
4028 {
4029 si_opt_1 &= ~Sy_bit(OPT_INTSTRATEGY);
4030 p = redtailBba(p,max_ind,strat,(lazyReduce & KSTD_NF_NONORM)==0);
4031 }
4032 }
4033 /*- release temp data------------------------------- -*/
4034 assume(strat->L==NULL); /* strat->L unused */
4035 assume(strat->B==NULL); /* strat->B unused */
4036 omFree(strat->sevS);
4037 omFree(strat->ecartS);
4038 assume(strat->T==NULL);//omfree(strat->T);
4039 assume(strat->sevT==NULL);//omfree(strat->sevT);
4040 assume(strat->R==NULL);//omfree(strat->R);
4041 omfree(strat->S_2_R);
4042 omfree(strat->fromQ);
4043 idDelete(&strat->Shdl);
4044 SI_RESTORE_OPT1(save1);
4045 if (TEST_OPT_PROT) PrintLn();
4046 return p;
4047}
redtailBba_Ring
KINLINE poly redtailBba_Ring(poly p, int pos, kStrategy strat)
Definition: kInline.h:1227
kTest
BOOLEAN kTest(kStrategy strat)
Definition: kutil.cc:1012
rField_is_Zn
static BOOLEAN rField_is_Zn(const ring r)
Definition: ring.h:512

◆ kNF2Bound() [1/2]

ideal kNF2Bound ( ideal  F,
ideal  Q,
ideal  q,
int  bound,
kStrategy  strat,
int  lazyReduce 
)

Definition at line 4208 of file kstd2.cc.

4209{
4210 assume(!idIs0(q));
4211 assume(!(idIs0(F)&&(Q==NULL)));
4212// lazy_reduce flags: can be combined by |
4213//#define KSTD_NF_LAZY 1
4214 // do only a reduction of the leading term
4215//#define KSTD_NF_NONORM 4
4216 // only global: avoid normalization, return a multiply of NF
4217 poly p;
4218 int i;
4219 ideal res;
4220 int max_ind;
4221
4222 //if (idIs0(q))
4223 // return idInit(IDELEMS(q),si_max(q->rank,F->rank));
4224 //if ((idIs0(F))&&(Q==NULL))
4225 // return idCopy(q); /*F=0*/
4226 //strat->ak = idRankFreeModule(F);
4227 /*- creating temp data structures------------------- -*/
4228 BITSET save1;
4229 SI_SAVE_OPT1(save1);
4230 si_opt_1|=Sy_bit(OPT_REDTAIL);
4231 initBuchMoraCrit(strat);
4232 strat->initEcart = initEcartBBA;
4233 strat->enterS = enterSBba;
4234 /*- set S -*/
4235 strat->sl = -1;
4236#ifndef NO_BUCKETS
4237 strat->use_buckets = (!TEST_OPT_NOT_BUCKETS) && (!rIsPluralRing(currRing));
4238#endif
4239 /*- init local data struct.---------------------------------------- -*/
4240 /*Shdl=*/initS(F,Q,strat);
4241 /*- compute------------------------------------------------------- -*/
4242 res=idInit(IDELEMS(q),si_max(q->rank,F->rank));
4243 for (i=IDELEMS(q)-1; i>=0; i--)
4244 {
4245 if (q->m[i]!=NULL)
4246 {
4247 if (TEST_OPT_PROT) { PrintS("r");mflush(); }
4248 p = redNFBound(pCopy(q->m[i]),max_ind,
4249 (lazyReduce & KSTD_NF_NONORM)==KSTD_NF_NONORM,strat,bound);
4250 if ((p!=NULL)&&((lazyReduce & KSTD_NF_LAZY)==0))
4251 {
4252 if (TEST_OPT_PROT) { PrintS("t"); mflush(); }
4253 if (rField_is_Z(currRing)||(rField_is_Zn(currRing)))
4254 {
4255 p = redtailBba_Z(p,max_ind,strat);
4256 }
4257 else if (rField_is_Ring(currRing))
4258 {
4259 p = redtailBba_Ring(p,max_ind,strat);
4260 }
4261 else
4262 {
4263 si_opt_1 &= ~Sy_bit(OPT_INTSTRATEGY);
4264 p = redtailBbaBound(p,max_ind,strat,bound,(lazyReduce & KSTD_NF_NONORM)==0);
4265 }
4266 }
4267 res->m[i]=p;
4268 }
4269 //else
4270 // res->m[i]=NULL;
4271 }
4272 /*- release temp data------------------------------- -*/
4273 assume(strat->L==NULL); /* strat->L unused */
4274 assume(strat->B==NULL); /* strat->B unused */
4275 omFree(strat->sevS);
4276 omFree(strat->ecartS);
4277 assume(strat->T==NULL);//omfree(strat->T);
4278 assume(strat->sevT==NULL);//omfree(strat->sevT);
4279 assume(strat->R==NULL);//omfree(strat->R);
4280 omfree(strat->S_2_R);
4281 omfree(strat->fromQ);
4282 idDelete(&strat->Shdl);
4283 SI_RESTORE_OPT1(save1);
4284 if (TEST_OPT_PROT) PrintLn();
4285 return res;
4286}
bound
static CanonicalForm bound(const CFMatrix &M)
Definition: cf_linsys.cc:460
redtailBbaBound
KINLINE poly redtailBbaBound(poly p, int pos, kStrategy strat, int bound, BOOLEAN normalize)
Definition: kInline.h:1220
redtailBba_Z
KINLINE poly redtailBba_Z(poly p, int pos, kStrategy strat)
Definition: kInline.h:1232
redNFBound
poly redNFBound(poly h, int &max_ind, int nonorm, kStrategy strat, int bound)
Definition: kstd2.cc:2525

◆ kNF2Bound() [2/2]

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

Definition at line 4049 of file kstd2.cc.

4050{
4051 assume(q!=NULL);
4052 assume(!(idIs0(F)&&(Q==NULL))); // NF(q, std(0) in polynomial ring?
4053
4054// lazy_reduce flags: can be combined by |
4055//#define KSTD_NF_LAZY 1
4056 // do only a reduction of the leading term
4057//#define KSTD_NF_NONORM 4
4058 // only global: avoid normalization, return a multiply of NF
4059 poly p;
4060
4061 //if ((idIs0(F))&&(Q==NULL))
4062 // return pCopy(q); /*F=0*/
4063 //strat->ak = idRankFreeModule(F);
4064 /*- creating temp data structures------------------- -*/
4065 BITSET save1;
4066 SI_SAVE_OPT1(save1);
4067 si_opt_1|=Sy_bit(OPT_REDTAIL);
4068 initBuchMoraCrit(strat);
4069 strat->initEcart = initEcartBBA;
4070 strat->enterS = enterSBba;
4071#ifndef NO_BUCKETS
4072 strat->use_buckets = (!TEST_OPT_NOT_BUCKETS) && (!rIsPluralRing(currRing));
4073#endif
4074 /*- set S -*/
4075 strat->sl = -1;
4076 /*- init local data struct.---------------------------------------- -*/
4077 /*Shdl=*/initS(F,Q,strat);
4078 /*- compute------------------------------------------------------- -*/
4079 //if ((TEST_OPT_INTSTRATEGY)&&(lazyReduce==0))
4080 //{
4081 // for (i=strat->sl;i>=0;i--)
4082 // pNorm(strat->S[i]);
4083 //}
4084 kTest(strat);
4085 if (TEST_OPT_PROT) { PrintS("r"); mflush(); }
4086 if (BVERBOSE(23)) kDebugPrint(strat);
4087 int max_ind;
4088 p = redNFBound(pCopy(q),max_ind,lazyReduce & KSTD_NF_NONORM,strat,bound);
4089 if ((p!=NULL)&&((lazyReduce & KSTD_NF_LAZY)==0))
4090 {
4091 if (TEST_OPT_PROT) { PrintS("t"); mflush(); }
4092 if (rField_is_Z(currRing)||(rField_is_Zn(currRing)))
4093 {
4094 p = redtailBba_Z(p,max_ind,strat);
4095 }
4096 else if (rField_is_Ring(currRing))
4097 {
4098 p = redtailBba_Ring(p,max_ind,strat);
4099 }
4100 else
4101 {
4102 si_opt_1 &= ~Sy_bit(OPT_INTSTRATEGY);
4103 p = redtailBbaBound(p,max_ind,strat,bound,(lazyReduce & KSTD_NF_NONORM)==0);
4104 //p = redtailBba(p,max_ind,strat,(lazyReduce & KSTD_NF_NONORM)==0);
4105 }
4106 }
4107 /*- release temp data------------------------------- -*/
4108 assume(strat->L==NULL); /* strat->L unused */
4109 assume(strat->B==NULL); /* strat->B unused */
4110 omFree(strat->sevS);
4111 omFree(strat->ecartS);
4112 assume(strat->T==NULL);//omfree(strat->T);
4113 assume(strat->sevT==NULL);//omfree(strat->sevT);
4114 assume(strat->R==NULL);//omfree(strat->R);
4115 omfree(strat->S_2_R);
4116 omfree(strat->fromQ);
4117 idDelete(&strat->Shdl);
4118 SI_RESTORE_OPT1(save1);
4119 if (TEST_OPT_PROT) PrintLn();
4120 return p;
4121}

◆ ksCreateShortSpoly()

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

Definition at line 1453 of file kspoly.cc.

1454{
1455 poly a1 = pNext(p1), a2 = pNext(p2);
1456#ifdef HAVE_SHIFTBBA
1457 int shift1, shift2;
1458 if (tailRing->isLPring)
1459 {
1460 // assume: LM is shifted, tail unshifted
1461 assume(p_FirstVblock(a1, tailRing) <= 1);
1462 assume(p_FirstVblock(a2, tailRing) <= 1);
1463 // save the shift of the LM so we can shift the other monomials on demand
1464 shift1 = p_mFirstVblock(p1, tailRing) - 1;
1465 shift2 = p_mFirstVblock(p2, tailRing) - 1;
1466 }
1467#endif
1468 long c1=p_GetComp(p1, currRing),c2=p_GetComp(p2, currRing);
1469 long c;
1470 poly m1,m2;
1471 number t1 = NULL,t2 = NULL;
1472 int cm,i;
1473 BOOLEAN equal;
1474
1475#ifdef HAVE_RINGS
1476 BOOLEAN is_Ring=rField_is_Ring(currRing);
1477 number lc1 = pGetCoeff(p1), lc2 = pGetCoeff(p2);
1478 if (is_Ring)
1479 {
1480 ksCheckCoeff(&lc1, &lc2, currRing->cf); // gcd and zero divisors
1481 if (a1 != NULL) t2 = nMult(pGetCoeff(a1),lc2);
1482 if (a2 != NULL) t1 = nMult(pGetCoeff(a2),lc1);
1483 while (a1 != NULL && nIsZero(t2))
1484 {
1485 pIter(a1);
1486 nDelete(&t2);
1487 if (a1 != NULL) t2 = nMult(pGetCoeff(a1),lc2);
1488 }
1489 while (a2 != NULL && nIsZero(t1))
1490 {
1491 pIter(a2);
1492 nDelete(&t1);
1493 if (a2 != NULL) t1 = nMult(pGetCoeff(a2),lc1);
1494 }
1495 }
1496#endif
1497
1498#ifdef HAVE_SHIFTBBA
1499 // shift the next monomial on demand
1500 if (tailRing->isLPring)
1501 {
1502 a1 = p_LPCopyAndShiftLM(a1, shift1, tailRing);
1503 a2 = p_LPCopyAndShiftLM(a2, shift2, tailRing);
1504 }
1505#endif
1506 if (a1==NULL)
1507 {
1508 if(a2!=NULL)
1509 {
1510 m2=p_Init(currRing);
1511x2:
1512 for (i = (currRing->N); i; i--)
1513 {
1514 c = p_GetExpDiff(p1, p2,i, currRing);
1515 if (c>0)
1516 {
1517 p_SetExp(m2,i,(c+p_GetExp(a2,i,tailRing)),currRing);
1518 }
1519 else
1520 {
1521 p_SetExp(m2,i,p_GetExp(a2,i,tailRing),currRing);
1522 }
1523 }
1524 if ((c1==c2)||(c2!=0))
1525 {
1526 p_SetComp(m2,p_GetComp(a2,tailRing), currRing);
1527 }
1528 else
1529 {
1530 p_SetComp(m2,c1,currRing);
1531 }
1532 p_Setm(m2, currRing);
1533#ifdef HAVE_RINGS
1534 if (is_Ring)
1535 {
1536 nDelete(&lc1);
1537 nDelete(&lc2);
1538 nDelete(&t2);
1539 pSetCoeff0(m2, t1);
1540 }
1541#endif
1542#ifdef HAVE_SHIFTBBA
1543 if (tailRing->isLPring && (shift2!=0)) /*a1==NULL*/
1544 {
1545 p_LmDelete(a2, tailRing);
1546 }
1547#endif
1548 return m2;
1549 }
1550 else
1551 {
1552#ifdef HAVE_RINGS
1553 if (is_Ring)
1554 {
1555 nDelete(&lc1);
1556 nDelete(&lc2);
1557 nDelete(&t1);
1558 nDelete(&t2);
1559 }
1560#endif
1561 return NULL;
1562 }
1563 }
1564 if (a2==NULL)
1565 {
1566 m1=p_Init(currRing);
1567x1:
1568 for (i = (currRing->N); i; i--)
1569 {
1570 c = p_GetExpDiff(p2, p1,i,currRing);
1571 if (c>0)
1572 {
1573 p_SetExp(m1,i,(c+p_GetExp(a1,i, tailRing)),currRing);
1574 }
1575 else
1576 {
1577 p_SetExp(m1,i,p_GetExp(a1,i, tailRing), currRing);
1578 }
1579 }
1580 if ((c1==c2)||(c1!=0))
1581 {
1582 p_SetComp(m1,p_GetComp(a1,tailRing),currRing);
1583 }
1584 else
1585 {
1586 p_SetComp(m1,c2,currRing);
1587 }
1588 p_Setm(m1, currRing);
1589#ifdef HAVE_RINGS
1590 if (is_Ring)
1591 {
1592 pSetCoeff0(m1, t2);
1593 nDelete(&lc1);
1594 nDelete(&lc2);
1595 nDelete(&t1);
1596 }
1597#endif
1598#ifdef HAVE_SHIFTBBA
1599 if (tailRing->isLPring && (shift1!=0)) /*a2==NULL*/
1600 {
1601 p_LmDelete(a1, tailRing);
1602 }
1603#endif
1604 return m1;
1605 }
1606 m1 = p_Init(currRing);
1607 m2 = p_Init(currRing);
1608 loop
1609 {
1610 for (i = (currRing->N); i; i--)
1611 {
1612 c = p_GetExpDiff(p1, p2,i,currRing);
1613 if (c > 0)
1614 {
1615 p_SetExp(m2,i,(c+p_GetExp(a2,i,tailRing)), currRing);
1616 p_SetExp(m1,i,p_GetExp(a1,i, tailRing), currRing);
1617 }
1618 else
1619 {
1620 p_SetExp(m1,i,(p_GetExp(a1,i,tailRing)-c), currRing);
1621 p_SetExp(m2,i,p_GetExp(a2,i, tailRing), currRing);
1622 }
1623 }
1624 if(c1==c2)
1625 {
1626 p_SetComp(m1,p_GetComp(a1, tailRing), currRing);
1627 p_SetComp(m2,p_GetComp(a2, tailRing), currRing);
1628 }
1629 else
1630 {
1631 if(c1!=0)
1632 {
1633 p_SetComp(m1,p_GetComp(a1, tailRing), currRing);
1634 p_SetComp(m2,c1, currRing);
1635 }
1636 else
1637 {
1638 p_SetComp(m2,p_GetComp(a2, tailRing), currRing);
1639 p_SetComp(m1,c2, currRing);
1640 }
1641 }
1642 p_Setm(m1,currRing);
1643 p_Setm(m2,currRing);
1644 cm = p_LmCmp(m1, m2,currRing);
1645 if (cm!=0)
1646 {
1647 if(cm==1)
1648 {
1649 p_LmFree(m2,currRing);
1650#ifdef HAVE_RINGS
1651 if (is_Ring)
1652 {
1653 pSetCoeff0(m1, t2);
1654 nDelete(&lc1);
1655 nDelete(&lc2);
1656 nDelete(&t1);
1657 }
1658#endif
1659#ifdef HAVE_SHIFTBBA
1660 if (tailRing->isLPring)
1661 {
1662 if (shift1!=0) p_LmDelete(a1, tailRing);
1663 if (shift2!=0) p_LmDelete(a2, tailRing);
1664 }
1665#endif
1666 return m1;
1667 }
1668 else
1669 {
1670 p_LmFree(m1,currRing);
1671#ifdef HAVE_RINGS
1672 if (is_Ring)
1673 {
1674 pSetCoeff0(m2, t1);
1675 nDelete(&lc1);
1676 nDelete(&lc2);
1677 nDelete(&t2);
1678 }
1679#endif
1680#ifdef HAVE_SHIFTBBA
1681 if (tailRing->isLPring)
1682 {
1683 if (shift1!=0) p_LmDelete(a1, tailRing);
1684 if (shift2!=0) p_LmDelete(a2, tailRing);
1685 }
1686#endif
1687 return m2;
1688 }
1689 }
1690#ifdef HAVE_RINGS
1691 if (is_Ring)
1692 {
1693 equal = nEqual(t1,t2);
1694 }
1695 else
1696#endif
1697 {
1698 t1 = nMult(pGetCoeff(a2),pGetCoeff(p1));
1699 t2 = nMult(pGetCoeff(a1),pGetCoeff(p2));
1700 equal = nEqual(t1,t2);
1701 nDelete(&t2);
1702 nDelete(&t1);
1703 }
1704 if (!equal)
1705 {
1706 p_LmFree(m2,currRing);
1707#ifdef HAVE_RINGS
1708 if (is_Ring)
1709 {
1710 pSetCoeff0(m1, nSub(t1, t2));
1711 nDelete(&lc1);
1712 nDelete(&lc2);
1713 nDelete(&t1);
1714 nDelete(&t2);
1715 }
1716#endif
1717#ifdef HAVE_SHIFTBBA
1718 if (tailRing->isLPring)
1719 {
1720 if (shift1!=0) p_LmDelete(a1, tailRing);
1721 if (shift2!=0) p_LmDelete(a2, tailRing);
1722 }
1723#endif
1724 return m1;
1725 }
1726 pIter(a1);
1727 pIter(a2);
1728#ifdef HAVE_RINGS
1729 if (is_Ring)
1730 {
1731 if (a2 != NULL)
1732 {
1733 nDelete(&t1);
1734 t1 = nMult(pGetCoeff(a2),lc1);
1735 }
1736 if (a1 != NULL)
1737 {
1738 nDelete(&t2);
1739 t2 = nMult(pGetCoeff(a1),lc2);
1740 }
1741 while ((a1 != NULL) && nIsZero(t2))
1742 {
1743 pIter(a1);
1744 if (a1 != NULL)
1745 {
1746 nDelete(&t2);
1747 t2 = nMult(pGetCoeff(a1),lc2);
1748 }
1749 }
1750 while ((a2 != NULL) && nIsZero(t1))
1751 {
1752 pIter(a2);
1753 if (a2 != NULL)
1754 {
1755 nDelete(&t1);
1756 t1 = nMult(pGetCoeff(a2),lc1);
1757 }
1758 }
1759 }
1760#endif
1761#ifdef HAVE_SHIFTBBA
1762 if (tailRing->isLPring)
1763 {
1764 a1 = p_LPCopyAndShiftLM(a1, shift1, tailRing);
1765 a2 = p_LPCopyAndShiftLM(a2, shift2, tailRing);
1766 }
1767#endif
1768 if (a2==NULL)
1769 {
1770 p_LmFree(m2,currRing);
1771 if (a1==NULL)
1772 {
1773#ifdef HAVE_RINGS
1774 if (is_Ring)
1775 {
1776 nDelete(&lc1);
1777 nDelete(&lc2);
1778 nDelete(&t1);
1779 nDelete(&t2);
1780 }
1781#endif
1782 p_LmFree(m1,currRing);
1783 return NULL;
1784 }
1785 goto x1;
1786 }
1787 if (a1==NULL)
1788 {
1789 p_LmFree(m1,currRing);
1790 goto x2;
1791 }
1792 }
1793}
equal
bool equal
Definition: cfModGcd.cc:4126
ksCheckCoeff
int ksCheckCoeff(number *a, number *b, const coeffs r)
Definition: kbuckets.cc:1504
nSub
#define nSub(n1, n2)
Definition: numbers.h:22
nMult
#define nMult(n1, n2)
Definition: numbers.h:17
p_LmDelete
static void p_LmDelete(poly p, const ring r)
Definition: p_polys.h:721
p_LPCopyAndShiftLM
poly p_LPCopyAndShiftLM(poly p, int sh, const ring r)
Definition: shiftgb.cc:35
p_mFirstVblock
int p_mFirstVblock(poly p, const ring ri)
Definition: shiftop.cc:478
p_FirstVblock
int p_FirstVblock(poly p, const ring r)
Definition: shiftop.cc:456

◆ ksCreateSpoly()

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

Definition at line 1208 of file kspoly.cc.

1211{
1212#ifdef KDEBUG
1213 create_count++;
1214#endif
1215 poly p1 = Pair->p1;
1216 poly p2 = Pair->p2;
1217 Pair->tailRing = tailRing;
1218
1219 assume(p1 != NULL);
1220 assume(p2 != NULL);
1221 assume(tailRing != NULL);
1222
1223 poly a1 = pNext(p1), a2 = pNext(p2);
1224 number lc1 = pGetCoeff(p1), lc2 = pGetCoeff(p2);
1225 int co=0/*, ct = ksCheckCoeff(&lc1, &lc2, currRing->cf)*/; // gcd and zero divisors
1226 (void) ksCheckCoeff(&lc1, &lc2, currRing->cf);
1227
1228 int l1=0, l2=0;
1229
1230 if (currRing->pCompIndex >= 0)
1231 {
1232 if (__p_GetComp(p1, currRing)!=__p_GetComp(p2, currRing))
1233 {
1234 if (__p_GetComp(p1, currRing)==0)
1235 {
1236 co=1;
1237 p_SetCompP(p1,__p_GetComp(p2, currRing), currRing, tailRing);
1238 }
1239 else
1240 {
1241 co=2;
1242 p_SetCompP(p2, __p_GetComp(p1, currRing), currRing, tailRing);
1243 }
1244 }
1245 }
1246
1247 // get m1 = LCM(LM(p1), LM(p2))/LM(p1)
1248 // m2 = LCM(LM(p1), LM(p2))/LM(p2)
1249 if (m1 == NULL)
1250 k_GetLeadTerms(p1, p2, currRing, m1, m2, tailRing);
1251
1252#ifdef HAVE_SHIFTBBA
1253 poly m12, m22;
1254 if (tailRing->isLPring)
1255 {
1256 assume(p_mFirstVblock(p1, tailRing) <= 1 || p_mFirstVblock(p2, tailRing) <= 1);
1257 k_SplitFrame(m1, m12, si_max(p_mFirstVblock(p1, tailRing), 1), tailRing);
1258 k_SplitFrame(m2, m22, si_max(p_mFirstVblock(p2, tailRing), 1), tailRing);
1259 // coeffs of m1,m2 are NULL here
1260 }
1261#endif
1262
1263 pSetCoeff0(m1, lc2);
1264 pSetCoeff0(m2, lc1); // and now, m1 * LT(p1) == m2 * LT(p2)
1265
1266 if (R != NULL)
1267 {
1268 if (Pair->i_r1 == -1)
1269 {
1270 l1 = pLength(p1) - 1;
1271 }
1272 else
1273 {
1274 l1 = (R[Pair->i_r1])->GetpLength() - 1;
1275 }
1276 if ((Pair->i_r2 == -1)||(R[Pair->i_r2]==NULL))
1277 {
1278 l2 = pLength(p2) - 1;
1279 }
1280 else
1281 {
1282 l2 = (R[Pair->i_r2])->GetpLength() - 1;
1283 }
1284 }
1285
1286 // get m2 * a2
1287#ifdef HAVE_SHIFTBBA
1288 if (tailRing->isLPring)
1289 {
1290 // m2*a2*m22
1291 poly tmp= tailRing->p_Procs->pp_mm_Mult(a2, m2, tailRing);
1292 a2 = tailRing->p_Procs->pp_Mult_mm(tmp, m22, tailRing);
1293 p_Delete(&tmp,tailRing);
1294 }
1295 else
1296#endif
1297 if (spNoether != NULL)
1298 {
1299 l2 = -1;
1300 a2 = tailRing->p_Procs->pp_Mult_mm_Noether(a2, m2, spNoether, l2, tailRing);
1301 assume(l2 == (int)pLength(a2));
1302 }
1303 else
1304 {
1305 a2 = tailRing->p_Procs->pp_Mult_mm(a2, m2, tailRing);
1306 }
1307#ifdef HAVE_RINGS
1308 if (!(rField_is_Domain(currRing))) l2 = pLength(a2);
1309#endif
1310
1311 Pair->SetLmTail(m2, a2, l2, use_buckets, tailRing);
1312
1313#ifdef HAVE_SHIFTBBA
1314 if (tailRing->isLPring)
1315 {
1316 // get m2*a2*m22 - m1*a1*m12
1317 poly tmp=tailRing->p_Procs->pp_Mult_mm(a1, m12, tailRing);
1318 Pair->Tail_Minus_mm_Mult_qq(m1, tmp, l1, spNoether);
1319 p_Delete(&tmp,tailRing);
1320 }
1321 else
1322#endif
1323 {
1324 // get m2*a2 - m1*a1
1325 Pair->Tail_Minus_mm_Mult_qq(m1, a1, l1, spNoether);
1326 }
1327
1328 // Clean-up time
1329 Pair->LmDeleteAndIter();
1330 p_LmDelete(m1, tailRing);
1331#ifdef HAVE_SHIFTBBA
1332 if (tailRing->isLPring)
1333 {
1334 // just to be sure, check that the shift is correct
1335 assume(Pair->shift == 0);
1336 assume(si_max(p_mFirstVblock(Pair->p, tailRing) - 1, 0) == Pair->shift); // == 0
1337
1338 p_LmDelete(m12, tailRing);
1339 p_LmDelete(m22, tailRing);
1340 // m2 is already deleted
1341 }
1342#endif
1343
1344 if (co != 0)
1345 {
1346 if (co==1)
1347 {
1348 p_SetCompP(p1,0, currRing, tailRing);
1349 }
1350 else
1351 {
1352 p_SetCompP(p2,0, currRing, tailRing);
1353 }
1354 }
1355}
create_count
VAR int create_count
Definition: kspoly.cc:28
rField_is_Domain
static BOOLEAN rField_is_Domain(const ring r)
Definition: ring.h:487
k_SplitFrame
void k_SplitFrame(poly &m1, poly &m2, int at, const ring r)
Definition: shiftop.cc:600
R
#define R
Definition: sirandom.c:27

◆ ksOldCreateSpoly()

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

Definition at line 1196 of file kInline.h.

1197{
1198 LObject L(r);
1199 L.p1 = p1;
1200 L.p2 = p2;
1201
1202 ksCreateSpoly(&L, spNoether);
1203 return L.GetLmCurrRing();
1204}

◆ ksOldSpolyRed()

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

Definition at line 1176 of file kInline.h.

1177{
1178 LObject L(p2);
1179 TObject T(p1);
1180
1181 ksReducePoly(&L, &T, spNoether);
1182
1183 return L.GetLmCurrRing();
1184}
ksReducePoly
int ksReducePoly(LObject *PR, TObject *PW, poly spNoether, number *coef, poly *mon, kStrategy strat, BOOLEAN reduce)
Definition: kspoly.cc:189

◆ ksOldSpolyRedNew()

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

Definition at line 1186 of file kInline.h.

1187{
1188 LObject L(p_Copy(p2, currRing));
1189 TObject T(p1);
1190
1191 ksReducePoly(&L, &T, spNoether);
1192
1193 return L.GetLmCurrRing();
1194}

◆ ksOldSpolyTail()

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

Definition at line 1206 of file kInline.h.

1207{
1208 LObject L(q, currRing, r);
1209 TObject T(p1, currRing, r);
1210
1211 ksReducePolyTail(&L, &T, q2, spNoether);
1212}
ksReducePolyTail
KINLINE int ksReducePolyTail(LObject *PR, TObject *PW, LObject *Red)
Definition: kInline.h:1149

◆ ksReducePoly()

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

Definition at line 189 of file kspoly.cc.

196{
197#ifdef KDEBUG
198 red_count++;
199#ifdef TEST_OPT_DEBUG_RED
200// if (TEST_OPT_DEBUG)
201// {
202// Print("Red %d:", red_count); PR->wrp(); Print(" with:");
203// PW->wrp();
204// //printf("\necart(PR)-ecart(PW): %i\n",PR->ecart-PW->ecart);
205// //pWrite(PR->p);
206// }
207#endif
208#endif
209 int ret = 0;
210 ring tailRing = PR->tailRing;
211 if (strat!=NULL)
212 {
213 kTest_L(PR,strat);
214 kTest_T(PW,strat);
215 }
216
217 poly p1 = PR->GetLmTailRing(); // p2 | p1
218 poly p2 = PW->GetLmTailRing(); // i.e. will reduce p1 with p2; lm = LT(p1) / LM(p2)
219 poly t2 = pNext(p2), lm = p1; // t2 = p2 - LT(p2); really compute P = LC(p2)*p1 - LT(p1)/LM(p2)*p2
220 assume(p1 != NULL && p2 != NULL);// Attention, we have rings and there LC(p2) and LC(p1) are special
221 p_CheckPolyRing(p1, tailRing);
222 p_CheckPolyRing(p2, tailRing);
223
224 pAssume1(p2 != NULL && p1 != NULL &&
225 p_DivisibleBy(p2, p1, tailRing));
226
227 pAssume1(p_GetComp(p1, tailRing) == p_GetComp(p2, tailRing) ||
228 (p_GetComp(p2, tailRing) == 0 &&
229 p_MaxComp(pNext(p2),tailRing) == 0));
230
231#ifdef HAVE_PLURAL
232 if (rIsPluralRing(currRing))
233 {
234 // for the time being: we know currRing==strat->tailRing
235 // no exp-bound checking needed
236 // (only needed if exp-bound(tailring)<exp-b(currRing))
237 if (PR->bucket!=NULL) nc_kBucketPolyRed_Z(PR->bucket, p2,coef,reduce);
238 else
239 {
240 poly _p = (PR->t_p != NULL ? PR->t_p : PR->p);
241 assume(_p != NULL);
242 nc_PolyPolyRed(_p, p2,coef, currRing);
243 if (PR->t_p!=NULL) PR->t_p=_p; else PR->p=_p;
244 PR->pLength=0; // usually not used, GetpLength re-computes it if needed
245 }
246 return 0;
247 }
248#endif
249
250 if ((t2==NULL)&&(mon==NULL)) // Divisor is just one term, therefore it will
251 { // just cancel the leading term
252 PR->LmDeleteAndIter();
253 if (coef != NULL) *coef = n_Init(1, tailRing->cf);
254 return 0;
255 }
256
257 p_ExpVectorSub(lm, p2, tailRing); // Calculate the Monomial we must multiply to p2
258
259 if (tailRing != currRing)
260 {
261 // check that reduction does not violate exp bound
262 while (PW->max_exp != NULL && !p_LmExpVectorAddIsOk(lm, PW->max_exp, tailRing))
263 {
264 // undo changes of lm
265 p_ExpVectorAdd(lm, p2, tailRing);
266 if (strat == NULL) return 2;
267 if (! kStratChangeTailRing(strat, PR, PW)) return -1;
268 tailRing = strat->tailRing;
269 p1 = PR->GetLmTailRing();
270 p2 = PW->GetLmTailRing();
271 t2 = pNext(p2);
272 lm = p1;
273 p_ExpVectorSub(lm, p2, tailRing);
274 ret = 1;
275 }
276 }
277
278#ifdef HAVE_SHIFTBBA
279 poly lmRight=NULL;
280 if (tailRing->isLPring)
281 {
282 assume(PR->shift == 0);
283 assume(PW->shift == si_max(p_mFirstVblock(PW->p, tailRing) - 1, 0));
284 k_SplitFrame(lm, lmRight, PW->shift + 1, tailRing);
285 }
286#endif
287
288 // take care of coef business
289 if (! n_IsOne(pGetCoeff(p2), tailRing->cf))
290 {
291 number bn = pGetCoeff(lm);
292 number an = pGetCoeff(p2);
293 int ct = ksCheckCoeff(&an, &bn, tailRing->cf); // Calculate special LC
294 if (reduce)
295 {
296 if(n_IsMOne(an, tailRing->cf))
297 {
298 an=n_InpNeg(an, tailRing->cf);
299 bn=n_InpNeg(bn, tailRing->cf);
300 ct+=1;
301 }
302#ifdef KDEBUG
303 else if(!n_IsOne(an,tailRing->cf))
304 {
305 StringSetS("ksReducePoly: ");n_Write(an,tailRing->cf);
306 StringAppendS("\n");
307 PrintS(StringEndS());
308 }
309#endif
310 }
311 // in case of reduce, do not multiply PR
312 p_SetCoeff(lm, bn, tailRing);
313 if ((ct == 0) || (ct == 2))
314 PR->Tail_Mult_nn(an);
315 if (coef != NULL) *coef = an;
316 else n_Delete(&an, tailRing->cf);
317 }
318 else
319 {
320 if (coef != NULL) *coef = n_Init(1, tailRing->cf);
321 }
322 if(mon!=NULL) *mon=pHead(lm);
323
324 // and finally,
325#ifdef HAVE_SHIFTBBA
326 if (tailRing->isLPring)
327 {
328 poly tmp=tailRing->p_Procs->pp_Mult_mm(t2, lmRight, tailRing);
329 PR->Tail_Minus_mm_Mult_qq(lm, tmp, pLength(t2), spNoether);
330 p_Delete(&tmp,tailRing);
331 p_Delete(&lm,tailRing);
332 p_Delete(&lmRight,tailRing);
333 }
334 else
335#endif
336 {
337 PR->Tail_Minus_mm_Mult_qq(lm, t2, pLength(t2) /*PW->GetpLength() - 1*/, spNoether);
338 }
339 assume(PW->GetpLength() == pLength(PW->p != NULL ? PW->p : PW->t_p));
340 PR->LmDeleteAndIter();
341
342 return ret;
343}
reduce
CanonicalForm reduce(const CanonicalForm &f, const CanonicalForm &M)
polynomials in M.mvar() are considered coefficients M univariate monic polynomial the coefficients of...
Definition: cf_ops.cc:660
n_IsMOne
static FORCE_INLINE BOOLEAN n_IsMOne(number n, const coeffs r)
TRUE iff 'n' represents the additive inverse of the one element, i.e. -1.
Definition: coeffs.h:469
n_InpNeg
static FORCE_INLINE number n_InpNeg(number n, const coeffs r)
in-place negation of n MUST BE USED: n = n_InpNeg(n) (no copy is returned)
Definition: coeffs.h:554
n_Delete
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition: coeffs.h:452
n_Write
static FORCE_INLINE void n_Write(number n, const coeffs r, const BOOLEAN bShortOut=TRUE)
Definition: coeffs.h:588
n_IsOne
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
Definition: coeffs.h:465
red_count
VAR int red_count
Definition: kspoly.cc:27
nc_kBucketPolyRed_Z
static void nc_kBucketPolyRed_Z(kBucket_pt b, poly p, number *c, BOOLEAN reduce)
Definition: nc.h:284
nc_PolyPolyRed
void nc_PolyPolyRed(poly &b, poly p, number *c, const ring r)
Definition: old.gring.cc:2238
pAssume1
#define pAssume1(cond)
Definition: monomials.h:171
p_ExpVectorSub
static void p_ExpVectorSub(poly p1, poly p2, const ring r)
Definition: p_polys.h:1438
p_DivisibleBy
static BOOLEAN p_DivisibleBy(poly a, poly b, const ring r)
Definition: p_polys.h:1898
p_MaxComp
static long p_MaxComp(poly p, ring lmRing, ring tailRing)
Definition: p_polys.h:290
p_CheckPolyRing
BOOLEAN p_CheckPolyRing(poly p, ring r)
Definition: pDebug.cc:112
StringSetS
void StringSetS(const char *st)
Definition: reporter.cc:128
StringAppendS
void StringAppendS(const char *st)
Definition: reporter.cc:107
StringEndS
char * StringEndS()
Definition: reporter.cc:151

◆ ksReducePolyBound()

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

Definition at line 595 of file kspoly.cc.

601{
602#ifdef KDEBUG
603 red_count++;
604#ifdef TEST_OPT_DEBUG_RED
605 if (TEST_OPT_DEBUG)
606 {
607 Print("Red %d:", red_count); PR->wrp(); Print(" with:");
608 PW->wrp();
609 //printf("\necart(PR)-ecart(PW): %i\n",PR->ecart-PW->ecart);
610 //pWrite(PR->p);
611 }
612#endif
613#endif
614 int ret = 0;
615 ring tailRing = PR->tailRing;
616 if (strat!=NULL)
617 {
618 kTest_L(PR,strat);
619 kTest_T(PW,strat);
620 }
621
622 poly p1 = PR->GetLmTailRing(); // p2 | p1
623 poly p2 = PW->GetLmTailRing(); // i.e. will reduce p1 with p2; lm = LT(p1) / LM(p2)
624 poly t2 = pNext(p2), lm = p1; // t2 = p2 - LT(p2); really compute P = LC(p2)*p1 - LT(p1)/LM(p2)*p2
625 assume(p1 != NULL && p2 != NULL);// Attention, we have rings and there LC(p2) and LC(p1) are special
626 p_CheckPolyRing(p1, tailRing);
627 p_CheckPolyRing(p2, tailRing);
628
629 pAssume1(p2 != NULL && p1 != NULL &&
630 p_DivisibleBy(p2, p1, tailRing));
631
632 pAssume1(p_GetComp(p1, tailRing) == p_GetComp(p2, tailRing) ||
633 (p_GetComp(p2, tailRing) == 0 &&
634 p_MaxComp(pNext(p2),tailRing) == 0));
635
636#ifdef HAVE_PLURAL
637 if (rIsPluralRing(currRing))
638 {
639 // for the time being: we know currRing==strat->tailRing
640 // no exp-bound checking needed
641 // (only needed if exp-bound(tailring)<exp-b(currRing))
642 if (PR->bucket!=NULL) nc_kBucketPolyRed_Z(PR->bucket, p2,coef,FALSE);
643 else
644 {
645 poly _p = (PR->t_p != NULL ? PR->t_p : PR->p);
646 assume(_p != NULL);
647 nc_PolyPolyRed(_p, p2,coef, currRing);
648 if (PR->t_p!=NULL) PR->t_p=_p; else PR->p=_p;
649 PR->pLength=0; // usually not used, GetpLength re-computes it if needed
650 }
651 return 0;
652 }
653#endif
654
655 if (t2==NULL) // Divisor is just one term, therefore it will
656 { // just cancel the leading term
657 PR->LmDeleteAndIter();
658 if (coef != NULL) *coef = n_Init(1, tailRing->cf);
659 return 0;
660 }
661
662 p_ExpVectorSub(lm, p2, tailRing); // Calculate the Monomial we must multiply to p2
663
664 if (tailRing != currRing)
665 {
666 // check that reduction does not violate exp bound
667 while (PW->max_exp != NULL && !p_LmExpVectorAddIsOk(lm, PW->max_exp, tailRing))
668 {
669 // undo changes of lm
670 p_ExpVectorAdd(lm, p2, tailRing);
671 if (strat == NULL) return 2;
672 if (! kStratChangeTailRing(strat, PR, PW)) return -1;
673 tailRing = strat->tailRing;
674 p1 = PR->GetLmTailRing();
675 p2 = PW->GetLmTailRing();
676 t2 = pNext(p2);
677 lm = p1;
678 p_ExpVectorSub(lm, p2, tailRing);
679 ret = 1;
680 }
681 }
682
683#ifdef HAVE_SHIFTBBA
684 poly lmRight;
685 if (tailRing->isLPring)
686 {
687 assume(PR->shift == 0);
688 assume(PW->shift == si_max(p_mFirstVblock(PW->p, tailRing) - 1, 0));
689 k_SplitFrame(lm, lmRight, PW->shift + 1, tailRing);
690 }
691#endif
692
693 // take care of coef business
694 if (! n_IsOne(pGetCoeff(p2), tailRing->cf))
695 {
696 number bn = pGetCoeff(lm);
697 number an = pGetCoeff(p2);
698 int ct = ksCheckCoeff(&an, &bn, tailRing->cf); // Calculate special LC
699 p_SetCoeff(lm, bn, tailRing);
700 if ((ct == 0) || (ct == 2))
701 PR->Tail_Mult_nn(an);
702 if (coef != NULL) *coef = an;
703 else n_Delete(&an, tailRing->cf);
704 }
705 else
706 {
707 if (coef != NULL) *coef = n_Init(1, tailRing->cf);
708 }
709
710
711 // and finally,
712#ifdef HAVE_SHIFTBBA
713 if (tailRing->isLPring)
714 {
715 PR->Tail_Minus_mm_Mult_qq(lm, tailRing->p_Procs->pp_Mult_mm(t2, lmRight, tailRing), pLength(t2), spNoether);
716 }
717 else
718#endif
719 {
720 PR->Tail_Minus_mm_Mult_qq(lm, t2, pLength(t2) /*PW->GetpLength() - 1*/, spNoether);
721 }
722 assume(PW->GetpLength() == pLength(PW->p != NULL ? PW->p : PW->t_p));
723 PR->LmDeleteAndIter();
724
725#if defined(KDEBUG) && defined(TEST_OPT_DEBUG_RED)
726 if (TEST_OPT_DEBUG)
727 {
728 Print(" to: "); PR->wrp(); Print("\n");
729 //printf("\nt^%i ", PR->ecart);pWrite(pHead(PR->p));
730 }
731#endif
732 return ret;
733}

◆ ksReducePolyGCD()

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

◆ ksReducePolyLC()

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

Definition at line 481 of file kspoly.cc.

486{
487#ifdef KDEBUG
488 red_count++;
489#ifdef TEST_OPT_DEBUG_RED
490// if (TEST_OPT_DEBUG)
491// {
492// Print("Red %d:", red_count); PR->wrp(); Print(" with:");
493// PW->wrp();
494// //printf("\necart(PR)-ecart(PW): %i\n",PR->ecart-PW->ecart);
495// //pWrite(PR->p);
496// }
497#endif
498#endif
499 /* printf("PR->P: ");
500 * p_Write(PR->p, currRing, PR->tailRing); */
501 int ret = 0;
502 ring tailRing = PR->tailRing;
503 if (strat!=NULL)
504 {
505 kTest_L(PR,strat);
506 kTest_T(PW,strat);
507 }
508
509 poly p1 = PR->GetLmTailRing(); // p2 | p1
510 poly p2 = PW->GetLmTailRing(); // i.e. will reduce p1 with p2; lm = LT(p1) / LM(p2)
511 poly t2 = pNext(p2), lm = p1; // t2 = p2 - LT(p2); really compute P = LC(p2)*p1 - LT(p1)/LM(p2)*p2
512 assume(p1 != NULL && p2 != NULL);// Attention, we have rings and there LC(p2) and LC(p1) are special
513 p_CheckPolyRing(p1, tailRing);
514 p_CheckPolyRing(p2, tailRing);
515
516 pAssume1(p2 != NULL && p1 != NULL &&
517 p_DivisibleBy(p2, p1, tailRing));
518
519 pAssume1(p_GetComp(p1, tailRing) == p_GetComp(p2, tailRing) ||
520 (p_GetComp(p2, tailRing) == 0 &&
521 p_MaxComp(pNext(p2),tailRing) == 0));
522
523#ifdef HAVE_PLURAL
524 if (rIsPluralRing(currRing))
525 {
526 // for the time being: we know currRing==strat->tailRing
527 // no exp-bound checking needed
528 // (only needed if exp-bound(tailring)<exp-b(currRing))
529 if (PR->bucket!=NULL) nc_kBucketPolyRed_Z(PR->bucket, p2,coef,FALSE);
530 else
531 {
532 poly _p = (PR->t_p != NULL ? PR->t_p : PR->p);
533 assume(_p != NULL);
534 nc_PolyPolyRed(_p, p2,coef, currRing);
535 if (PR->t_p!=NULL) PR->t_p=_p; else PR->p=_p;
536 PR->pLength=0; // usually not used, GetpLength re-computes it if needed
537 }
538 return 0;
539 }
540#endif
541
542 p_ExpVectorSub(lm, p2, tailRing); // Calculate the Monomial we must multiply to p2
543 p_SetCoeff(lm, n_Init(1, tailRing->cf), tailRing);
544 while (PW->max_exp != NULL && !p_LmExpVectorAddIsOk(lm, PW->max_exp, tailRing))
545 {
546 // undo changes of lm
547 p_ExpVectorAdd(lm, p2, tailRing);
548 if (strat == NULL) return 2;
549 /* if (! kStratChangeTailRing(strat, PR, PW)) return -1; */
550 tailRing = strat->tailRing;
551 p1 = PR->GetLmTailRing();
552 p2 = PW->GetLmTailRing();
553 t2 = pNext(p2);
554 lm = p1;
555 p_ExpVectorSub(lm, p2, tailRing);
556 ret = 1;
557 }
558
559#ifdef HAVE_SHIFTBBA
560 poly lmRight;
561 if (tailRing->isLPring)
562 {
563 assume(PR->shift == 0);
564 assume(PW->shift == si_max(p_mFirstVblock(PW->p, tailRing) - 1, 0));
565 k_SplitFrame(lm, lmRight, PW->shift + 1, tailRing);
566 }
567#endif
568
569 // and finally,
570#ifdef HAVE_SHIFTBBA
571 if (tailRing->isLPring)
572 {
573 PR->Tail_Minus_mm_Mult_qq(lm, tailRing->p_Procs->pp_Mult_mm(p2, lmRight, tailRing), pLength(p2), spNoether);
574 }
575 else
576#endif
577 {
578 PR->Tail_Minus_mm_Mult_qq(lm, p2, pLength(p2) /*PW->GetpLength() - 1*/, spNoether);
579 }
580 assume(PW->GetpLength() == pLength(PW->p != NULL ? PW->p : PW->t_p));
581
582 PR->LmDeleteAndIter();
583 p_SetCoeff(PR->p, *coef, currRing);
584
585#if defined(KDEBUG) && defined(TEST_OPT_DEBUG_RED)
586 if (TEST_OPT_DEBUG)
587 {
588 Print(" to: "); PR->wrp(); Print("\n");
589 //printf("\nt^%i ", PR->ecart);pWrite(pHead(PR->p));
590 }
591#endif
592 return ret;
593}

◆ ksReducePolySig()

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

Definition at line 742 of file kspoly.cc.

748{
749#ifdef KDEBUG
750 red_count++;
751#ifdef TEST_OPT_DEBUG_RED
752 if (TEST_OPT_DEBUG)
753 {
754 Print("Red %d:", red_count); PR->wrp(); Print(" with:");
755 PW->wrp();
756 }
757#endif
758#endif
759 int ret = 0;
760 ring tailRing = PR->tailRing;
761 if (strat!=NULL)
762 {
763 kTest_L(PR,strat);
764 kTest_T(PW,strat);
765 }
766
767 // signature-based stuff:
768 // checking for sig-safeness first
769 // NOTE: This has to be done in the current ring
770 //
771 /**********************************************
772 *
773 * TODO:
774 * --------------------------------------------
775 * if strat->sbaOrder == 1
776 * Since we are subdividing lower index and
777 * current index reductions it is enough to
778 * look at the polynomial part of the signature
779 * for a check. This should speed-up checking
780 * a lot!
781 * if !strat->sbaOrder == 0
782 * We are not subdividing lower and current index
783 * due to the fact that we are using the induced
784 * Schreyer order
785 *
786 * nevertheless, this different behaviour is
787 * taken care of by is_sigsafe
788 * => one reduction procedure can be used for
789 * both, the incremental and the non-incremental
790 * attempt!
791 * --------------------------------------------
792 *
793 *********************************************/
794 //printf("COMPARE IDX: %ld -- %ld\n",idx,strat->currIdx);
795 if (!PW->is_sigsafe)
796 {
797 poly sigMult = pCopy(PW->sig); // copy signature of reducer
798//#if 1
799#ifdef DEBUGF5
800 printf("IN KSREDUCEPOLYSIG: \n");
801 pWrite(pHead(f1));
802 pWrite(pHead(f2));
803 pWrite(sigMult);
804 printf("--------------\n");
805#endif
806 p_ExpVectorAddSub(sigMult,PR->GetLmCurrRing(),PW->GetLmCurrRing(),currRing);
807//#if 1
808#ifdef DEBUGF5
809 printf("------------------- IN KSREDUCEPOLYSIG: --------------------\n");
810 pWrite(pHead(f1));
811 pWrite(pHead(f2));
812 pWrite(sigMult);
813 pWrite(PR->sig);
814 printf("--------------\n");
815#endif
816 int sigSafe = p_LmCmp(PR->sig,sigMult,currRing);
817 // now we can delete the copied polynomial data used for checking for
818 // sig-safeness of the reduction step
819//#if 1
820#ifdef DEBUGF5
821 printf("%d -- %d sig\n",sigSafe,PW->is_sigsafe);
822
823#endif
824 //pDelete(&f1);
825 pDelete(&sigMult);
826 // go on with the computations only if the signature of p2 is greater than the
827 // signature of fm*p1
828 if(sigSafe != 1)
829 {
830 PR->is_redundant = TRUE;
831 return 3;
832 }
833 //PW->is_sigsafe = TRUE;
834 }
835 PR->is_redundant = FALSE;
836 poly p1 = PR->GetLmTailRing(); // p2 | p1
837 poly p2 = PW->GetLmTailRing(); // i.e. will reduce p1 with p2; lm = LT(p1) / LM(p2)
838 poly t2 = pNext(p2), lm = p1; // t2 = p2 - LT(p2); really compute P = LC(p2)*p1 - LT(p1)/LM(p2)*p2
839 assume(p1 != NULL && p2 != NULL);// Attention, we have rings and there LC(p2) and LC(p1) are special
840 p_CheckPolyRing(p1, tailRing);
841 p_CheckPolyRing(p2, tailRing);
842
843 pAssume1(p2 != NULL && p1 != NULL &&
844 p_DivisibleBy(p2, p1, tailRing));
845
846 pAssume1(p_GetComp(p1, tailRing) == p_GetComp(p2, tailRing) ||
847 (p_GetComp(p2, tailRing) == 0 &&
848 p_MaxComp(pNext(p2),tailRing) == 0));
849
850#ifdef HAVE_PLURAL
851 if (rIsPluralRing(currRing))
852 {
853 // for the time being: we know currRing==strat->tailRing
854 // no exp-bound checking needed
855 // (only needed if exp-bound(tailring)<exp-b(currRing))
856 if (PR->bucket!=NULL) nc_kBucketPolyRed_Z(PR->bucket, p2,coef,FALSE);
857 else
858 {
859 poly _p = (PR->t_p != NULL ? PR->t_p : PR->p);
860 assume(_p != NULL);
861 nc_PolyPolyRed(_p, p2, coef, currRing);
862 if (PR->t_p!=NULL) PR->t_p=_p; else PR->p=_p;
863 PR->pLength=0; // usaully not used, GetpLength re-comoutes it if needed
864 }
865 return 0;
866 }
867#endif
868
869 if (t2==NULL) // Divisor is just one term, therefore it will
870 { // just cancel the leading term
871 PR->LmDeleteAndIter();
872 if (coef != NULL) *coef = n_Init(1, tailRing->cf);
873 return 0;
874 }
875
876 p_ExpVectorSub(lm, p2, tailRing); // Calculate the Monomial we must multiply to p2
877
878 if (tailRing != currRing)
879 {
880 // check that reduction does not violate exp bound
881 while (PW->max_exp != NULL && !p_LmExpVectorAddIsOk(lm, PW->max_exp, tailRing))
882 {
883 // undo changes of lm
884 p_ExpVectorAdd(lm, p2, tailRing);
885 if (strat == NULL) return 2;
886 if (! kStratChangeTailRing(strat, PR, PW)) return -1;
887 tailRing = strat->tailRing;
888 p1 = PR->GetLmTailRing();
889 p2 = PW->GetLmTailRing();
890 t2 = pNext(p2);
891 lm = p1;
892 p_ExpVectorSub(lm, p2, tailRing);
893 ret = 1;
894 }
895 }
896
897#ifdef HAVE_SHIFTBBA
898 poly lmRight;
899 if (tailRing->isLPring)
900 {
901 assume(PR->shift == 0);
902 assume(PW->shift == si_max(p_mFirstVblock(PW->p, tailRing) - 1, 0));
903 k_SplitFrame(lm, lmRight, PW->shift + 1, tailRing);
904 }
905#endif
906
907 // take care of coef business
908 if (! n_IsOne(pGetCoeff(p2), tailRing->cf))
909 {
910 number bn = pGetCoeff(lm);
911 number an = pGetCoeff(p2);
912 int ct = ksCheckCoeff(&an, &bn, tailRing->cf); // Calculate special LC
913 p_SetCoeff(lm, bn, tailRing);
914 if ((ct == 0) || (ct == 2))
915 PR->Tail_Mult_nn(an);
916 if (coef != NULL) *coef = an;
917 else n_Delete(&an, tailRing->cf);
918 }
919 else
920 {
921 if (coef != NULL) *coef = n_Init(1, tailRing->cf);
922 }
923
924
925 // and finally,
926#ifdef HAVE_SHIFTBBA
927 if (tailRing->isLPring)
928 {
929 PR->Tail_Minus_mm_Mult_qq(lm, tailRing->p_Procs->pp_Mult_mm(t2, lmRight, tailRing), pLength(t2), spNoether);
930 }
931 else
932#endif
933 {
934 PR->Tail_Minus_mm_Mult_qq(lm, t2, PW->GetpLength() - 1, spNoether);
935 }
936 assume(PW->GetpLength() == (int)pLength(PW->p != NULL ? PW->p : PW->t_p));
937 PR->LmDeleteAndIter();
938
939#if defined(KDEBUG) && defined(TEST_OPT_DEBUG_RED)
940 if (TEST_OPT_DEBUG)
941 {
942 Print(" to: "); PR->wrp(); Print("\n");
943 }
944#endif
945 return ret;
946}
p_ExpVectorAddSub
static void p_ExpVectorAddSub(poly p1, poly p2, poly p3, const ring r)
Definition: p_polys.h:1454

◆ ksReducePolySigRing()

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

Definition at line 948 of file kspoly.cc.

954{
955#ifdef KDEBUG
956 red_count++;
957#ifdef TEST_OPT_DEBUG_RED
958 if (TEST_OPT_DEBUG)
959 {
960 Print("Red %d:", red_count); PR->wrp(); Print(" with:");
961 PW->wrp();
962 }
963#endif
964#endif
965 int ret = 0;
966 ring tailRing = PR->tailRing;
967 if (strat!=NULL)
968 {
969 kTest_L(PR,strat);
970 kTest_T(PW,strat);
971 }
972
973 // signature-based stuff:
974 // checking for sig-safeness first
975 // NOTE: This has to be done in the current ring
976 //
977 /**********************************************
978 *
979 * TODO:
980 * --------------------------------------------
981 * if strat->sbaOrder == 1
982 * Since we are subdividing lower index and
983 * current index reductions it is enough to
984 * look at the polynomial part of the signature
985 * for a check. This should speed-up checking
986 * a lot!
987 * if !strat->sbaOrder == 0
988 * We are not subdividing lower and current index
989 * due to the fact that we are using the induced
990 * Schreyer order
991 *
992 * nevertheless, this different behaviour is
993 * taken care of by is_sigsafe
994 * => one reduction procedure can be used for
995 * both, the incremental and the non-incremental
996 * attempt!
997 * --------------------------------------------
998 *
999 *********************************************/
1000 //printf("COMPARE IDX: %ld -- %ld\n",idx,strat->currIdx);
1001 if (!PW->is_sigsafe)
1002 {
1003 poly sigMult = pCopy(PW->sig); // copy signature of reducer
1004//#if 1
1005#ifdef DEBUGF5
1006 printf("IN KSREDUCEPOLYSIG: \n");
1007 pWrite(pHead(f1));
1008 pWrite(pHead(f2));
1009 pWrite(sigMult);
1010 printf("--------------\n");
1011#endif
1012 p_ExpVectorAddSub(sigMult,PR->GetLmCurrRing(),PW->GetLmCurrRing(),currRing);
1013 //I have also to set the leading coefficient for sigMult (in the case of rings)
1014 if(rField_is_Ring(currRing))
1015 {
1016 pSetCoeff(sigMult,nMult(nDiv(pGetCoeff(PR->p),pGetCoeff(PW->p)), pGetCoeff(sigMult)));
1017 if(nIsZero(pGetCoeff(sigMult)))
1018 {
1019 sigMult = NULL;
1020 }
1021 }
1022//#if 1
1023#ifdef DEBUGF5
1024 printf("------------------- IN KSREDUCEPOLYSIG: --------------------\n");
1025 pWrite(pHead(f1));
1026 pWrite(pHead(f2));
1027 pWrite(sigMult);
1028 pWrite(PR->sig);
1029 printf("--------------\n");
1030#endif
1031 int sigSafe;
1032 if(!rField_is_Ring(currRing))
1033 sigSafe = p_LmCmp(PR->sig,sigMult,currRing);
1034 // now we can delete the copied polynomial data used for checking for
1035 // sig-safeness of the reduction step
1036//#if 1
1037#ifdef DEBUGF5
1038 printf("%d -- %d sig\n",sigSafe,PW->is_sigsafe);
1039
1040#endif
1041 if(rField_is_Ring(currRing))
1042 {
1043 // Set the sig
1044 poly origsig = pCopy(PR->sig);
1045 if(sigMult != NULL)
1046 PR->sig = pHead(pSub(PR->sig, sigMult));
1047 //The sigs have the same lm, have to subtract
1048 //It may happen that now the signature is 0 (drop)
1049 if(PR->sig == NULL)
1050 {
1051 strat->sigdrop=TRUE;
1052 }
1053 else
1054 {
1055 if(pLtCmp(PR->sig,origsig) == 1)
1056 {
1057 // do not allow this reduction - it will increase it's signature
1058 // and the partially standard basis is just till the old sig, not the new one
1059 PR->is_redundant = TRUE;
1060 pDelete(&PR->sig);
1061 PR->sig = origsig;
1062 strat->blockred++;
1063 return 3;
1064 }
1065 if(pLtCmp(PR->sig,origsig) == -1)
1066 {
1067 strat->sigdrop=TRUE;
1068 }
1069 }
1070 pDelete(&origsig);
1071 }
1072 //pDelete(&f1);
1073 // go on with the computations only if the signature of p2 is greater than the
1074 // signature of fm*p1
1075 if(sigSafe != 1 && !rField_is_Ring(currRing))
1076 {
1077 PR->is_redundant = TRUE;
1078 return 3;
1079 }
1080 //PW->is_sigsafe = TRUE;
1081 }
1082 PR->is_redundant = FALSE;
1083 poly p1 = PR->GetLmTailRing(); // p2 | p1
1084 poly p2 = PW->GetLmTailRing(); // i.e. will reduce p1 with p2; lm = LT(p1) / LM(p2)
1085 poly t2 = pNext(p2), lm = p1; // t2 = p2 - LT(p2); really compute P = LC(p2)*p1 - LT(p1)/LM(p2)*p2
1086 assume(p1 != NULL && p2 != NULL);// Attention, we have rings and there LC(p2) and LC(p1) are special
1087 p_CheckPolyRing(p1, tailRing);
1088 p_CheckPolyRing(p2, tailRing);
1089
1090 pAssume1(p2 != NULL && p1 != NULL &&
1091 p_DivisibleBy(p2, p1, tailRing));
1092
1093 pAssume1(p_GetComp(p1, tailRing) == p_GetComp(p2, tailRing) ||
1094 (p_GetComp(p2, tailRing) == 0 &&
1095 p_MaxComp(pNext(p2),tailRing) == 0));
1096
1097#ifdef HAVE_PLURAL
1098 if (rIsPluralRing(currRing))
1099 {
1100 // for the time being: we know currRing==strat->tailRing
1101 // no exp-bound checking needed
1102 // (only needed if exp-bound(tailring)<exp-b(currRing))
1103 if (PR->bucket!=NULL) nc_kBucketPolyRed_Z(PR->bucket, p2,coef,FALSE);
1104 else
1105 {
1106 poly _p = (PR->t_p != NULL ? PR->t_p : PR->p);
1107 assume(_p != NULL);
1108 nc_PolyPolyRed(_p, p2, coef, currRing);
1109 if (PR->t_p!=NULL) PR->t_p=_p; else PR->p=_p;
1110 PR->pLength=0; // usaully not used, GetpLength re-comoutes it if needed
1111 }
1112 return 0;
1113 }
1114#endif
1115
1116 if (t2==NULL) // Divisor is just one term, therefore it will
1117 { // just cancel the leading term
1118 PR->LmDeleteAndIter();
1119 if (coef != NULL) *coef = n_Init(1, tailRing->cf);
1120 return 0;
1121 }
1122
1123 p_ExpVectorSub(lm, p2, tailRing); // Calculate the Monomial we must multiply to p2
1124
1125 if (tailRing != currRing)
1126 {
1127 // check that reduction does not violate exp bound
1128 while (PW->max_exp != NULL && !p_LmExpVectorAddIsOk(lm, PW->max_exp, tailRing))
1129 {
1130 // undo changes of lm
1131 p_ExpVectorAdd(lm, p2, tailRing);
1132 if (strat == NULL) return 2;
1133 if (! kStratChangeTailRing(strat, PR, PW)) return -1;
1134 tailRing = strat->tailRing;
1135 p1 = PR->GetLmTailRing();
1136 p2 = PW->GetLmTailRing();
1137 t2 = pNext(p2);
1138 lm = p1;
1139 p_ExpVectorSub(lm, p2, tailRing);
1140 ret = 1;
1141 }
1142 }
1143
1144#ifdef HAVE_SHIFTBBA
1145 poly lmRight;
1146 if (tailRing->isLPring)
1147 {
1148 assume(PR->shift == 0);
1149 assume(PW->shift == si_max(p_mFirstVblock(PW->p, tailRing) - 1, 0));
1150 k_SplitFrame(lm, lmRight, PW->shift + 1, tailRing);
1151 }
1152#endif
1153
1154 // take care of coef business
1155 if(rField_is_Ring(currRing))
1156 {
1157 p_SetCoeff(lm, nDiv(pGetCoeff(lm),pGetCoeff(p2)), tailRing);
1158 if (coef != NULL) *coef = n_Init(1, tailRing->cf);
1159 }
1160 else
1161 {
1162 if (! n_IsOne(pGetCoeff(p2), tailRing->cf))
1163 {
1164 number bn = pGetCoeff(lm);
1165 number an = pGetCoeff(p2);
1166 int ct = ksCheckCoeff(&an, &bn, tailRing->cf); // Calculate special LC
1167 p_SetCoeff(lm, bn, tailRing);
1168 if (((ct == 0) || (ct == 2)))
1169 PR->Tail_Mult_nn(an);
1170 if (coef != NULL) *coef = an;
1171 else n_Delete(&an, tailRing->cf);
1172 }
1173 else
1174 {
1175 if (coef != NULL) *coef = n_Init(1, tailRing->cf);
1176 }
1177 }
1178
1179 // and finally,
1180#ifdef HAVE_SHIFTBBA
1181 if (tailRing->isLPring)
1182 {
1183 PR->Tail_Minus_mm_Mult_qq(lm, tailRing->p_Procs->pp_Mult_mm(t2, lmRight, tailRing), pLength(t2), spNoether);
1184 }
1185 else
1186#endif
1187 {
1188 PR->Tail_Minus_mm_Mult_qq(lm, t2, PW->GetpLength() - 1, spNoether);
1189 }
1190 assume(PW->GetpLength() == (int)pLength(PW->p != NULL ? PW->p : PW->t_p));
1191 PR->LmDeleteAndIter();
1192
1193#if defined(KDEBUG) && defined(TEST_OPT_DEBUG_RED)
1194 if (TEST_OPT_DEBUG)
1195 {
1196 Print(" to: "); PR->wrp(); Print("\n");
1197 }
1198#endif
1199 return ret;
1200}
skStrategy::blockred
int blockred
Definition: kutil.h:364
nDiv
#define nDiv(a, b)
Definition: numbers.h:32
pSub
#define pSub(a, b)
Definition: polys.h:287

◆ ksReducePolyTail() [1/2]

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

Definition at line 1149 of file kInline.h.

1150{
1151 BOOLEAN ret;
1152 number coef;
1153
1154 assume(PR->GetLmCurrRing() != PW->GetLmCurrRing());
1155 Red->HeadNormalize();
1156 ret = ksReducePoly(Red, PW, NULL, &coef);
1157
1158 if (!ret)
1159 {
1160 if (! n_IsOne(coef, currRing->cf))
1161 {
1162 PR->Mult_nn(coef);
1163 // HANNES: mark for Normalize
1164 }
1165 n_Delete(&coef, currRing->cf);
1166 }
1167 return ret;
1168}

◆ ksReducePolyTail() [2/2]

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

Definition at line 1357 of file kspoly.cc.

1358{
1359 BOOLEAN ret;
1360 number coef;
1361 poly Lp = PR->GetLmCurrRing();
1362 poly Save = PW->GetLmCurrRing();
1363
1364 pAssume(pIsMonomOf(Lp, Current));
1365
1366 assume(Lp != NULL && Current != NULL && pNext(Current) != NULL);
1367 assume(PR->bucket == NULL);
1368
1369 LObject Red(pNext(Current), PR->tailRing);
1370 TObject With(PW, Lp == Save);
1371
1372 pAssume(!pHaveCommonMonoms(Red.p, With.p));
1373 ret = ksReducePoly(&Red, &With, spNoether, &coef);
1374
1375 if (!ret)
1376 {
1377 if (! n_IsOne(coef, currRing->cf))
1378 {
1379 pNext(Current) = NULL;
1380 if (Current == PR->p && PR->t_p != NULL)
1381 pNext(PR->t_p) = NULL;
1382 PR->Mult_nn(coef);
1383 }
1384
1385 n_Delete(&coef, currRing->cf);
1386 pNext(Current) = Red.GetLmTailRing();
1387 if (Current == PR->p && PR->t_p != NULL)
1388 pNext(PR->t_p) = pNext(Current);
1389 }
1390
1391 if (Lp == Save)
1392 With.Delete();
1393
1394 return ret;
1395}
pIsMonomOf
BOOLEAN pIsMonomOf(poly p, poly m)
Definition: pDebug.cc:165
pHaveCommonMonoms
BOOLEAN pHaveCommonMonoms(poly p, poly q)
Definition: pDebug.cc:175

◆ ksReducePolyZ()

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

◆ kStratChangeTailRing()

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

Definition at line 11021 of file kutil.cc.

11022{
11023 assume((strat->tailRing == currRing) || (strat->tailRing->bitmask <= currRing->bitmask));
11024 /* initial setup or extending */
11025
11026 if (rIsLPRing(currRing)) return TRUE;
11027 if (expbound == 0) expbound = strat->tailRing->bitmask << 1;
11028 if (expbound >= currRing->bitmask) return FALSE;
11029 strat->overflow=FALSE;
11030 ring new_tailRing = rModifyRing(currRing,
11031 // Hmmm .. the condition pFDeg == p_Deg
11032 // might be too strong
11033 (strat->homog && currRing->pFDeg == p_Deg && !(rField_is_Ring(currRing))), // omit degree
11034 (strat->ak==0), // omit_comp if the input is an ideal
11035 expbound); // exp_limit
11036
11037 if (new_tailRing == currRing) return TRUE;
11038
11039 strat->pOrigFDeg_TailRing = new_tailRing->pFDeg;
11040 strat->pOrigLDeg_TailRing = new_tailRing->pLDeg;
11041
11042 if (currRing->pFDeg != currRing->pFDegOrig)
11043 {
11044 new_tailRing->pFDeg = currRing->pFDeg;
11045 new_tailRing->pLDeg = currRing->pLDeg;
11046 }
11047
11048 if (TEST_OPT_PROT)
11049 Print("[%lu:%d", (unsigned long) new_tailRing->bitmask, new_tailRing->ExpL_Size);
11050 kTest_TS(strat);
11051 assume(new_tailRing != strat->tailRing);
11052 pShallowCopyDeleteProc p_shallow_copy_delete
11053 = pGetShallowCopyDeleteProc(strat->tailRing, new_tailRing);
11054
11055 omBin new_tailBin = omGetStickyBinOfBin(new_tailRing->PolyBin);
11056
11057 int i;
11058 for (i=0; i<=strat->tl; i++)
11059 {
11060 strat->T[i].ShallowCopyDelete(new_tailRing, new_tailBin,
11061 p_shallow_copy_delete);
11062 }
11063 for (i=0; i<=strat->Ll; i++)
11064 {
11065 assume(strat->L[i].p != NULL);
11066 if (pNext(strat->L[i].p) != strat->tail)
11067 strat->L[i].ShallowCopyDelete(new_tailRing, p_shallow_copy_delete);
11068 }
11069 if ((strat->P.t_p != NULL) ||
11070 ((strat->P.p != NULL) && pNext(strat->P.p) != strat->tail))
11071 strat->P.ShallowCopyDelete(new_tailRing, p_shallow_copy_delete);
11072
11073 if ((L != NULL) && (L->tailRing != new_tailRing))
11074 {
11075 if (L->i_r < 0)
11076 L->ShallowCopyDelete(new_tailRing, p_shallow_copy_delete);
11077 else
11078 {
11079 assume(L->i_r <= strat->tl);
11080 TObject* t_l = strat->R[L->i_r];
11081 assume(t_l != NULL);
11082 L->tailRing = new_tailRing;
11083 L->p = t_l->p;
11084 L->t_p = t_l->t_p;
11085 L->max_exp = t_l->max_exp;
11086 }
11087 }
11088
11089 if ((T != NULL) && (T->tailRing != new_tailRing && T->i_r < 0))
11090 T->ShallowCopyDelete(new_tailRing, new_tailBin, p_shallow_copy_delete);
11091
11092 omMergeStickyBinIntoBin(strat->tailBin, strat->tailRing->PolyBin);
11093 if (strat->tailRing != currRing)
11094 rKillModifiedRing(strat->tailRing);
11095
11096 strat->tailRing = new_tailRing;
11097 strat->tailBin = new_tailBin;
11098 strat->p_shallow_copy_delete
11099 = pGetShallowCopyDeleteProc(currRing, new_tailRing);
11100
11101 if (strat->kNoether != NULL)
11102 {
11103 if (strat->t_kNoether != NULL)
11104 p_LmFree(strat->t_kNoether, strat->tailRing);
11105 strat->t_kNoether=k_LmInit_currRing_2_tailRing(strat->kNoether, new_tailRing);
11106 }
11107
11108 kTest_TS(strat);
11109 if (TEST_OPT_PROT)
11110 PrintS("]");
11111 return TRUE;
11112}
skStrategy::t_kNoether
poly t_kNoether
Definition: kutil.h:330
skStrategy::pOrigFDeg_TailRing
pFDegProc pOrigFDeg_TailRing
Definition: kutil.h:298
skStrategy::pOrigLDeg_TailRing
pLDegProc pOrigLDeg_TailRing
Definition: kutil.h:299
omBin
omBin_t * omBin
Definition: omStructs.h:12
rKillModifiedRing
void rKillModifiedRing(ring r)
Definition: ring.cc:3059
rModifyRing
ring rModifyRing(ring r, BOOLEAN omit_degree, BOOLEAN try_omit_comp, unsigned long exp_limit)
Definition: ring.cc:2698
omGetStickyBinOfBin
#define omGetStickyBinOfBin(B)
Definition: xalloc.h:247
omMergeStickyBinIntoBin
#define omMergeStickyBinIntoBin(A, B)
Definition: xalloc.h:275

◆ kStratInitChangeTailRing()

void kStratInitChangeTailRing ( kStrategy  strat)

Definition at line 11114 of file kutil.cc.

11115{
11116 unsigned long l = 0;
11117 int i;
11118 long e;
11119
11120 assume(strat->tailRing == currRing);
11121
11122 for (i=0; i<= strat->Ll; i++)
11123 {
11124 l = p_GetMaxExpL(strat->L[i].p, currRing, l);
11125 }
11126 for (i=0; i<=strat->tl; i++)
11127 {
11128 // Hmm ... this we could do in one Step
11129 l = p_GetMaxExpL(strat->T[i].p, currRing, l);
11130 }
11131 if (rField_is_Ring(currRing))
11132 {
11133 l *= 2;
11134 }
11135 e = p_GetMaxExp(l, currRing);
11136 if (e <= 1) e = 2;
11137 if (rIsLPRing(currRing)) e = 1;
11138
11139 kStratChangeTailRing(strat, NULL, NULL, e);
11140}
p_GetMaxExpL
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
p_GetMaxExp
static unsigned long p_GetMaxExp(const unsigned long l, const ring r)
Definition: p_polys.h:779

◆ kTest()

BOOLEAN kTest ( kStrategy  strat)

Definition at line 1012 of file kutil.cc.

1013{
1014 int i;
1015 // test P
1016 kFalseReturn(kTest_L(&(strat->P), strat,
1017 (strat->P.p != NULL && pNext(strat->P.p)!=strat->tail),
1018 -1, strat->T, strat->tl));
1019
1020 // test T
1021 if (strat->T != NULL)
1022 {
1023 for (i=0; i<=strat->tl; i++)
1024 {
1025 kFalseReturn(kTest_T(&(strat->T[i]), strat, i, 'T'));
1026 if (strat->sevT[i] != pGetShortExpVector(strat->T[i].p))
1027 return dReportError("strat->sevT[%d] out of sync", i);
1028 }
1029 }
1030
1031 // test L
1032 if (strat->L != NULL)
1033 {
1034 for (i=0; i<=strat->Ll; i++)
1035 {
1036 kFalseReturn(kTest_L(&(strat->L[i]), strat,
1037 strat->L[i].Next() != strat->tail, i,
1038 strat->T, strat->tl));
1039 // may be unused
1040 //if (strat->use_buckets && strat->L[i].Next() != strat->tail &&
1041 // strat->L[i].Next() != NULL && strat->L[i].p1 != NULL)
1042 //{
1043 // assume(strat->L[i].bucket != NULL);
1044 //}
1045 }
1046 }
1047
1048 // test S
1049 if (strat->S != NULL)
1050 kFalseReturn(kTest_S(strat));
1051
1052 return TRUE;
1053}
kFalseReturn
#define kFalseReturn(x)
Definition: kutil.cc:780
kTest_S
BOOLEAN kTest_S(kStrategy strat)
Definition: kutil.cc:1055
dReportError
int dReportError(const char *fmt,...)
Definition: dError.cc:44

◆ kTest_L()

BOOLEAN kTest_L ( LObject *  L,
kStrategy  strat,
BOOLEAN  testp = FALSE,
int  lpos = -1,
TSet  T = NULL,
int  tlength = -1 
)

Definition at line 926 of file kutil.cc.

928{
929 ring strat_tailRing=strat->tailRing;
930 if (L->p!=NULL)
931 {
932 if ((L->t_p==NULL)
933 &&(pNext(L->p)!=NULL)
934 &&(pGetCoeff(pNext(L->p))!=NULL)) /* !=strat->tail*/
935 {
936 p_Test(pNext(L->p),currRing);
937 nTest(pGetCoeff(L->p));
938 }
939 }
940 if (L->t_p!=NULL)
941 {
942 if ((pNext(L->t_p)!=NULL)
943 &&(pGetCoeff(pNext(L->t_p))!=NULL)) /* !=strat->tail*/
944 {
945 p_Test(pNext(L->t_p),strat_tailRing);
946 nTest(pGetCoeff(L->t_p));
947 }
948 }
949 if ((L->p!=NULL)&&(L->t_p!=NULL)) assume(pGetCoeff(L->p)==pGetCoeff(L->t_p));
950
951 if (testp)
952 {
953 poly pn = NULL;
954 if (L->bucket != NULL)
955 {
956 kFalseReturn(kbTest(L->bucket));
957 r_assume(L->bucket->bucket_ring == L->tailRing);
958 if (L->p != NULL && pNext(L->p) != NULL)
959 {
960 pn = pNext(L->p);
961 pNext(L->p) = NULL;
962 }
963 }
964 kFalseReturn(kTest_T(L, strat, lpos, 'L'));
965 if (pn != NULL)
966 pNext(L->p) = pn;
967
968 ring r;
969 poly p;
970 L->GetLm(p, r);
971 if (L->sev != 0L)
972 {
973 if (p_GetShortExpVector(p, r) != L->sev)
974 {
975 return dReportError("L[%d] wrong sev: has %lo, specified to have %lo",
976 lpos, p_GetShortExpVector(p, r), L->sev);
977 }
978 }
979 }
980 if (L->p1 == NULL)
981 {
982 // L->p2 either NULL or "normal" poly
983 pFalseReturn(pp_Test(L->p2, currRing, L->tailRing));
984 }
985 else if (tlength > 0 && T != NULL && (lpos >=0))
986 {
987 // now p1 and p2 must be != NULL and must be contained in T
988 int i;
989#ifdef HAVE_SHIFTBBA
990 if (rIsLPRing(currRing))
991 i = kFindInTShift(L->p1, T, tlength);
992 else
993#endif
994 i = kFindInT(L->p1, T, tlength);
995 if (i < 0)
996 return dReportError("L[%d].p1 not in T",lpos);
997#ifdef HAVE_SHIFTBBA
998 if (rIsLPRing(currRing))
999 {
1000 if (rField_is_Ring(currRing)) return TRUE; // m*shift(q) is not in T
1001 i = kFindInTShift(L->p2, T, tlength);
1002 }
1003 else
1004#endif
1005 i = kFindInT(L->p2, T, tlength);
1006 if (i < 0)
1007 return dReportError("L[%d].p2 not in T",lpos);
1008 }
1009 return TRUE;
1010}
kbTest
BOOLEAN kbTest(kBucket_pt bucket)
Tests.
Definition: kbuckets.cc:197
kFindInTShift
int kFindInTShift(poly p, TSet T, int tlength)
Definition: kutil.cc:743
r_assume
#define r_assume(x)
Definition: mod2.h:390
pFalseReturn
#define pFalseReturn(cond)
Definition: monomials.h:139
nTest
#define nTest(a)
Definition: numbers.h:35

◆ kTest_S()

BOOLEAN kTest_S ( kStrategy  strat)

Definition at line 1055 of file kutil.cc.

1056{
1057 int i;
1058 BOOLEAN ret = TRUE;
1059 for (i=0; i<=strat->sl; i++)
1060 {
1061 if (strat->S[i] != NULL &&
1062 strat->sevS[i] != pGetShortExpVector(strat->S[i]))
1063 {
1064 return dReportError("S[%d] wrong sev: has %o, specified to have %o",
1065 i , pGetShortExpVector(strat->S[i]), strat->sevS[i]);
1066 }
1067 }
1068 return ret;
1069}

◆ kTest_T()

BOOLEAN kTest_T ( TObject *  T,
kStrategy  strat,
int  tpos = -1,
char  TN = '?' 
)

Definition at line 801 of file kutil.cc.

802{
803 ring tailRing = T->tailRing;
804 ring strat_tailRing = strat->tailRing;
805 if (strat_tailRing == NULL) strat_tailRing = tailRing;
806 r_assume(strat_tailRing == tailRing);
807
808 poly p = T->p;
809 // ring r = currRing;
810
811 if (T->p == NULL && T->t_p == NULL && i >= 0)
812 return dReportError("%c[%d].poly is NULL", TN, i);
813
814 if (T->p!=NULL)
815 {
816 nTest(pGetCoeff(T->p));
817 if ((T->t_p==NULL)&&(pNext(T->p)!=NULL)) p_Test(pNext(T->p),currRing);
818 }
819 if (T->t_p!=NULL)
820 {
821 nTest(pGetCoeff(T->t_p));
822 if (pNext(T->t_p)!=NULL) p_Test(pNext(T->t_p),strat_tailRing);
823 }
824 if ((T->p!=NULL)&&(T->t_p!=NULL)) assume(pGetCoeff(T->p)==pGetCoeff(T->t_p));
825
826 if (T->tailRing != currRing)
827 {
828 if (T->t_p == NULL && i > 0)
829 return dReportError("%c[%d].t_p is NULL", TN, i);
830 pFalseReturn(p_Test(T->t_p, T->tailRing));
831 if (T->p != NULL) pFalseReturn(p_LmTest(T->p, currRing));
832 if ((T->p != NULL) && (T->t_p != NULL))
833 {
834 const char* msg = kTest_LmEqual(T->p, T->t_p, T->tailRing);
835 if (msg != NULL)
836 return dReportError("%c[%d] %s", TN, i, msg);
837 // r = T->tailRing;
838 p = T->t_p;
839 }
840 if (T->p == NULL)
841 {
842 p = T->t_p;
843 // r = T->tailRing;
844 }
845 if (T->t_p != NULL && i >= 0 && TN == 'T')
846 {
847 if (pNext(T->t_p) == NULL)
848 {
849 if (T->max_exp != NULL)
850 return dReportError("%c[%d].max_exp is not NULL as it should be", TN, i);
851 }
852 else
853 {
854 if (T->max_exp == NULL)
855 return dReportError("%c[%d].max_exp is NULL", TN, i);
856 if (pNext(T->max_exp) != NULL)
857 return dReportError("pNext(%c[%d].max_exp) != NULL", TN, i);
858
859 pFalseReturn(p_CheckPolyRing(T->max_exp, tailRing));
860 omCheckBinAddrSize(T->max_exp, (omSizeWOfBin(tailRing->PolyBin))*SIZEOF_LONG);
861#if KDEBUG > 0
862 if (! sloppy_max)
863 {
864 poly test_max = p_GetMaxExpP(pNext(T->t_p), tailRing);
865 p_Setm(T->max_exp, tailRing);
866 p_Setm(test_max, tailRing);
867 BOOLEAN equal = p_ExpVectorEqual(T->max_exp, test_max, tailRing);
868 if (! equal)
869 return dReportError("%c[%d].max out of sync", TN, i);
870 p_LmFree(test_max, tailRing);
871 }
872#endif
873 }
874 }
875 }
876 else
877 {
878 if (T->p == NULL && i > 0)
879 return dReportError("%c[%d].p is NULL", TN, i);
880#ifdef HAVE_SHIFTBBA
881 if (currRing->isLPring && T->shift > 0)
882 {
883 // in this case, the order is not correct. test LM and tail separately
884 pFalseReturn(p_LmTest(T->p, currRing));
885 pFalseReturn(p_Test(pNext(T->p), currRing));
886 }
887 else
888#endif
889 {
890 pFalseReturn(p_Test(T->p, currRing));
891 }
892 }
893
894 if ((i >= 0) && (T->pLength != 0)
895 && (! rIsSyzIndexRing(currRing)) && (T->pLength != pLength(p)))
896 {
897 int l=T->pLength;
898 T->pLength=pLength(p);
899 return dReportError("%c[%d] pLength error: has %d, specified to have %d",
900 TN, i , pLength(p), l);
901 }
902
903 // check FDeg, for elements in L and T
904 if (i >= 0 && (TN == 'T' || TN == 'L'))
905 {
906 // FDeg has ir element from T of L set
907 if (strat->homog && (T->FDeg != T->pFDeg()))
908 {
909 int d=T->FDeg;
910 T->FDeg=T->pFDeg();
911 return dReportError("%c[%d] FDeg error: has %d, specified to have %d",
912 TN, i , T->pFDeg(), d);
913 }
914 }
915
916 // check is_normalized for elements in T
917 if (i >= 0 && TN == 'T')
918 {
919 if (T->is_normalized && ! nIsOne(pGetCoeff(p)))
920 return dReportError("T[%d] is_normalized error", i);
921
922 }
923 return TRUE;
924}
kTest_LmEqual
static const char * kTest_LmEqual(poly p, poly t_p, ring tailRing)
Definition: kutil.cc:783
omCheckBinAddrSize
#define omCheckBinAddrSize(addr, size)
Definition: omAllocDecl.h:326
omSizeWOfBin
#define omSizeWOfBin(bin_ptr)
Definition: omAllocPrivate.h:100
p_ExpVectorEqual
static BOOLEAN p_ExpVectorEqual(poly p1, poly p2, const ring r1, const ring r2)
Definition: p_polys.cc:4522

◆ kTest_TS()

BOOLEAN kTest_TS ( kStrategy  strat)

Definition at line 1073 of file kutil.cc.

1074{
1075 int i, j;
1076 // BOOLEAN ret = TRUE;
1077 kFalseReturn(kTest(strat));
1078
1079 // test strat->R, strat->T[i].i_r
1080 for (i=0; i<=strat->tl; i++)
1081 {
1082 if (strat->T[i].i_r < 0 || strat->T[i].i_r > strat->tl)
1083 return dReportError("strat->T[%d].i_r == %d out of bounds", i,
1084 strat->T[i].i_r);
1085 if (strat->R[strat->T[i].i_r] != &(strat->T[i]))
1086 return dReportError("T[%d].i_r with R out of sync", i);
1087 }
1088 // test containment of S inT
1089 if ((strat->S != NULL)&&(strat->tl>=0))
1090 {
1091 for (i=0; i<=strat->sl; i++)
1092 {
1093 j = kFindInT(strat->S[i], strat->T, strat->tl);
1094 if (j < 0)
1095 return dReportError("S[%d] not in T", i);
1096 if (strat->S_2_R[i] != strat->T[j].i_r)
1097 return dReportError("S_2_R[%d]=%d != T[%d].i_r=%d\n",
1098 i, strat->S_2_R[i], j, strat->T[j].i_r);
1099 }
1100 }
1101 // test strat->L[i].i_r1
1102 #ifdef HAVE_SHIFTBBA
1103 if (!rIsLPRing(currRing)) // in the Letterplace ring we currently don't set/use i_r1 and i_r2
1104 #endif
1105 if (strat->L!=NULL)
1106 {
1107 for (i=0; i<=strat->Ll; i++)
1108 {
1109 if (strat->L[i].p1 != NULL && strat->L[i].p2)
1110 {
1111 if (strat->L[i].i_r1 < 0 ||
1112 strat->L[i].i_r1 > strat->tl ||
1113 strat->L[i].T_1(strat)->p != strat->L[i].p1)
1114 return dReportError("L[%d].i_r1 out of sync", i);
1115 if (strat->L[i].i_r2 < 0 ||
1116 strat->L[i].i_r2 > strat->tl ||
1117 strat->L[i].T_2(strat)->p != strat->L[i].p2)
1118 return dReportError("L[%d].i_r2 out of sync", i);
1119 }
1120 else
1121 {
1122 if (strat->L[i].i_r1 != -1)
1123 return dReportError("L[%d].i_r1 out of sync", i);
1124 if (strat->L[i].i_r2 != -1)
1125 return dReportError("L[%d].i_r2 out of sync", i);
1126 }
1127 if (strat->L[i].i_r != -1)
1128 return dReportError("L[%d].i_r out of sync", i);
1129 }
1130 }
1131 return TRUE;
1132}

◆ kTestDivisibleByT0_Z()

int kTestDivisibleByT0_Z ( const kStrategy  strat,
const LObject *  L 
)

tests if T[0] divides the leading monomial of L, returns -1 if not

Definition at line 146 of file kstd2.cc.

147{
148 if (strat->tl < 1)
149 return -1;
150
151 unsigned long not_sev = ~L->sev;
152 const unsigned long sevT0 = strat->sevT[0];
153 number orest,rest,mult;
154 if (L->p!=NULL)
155 {
156 const poly T0p = strat->T[0].p;
157 const ring r = currRing;
158 const poly p = L->p;
159 orest = pGetCoeff(p);
160
161 pAssume(~not_sev == p_GetShortExpVector(p, r));
162
163#if defined(PDEBUG) || defined(PDIV_DEBUG)
164 if (p_LmShortDivisibleBy(T0p, sevT0, p, not_sev, r))
165#else
166 if (!(sevT0 & not_sev) && p_LmDivisibleBy(T0p, p, r))
167#endif
168 {
169 if (n_QuotRem!=ndQuotRem) /*euclidean ring*/
170 {
171 mult= n_QuotRem(pGetCoeff(p), pGetCoeff(T0p), &rest, r->cf);
172 if (!n_IsZero(mult, r->cf) && n_Greater(n_EucNorm(orest, r->cf), n_EucNorm(rest, r->cf), r->cf))
173 {
174 n_Delete(&mult,r->cf);
175 n_Delete(&rest,r->cf);
176 return 0;
177 }
178 n_Delete(&mult,r->cf);
179 n_Delete(&rest,r->cf);
180 }
181 }
182 }
183 else
184 {
185 const poly T0p = strat->T[0].t_p;
186 const ring r = strat->tailRing;
187 const poly p = L->t_p;
188 orest = pGetCoeff(p);
189#if defined(PDEBUG) || defined(PDIV_DEBUG)
190 if (p_LmShortDivisibleBy(T0p, sevT0,
191 p, not_sev, r))
192#else
193 if (!(sevT0 & not_sev) && p_LmDivisibleBy(T0p, p, r))
194#endif
195 {
196 if (n_QuotRem!=ndQuotRem) /*euclidean ring*/
197 {
198 mult= n_QuotRem(pGetCoeff(p), pGetCoeff(T0p), &rest, r->cf);
199 if (!n_IsZero(mult, r->cf) && n_Greater(n_EucNorm(orest, r->cf), n_EucNorm(rest, r->cf), r->cf))
200 {
201 n_Delete(&mult,r->cf);
202 n_Delete(&rest,r->cf);
203 return 0;
204 }
205 n_Delete(&mult,r->cf);
206 n_Delete(&rest,r->cf);
207 }
208 }
209 }
210 return -1;
211}
ndQuotRem
number ndQuotRem(number a, number b, number *r, const coeffs R)
Definition: numbers.cc:357

◆ message()

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

Definition at line 7512 of file kutil.cc.

7513{
7514 if (i != *olddeg)
7515 {
7516 Print("%d",i);
7517 *olddeg = i;
7518 }
7519 if (TEST_OPT_OLDSTD)
7520 {
7521 if (strat->Ll != *reduc)
7522 {
7523 if (strat->Ll != *reduc-1)
7524 Print("(%d)",strat->Ll+1);
7525 else
7526 PrintS("-");
7527 *reduc = strat->Ll;
7528 }
7529 else
7530 PrintS(".");
7531 mflush();
7532 }
7533 else
7534 {
7535 if (red_result == 0)
7536 PrintS("-");
7537 else if (red_result < 0)
7538 PrintS(".");
7539 if ((red_result > 0) || ((strat->Ll % 100)==99))
7540 {
7541 if (strat->Ll != *reduc && strat->Ll > 0)
7542 {
7543 Print("(%d)",strat->Ll+1);
7544 *reduc = strat->Ll;
7545 }
7546 }
7547 }
7548}

◆ messageSets()

void messageSets ( kStrategy  strat)

Definition at line 7585 of file kutil.cc.

7586{
7587 int i;
7588 if (strat->news)
7589 {
7590 PrintS("set S");
7591 for (i=0; i<=strat->sl; i++)
7592 {
7593 Print("\n %d:",i);
7594 p_wrp(strat->S[i], currRing, strat->tailRing);
7595 if (strat->fromQ!=NULL && strat->fromQ[i])
7596 Print(" (from Q)");
7597 }
7598 strat->news = FALSE;
7599 }
7600 if (strat->newt)
7601 {
7602 PrintS("\nset T");
7603 for (i=0; i<=strat->tl; i++)
7604 {
7605 Print("\n %d:",i);
7606 strat->T[i].wrp();
7607 if (strat->T[i].length==0) strat->T[i].length=pLength(strat->T[i].p);
7608 Print(" o:%ld e:%d l:%d",
7609 strat->T[i].pFDeg(),strat->T[i].ecart,strat->T[i].length);
7610 }
7611 strat->newt = FALSE;
7612 }
7613 PrintS("\nset L");
7614 for (i=strat->Ll; i>=0; i--)
7615 {
7616 Print("\n%d:",i);
7617 p_wrp(strat->L[i].p1, currRing, strat->tailRing);
7618 PrintS(" ");
7619 p_wrp(strat->L[i].p2, currRing, strat->tailRing);
7620 PrintS(" lcm: ");p_wrp(strat->L[i].lcm, currRing);
7621 PrintS("\n p : ");
7622 strat->L[i].wrp();
7623 Print(" o:%ld e:%d l:%d",
7624 strat->L[i].pFDeg(),strat->L[i].ecart,strat->L[i].length);
7625 }
7626 PrintLn();
7627}

◆ messageStat()

void messageStat ( int  hilbcount,
kStrategy  strat 
)

Definition at line 7553 of file kutil.cc.

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

◆ messageStatSBA()

void messageStatSBA ( int  hilbcount,
kStrategy  strat 
)

Definition at line 7566 of file kutil.cc.

7567{
7568 //PrintS("\nUsage/Allocation of temporary storage:\n");
7569 //Print("%d/%d polynomials in standard base\n",srmax,IDELEMS(Shdl));
7570 //Print("%d/%d polynomials in set L (for lazy alg.)",lrmax+1,strat->Lmax);
7571 Print("syz criterion:%d rew criterion:%d\n",strat->nrsyzcrit,strat->nrrewcrit);
7572 //Print("product criterion:%d chain criterion:%d\n",strat->cp,strat->c3);
7573 if (hilbcount!=0) Print("hilbert series criterion:%d\n",hilbcount);
7574 #ifdef HAVE_SHIFTBBA
7575 /* in usual case strat->cv is 0, it gets changed only in shift routines */
7576 if (strat->cv!=0) Print("shift V criterion:%d\n",strat->cv);
7577 #endif
7578}
skStrategy::nrsyzcrit
int nrsyzcrit
Definition: kutil.h:360

◆ newHEdge()

BOOLEAN newHEdge ( kStrategy  strat)

Definition at line 10462 of file kutil.cc.

10463{
10464 if (currRing->pLexOrder || rHasMixedOrdering(currRing))
10465 return FALSE;
10466 int i,j;
10467 poly newNoether;
10468
10469#if 0
10470 if (currRing->weight_all_1)
10471 scComputeHC(strat->Shdl,NULL,strat->ak,strat->kNoether);
10472 else
10473 scComputeHCw(strat->Shdl,NULL,strat->ak,strat->kNoether);
10474#else
10475 scComputeHC(strat->Shdl,NULL,strat->ak,strat->kNoether);
10476#endif
10477 if (strat->kNoether==NULL) return FALSE;
10478 if (strat->t_kNoether != NULL)
10479 {
10480 p_LmFree(strat->t_kNoether, strat->tailRing);
10481 strat->t_kNoether=NULL;
10482 }
10483 if (strat->tailRing != currRing)
10484 strat->t_kNoether = k_LmInit_currRing_2_tailRing(strat->kNoether, strat->tailRing);
10485 /* compare old and new noether*/
10486 newNoether = pLmInit(strat->kNoether);
10487 pSetCoeff0(newNoether,nInit(1));
10488 j = p_FDeg(newNoether,currRing);
10489 for (i=1; i<=(currRing->N); i++)
10490 {
10491 if (pGetExp(newNoether, i) > 0) pDecrExp(newNoether,i);
10492 }
10493 pSetm(newNoether);
10494 if (j < HCord) /*- statistics -*/
10495 {
10496 if (TEST_OPT_PROT)
10497 {
10498 Print("H(%d)",j);
10499 mflush();
10500 }
10501 HCord=j;
10502 #ifdef KDEBUG
10503 if (TEST_OPT_DEBUG)
10504 {
10505 Print("H(%d):",j);
10506 wrp(strat->kNoether);
10507 PrintLn();
10508 }
10509 #endif
10510 }
10511 if (pCmp(strat->kNoether,newNoether)!=1)
10512 {
10513 if (strat->kNoether!=NULL) p_LmDelete0(strat->kNoether,currRing);
10514 strat->kNoether=newNoether;
10515 if (strat->t_kNoether != NULL)
10516 {
10517 p_LmFree(strat->t_kNoether, strat->tailRing);
10518 strat->t_kNoether=NULL;
10519 }
10520 if (strat->tailRing != currRing)
10521 strat->t_kNoether = k_LmInit_currRing_2_tailRing(strat->kNoether, strat->tailRing);
10522
10523 return TRUE;
10524 }
10525 pLmDelete(newNoether);
10526 return FALSE;
10527}
scComputeHC
void scComputeHC(ideal S, ideal Q, int ak, poly &hEdge)
Definition: hdegree.cc:1101
HCord
VAR int HCord
Definition: kutil.cc:246
p_LmDelete0
static void p_LmDelete0(poly p, const ring r)
Definition: p_polys.h:731
pCmp
#define pCmp(p1, p2)
pCmp: args may be NULL returns: (p2==NULL ? 1 : (p1 == NULL ? -1 : p_LmCmp(p1, p2)))
Definition: polys.h:115
pLmInit
#define pLmInit(p)
like pInit, except that expvector is initialized to that of p, p must be != NULL
Definition: polys.h:64
pGetExp
#define pGetExp(p, i)
Exponent.
Definition: polys.h:41
pDecrExp
#define pDecrExp(p, i)
Definition: polys.h:44

◆ pairs()

void pairs ( )

◆ posInIdealMonFirst()

int posInIdealMonFirst ( const ideal  F,
const poly  p,
int  start = 0,
int  end = -1 
)

Definition at line 4863 of file kutil.cc.

4864{
4865 if(end < 0 || end >= IDELEMS(F))
4866 end = IDELEMS(F);
4867 if (end<0) return 0;
4868 if(pNext(p) == NULL) return start;
4869 polyset set=F->m;
4870 int o = p_Deg(p,currRing);
4871 int op;
4872 int i;
4873 int an = start;
4874 for(i=start;i<end;i++)
4875 if(set[i] != NULL && pNext(set[i]) == NULL)
4876 an++;
4877 if(an == end-1)
4878 return end;
4879 int en= end;
4880 loop
4881 {
4882 if(an>=en)
4883 return en;
4884 if (an == en-1)
4885 {
4886 op = p_Deg(set[an],currRing);
4887 if ((op < o)
4888 || ((op == o) && (pLtCmp(set[an],p) == -1)))
4889 return en;
4890 return an;
4891 }
4892 i=(an+en) / 2;
4893 op = p_Deg(set[i],currRing);
4894 if ((op < o)
4895 || ((op == o) && (pLtCmp(set[i],p) == -1)))
4896 an=i;
4897 else
4898 en=i;
4899 }
4900}
polyset
poly * polyset
Definition: polys.h:259

◆ posInL0()

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

Definition at line 5643 of file kutil.cc.

5645{
5646 if (length<0) return 0;
5647
5648 int cmp_int=currRing->OrdSgn;
5649
5650 if (pLmCmp(set[length].p,p->p)== cmp_int)
5651 return length+1;
5652
5653 int i;
5654 int an = 0;
5655 int en= length;
5656 loop
5657 {
5658 if (an >= en-1)
5659 {
5660 if (pLmCmp(set[an].p,p->p) == cmp_int) return en;
5661 return an;
5662 }
5663 i=(an+en) / 2;
5664 if (pLmCmp(set[i].p,p->p) == cmp_int) an=i;
5665 else en=i;
5666 /*aend. fuer lazy == in !=- machen */
5667 }
5668}

◆ posInL10()

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

Definition at line 1365 of file kstd1.cc.

1366{
1367 int j,dp,dL;
1368
1369 if (length<0) return 0;
1370 if (hasPurePower(p,strat->lastAxis,&dp,strat))
1371 {
1372 int op= p->GetpFDeg() +p->ecart;
1373 for (j=length; j>=0; j--)
1374 {
1375 if (!hasPurePower(&(set[j]),strat->lastAxis,&dL,strat))
1376 return j+1;
1377 if (dp < dL)
1378 return j+1;
1379 if ((dp == dL)
1380 && (set[j].GetpFDeg()+set[j].ecart >= op))
1381 return j+1;
1382 }
1383 }
1384 j=length;
1385 loop
1386 {
1387 if (j<0) break;
1388 if (!hasPurePower(&(set[j]),strat->lastAxis,&dL,strat)) break;
1389 j--;
1390 }
1391 return strat->posInLOld(set,j,p,strat);
1392}
skStrategy::lastAxis
int lastAxis
Definition: kutil.h:355
skStrategy::posInLOld
int(* posInLOld)(const LSet Ls, const int Ll, LObject *Lo, const kStrategy strat)
Definition: kutil.h:288
hasPurePower
BOOLEAN hasPurePower(const poly p, int last, int *length, kStrategy strat)
Definition: kstd1.cc:1317

◆ posInL10Ring()

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

◆ posInL11()

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

Definition at line 5833 of file kutil.cc.

5835{
5836 if (length<0) return 0;
5837
5838 int o = p->GetpFDeg();
5839 int op = set[length].GetpFDeg();
5840 int cmp_int= -currRing->OrdSgn;
5841
5842 if ((op > o)
5843 || ((op == o) && (pLmCmp(set[length].p,p->p) != cmp_int)))
5844 return length+1;
5845 int i;
5846 int an = 0;
5847 int en= length;
5848 loop
5849 {
5850 if (an >= en-1)
5851 {
5852 op = set[an].GetpFDeg();
5853 if ((op > o)
5854 || ((op == o) && (pLmCmp(set[an].p,p->p) != cmp_int)))
5855 return en;
5856 return an;
5857 }
5858 i=(an+en) / 2;
5859 op = set[i].GetpFDeg();
5860 if ((op > o)
5861 || ((op == o) && (pLmCmp(set[i].p,p->p) != cmp_int)))
5862 an=i;
5863 else
5864 en=i;
5865 }
5866}

◆ posInL110()

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

Definition at line 6093 of file kutil.cc.

6095{
6096 if (length<0) return 0;
6097
6098 int o = p->GetpFDeg();
6099 int op = set[length].GetpFDeg();
6100 int cmp_int= -currRing->OrdSgn;
6101
6102 if ((op > o)
6103 || ((op == o) && (set[length].length >p->length))
6104 || ((op == o) && (set[length].length <= p->length)
6105 && (pLmCmp(set[length].p,p->p) != cmp_int)))
6106 return length+1;
6107 int i;
6108 int an = 0;
6109 int en= length;
6110 loop
6111 {
6112 if (an >= en-1)
6113 {
6114 op = set[an].GetpFDeg();
6115 if ((op > o)
6116 || ((op == o) && (set[an].length >p->length))
6117 || ((op == o) && (set[an].length <=p->length)
6118 && (pLmCmp(set[an].p,p->p) != cmp_int)))
6119 return en;
6120 return an;
6121 }
6122 i=(an+en) / 2;
6123 op = set[i].GetpFDeg();
6124 if ((op > o)
6125 || ((op == o) && (set[i].length > p->length))
6126 || ((op == o) && (set[i].length <= p->length)
6127 && (pLmCmp(set[i].p,p->p) != cmp_int)))
6128 an=i;
6129 else
6130 en=i;
6131 }
6132}

◆ posInL11Ring()

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

Definition at line 5876 of file kutil.cc.

5878{
5879 if (length<0) return 0;
5880
5881 int o = p->GetpFDeg();
5882 int op = set[length].GetpFDeg();
5883
5884 if ((op > o)
5885 || ((op == o) && (pLtCmpOrdSgnDiffM(set[length].p,p->p))))
5886 return length+1;
5887 int i;
5888 int an = 0;
5889 int en= length;
5890 loop
5891 {
5892 if (an >= en-1)
5893 {
5894 op = set[an].GetpFDeg();
5895 if ((op > o)
5896 || ((op == o) && (pLtCmpOrdSgnDiffM(set[an].p,p->p))))
5897 return en;
5898 return an;
5899 }
5900 i=(an+en) / 2;
5901 op = set[i].GetpFDeg();
5902 if ((op > o)
5903 || ((op == o) && (pLtCmpOrdSgnDiffM(set[i].p,p->p))))
5904 an=i;
5905 else
5906 en=i;
5907 }
5908}
pLtCmpOrdSgnDiffM
#define pLtCmpOrdSgnDiffM(p, q)
Definition: polys.h:125

◆ posInL11Ringls()

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

Definition at line 5946 of file kutil.cc.

5948{
5949 if (length < 0) return 0;
5950 int an,en,i;
5951 an = 0;
5952 en = length+1;
5953 loop
5954 {
5955 if (an >= en-1)
5956 {
5957 if(an == en)
5958 return en;
5959 if (set[an].FDeg > p->FDeg)
5960 return en;
5961 if (set[an].FDeg < p->FDeg)
5962 return an;
5963 if (set[an].FDeg == p->FDeg)
5964 {
5965 number lcset,lcp;
5966 lcset = pGetCoeff(set[an].p);
5967 lcp = pGetCoeff(p->p);
5968 if(!nGreaterZero(lcset))
5969 {
5970 set[an].p=p_Neg(set[an].p,currRing);
5971 if (set[an].t_p!=NULL)
5972 pSetCoeff0(set[an].t_p,pGetCoeff(set[an].p));
5973 lcset=pGetCoeff(set[an].p);
5974 }
5975 if(!nGreaterZero(lcp))
5976 {
5977 p->p=p_Neg(p->p,currRing);
5978 if (p->t_p!=NULL)
5979 pSetCoeff0(p->t_p,pGetCoeff(p->p));
5980 lcp=pGetCoeff(p->p);
5981 }
5982 if(nGreater(lcset, lcp))
5983 {
5984 return en;
5985 }
5986 else
5987 {
5988 return an;
5989 }
5990 }
5991 }
5992 i=(an+en) / 2;
5993 if (set[i].FDeg > p->FDeg)
5994 an=i;
5995 if (set[i].FDeg < p->FDeg)
5996 en=i;
5997 if (set[i].FDeg == p->FDeg)
5998 {
5999 number lcset,lcp;
6000 lcset = pGetCoeff(set[i].p);
6001 lcp = pGetCoeff(p->p);
6002 if(!nGreaterZero(lcset))
6003 {
6004 set[i].p=p_Neg(set[i].p,currRing);
6005 if (set[i].t_p!=NULL)
6006 pSetCoeff0(set[i].t_p,pGetCoeff(set[i].p));
6007 lcset=pGetCoeff(set[i].p);
6008 }
6009 if(!nGreaterZero(lcp))
6010 {
6011 p->p=p_Neg(p->p,currRing);
6012 if (p->t_p!=NULL)
6013 pSetCoeff0(p->t_p,pGetCoeff(p->p));
6014 lcp=pGetCoeff(p->p);
6015 }
6016 if(nGreater(lcset, lcp))
6017 {
6018 an = i;
6019 }
6020 else
6021 {
6022 en = i;
6023 }
6024 }
6025 }
6026}
nGreater
#define nGreater(a, b)
Definition: numbers.h:28

◆ posInL13()

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

Definition at line 6182 of file kutil.cc.

6184{
6185 if (length<0) return 0;
6186
6187 int o = p->GetpFDeg();
6188
6189 if (set[length].GetpFDeg() > o)
6190 return length+1;
6191
6192 int i;
6193 int an = 0;
6194 int en= length;
6195 loop
6196 {
6197 if (an >= en-1)
6198 {
6199 if (set[an].GetpFDeg() >= o)
6200 return en;
6201 return an;
6202 }
6203 i=(an+en) / 2;
6204 if (set[i].GetpFDeg() >= o)
6205 an=i;
6206 else
6207 en=i;
6208 }
6209}

◆ posInL15()

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

Definition at line 6217 of file kutil.cc.

6219{
6220 if (length<0) return 0;
6221
6222 int o = p->GetpFDeg() + p->ecart;
6223 int op = set[length].GetpFDeg() + set[length].ecart;
6224 int cmp_int= -currRing->OrdSgn;
6225
6226 if ((op > o)
6227 || ((op == o) && (pLmCmp(set[length].p,p->p) != cmp_int)))
6228 return length+1;
6229 int i;
6230 int an = 0;
6231 int en= length;
6232 loop
6233 {
6234 if (an >= en-1)
6235 {
6236 op = set[an].GetpFDeg() + set[an].ecart;
6237 if ((op > o)
6238 || ((op == o) && (pLmCmp(set[an].p,p->p) != cmp_int)))
6239 return en;
6240 return an;
6241 }
6242 i=(an+en) / 2;
6243 op = set[i].GetpFDeg() + set[i].ecart;
6244 if ((op > o)
6245 || ((op == o) && (pLmCmp(set[i].p,p->p) != cmp_int)))
6246 an=i;
6247 else
6248 en=i;
6249 }
6250}

◆ posInL15Ring()

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

Definition at line 6253 of file kutil.cc.

6255{
6256 if (length<0) return 0;
6257
6258 int o = p->GetpFDeg() + p->ecart;
6259 int op = set[length].GetpFDeg() + set[length].ecart;
6260
6261 if ((op > o)
6262 || ((op == o) && (pLtCmpOrdSgnDiffM(set[length].p,p->p))))
6263 return length+1;
6264 int i;
6265 int an = 0;
6266 int en= length;
6267 loop
6268 {
6269 if (an >= en-1)
6270 {
6271 op = set[an].GetpFDeg() + set[an].ecart;
6272 if ((op > o)
6273 || ((op == o) && (pLtCmpOrdSgnDiffM(set[an].p,p->p))))
6274 return en;
6275 return an;
6276 }
6277 i=(an+en) / 2;
6278 op = set[i].GetpFDeg() + set[i].ecart;
6279 if ((op > o)
6280 || ((op == o) && (pLtCmpOrdSgnDiffM(set[i].p,p->p))))
6281 an=i;
6282 else
6283 en=i;
6284 }
6285}

◆ posInL17()

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

Definition at line 6294 of file kutil.cc.

6296{
6297 if (length<0) return 0;
6298
6299 int o = p->GetpFDeg() + p->ecart;
6300 int cmp_int= -currRing->OrdSgn;
6301
6302 if ((set[length].GetpFDeg() + set[length].ecart > o)
6303 || ((set[length].GetpFDeg() + set[length].ecart == o)
6304 && (set[length].ecart > p->ecart))
6305 || ((set[length].GetpFDeg() + set[length].ecart == o)
6306 && (set[length].ecart == p->ecart)
6307 && (pLmCmp(set[length].p,p->p) != cmp_int)))
6308 return length+1;
6309 int i;
6310 int an = 0;
6311 int en= length;
6312 loop
6313 {
6314 if (an >= en-1)
6315 {
6316 if ((set[an].GetpFDeg() + set[an].ecart > o)
6317 || ((set[an].GetpFDeg() + set[an].ecart == o)
6318 && (set[an].ecart > p->ecart))
6319 || ((set[an].GetpFDeg() + set[an].ecart == o)
6320 && (set[an].ecart == p->ecart)
6321 && (pLmCmp(set[an].p,p->p) != cmp_int)))
6322 return en;
6323 return an;
6324 }
6325 i=(an+en) / 2;
6326 if ((set[i].GetpFDeg() + set[i].ecart > o)
6327 || ((set[i].GetpFDeg() + set[i].ecart == o)
6328 && (set[i].ecart > p->ecart))
6329 || ((set[i].GetpFDeg() +set[i].ecart == o)
6330 && (set[i].ecart == p->ecart)
6331 && (pLmCmp(set[i].p,p->p) != cmp_int)))
6332 an=i;
6333 else
6334 en=i;
6335 }
6336}

◆ posInLF5C()

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

Definition at line 5821 of file kutil.cc.

5823{
5824 return strat->Ll+1;
5825}

◆ posInLF5CRing()

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

Definition at line 5910 of file kutil.cc.

5912{
5913 if (length<0) return 0;
5914 if(start == (length +1)) return (length+1);
5915 int o = p->GetpFDeg();
5916 int op = set[length].GetpFDeg();
5917
5918 if ((op > o)
5919 || ((op == o) && (pLtCmpOrdSgnDiffM(set[length].p,p->p))))
5920 return length+1;
5921 int i;
5922 int an = start;
5923 int en= length;
5924 loop
5925 {
5926 if (an >= en-1)
5927 {
5928 op = set[an].GetpFDeg();
5929 if ((op > o)
5930 || ((op == o) && (pLtCmpOrdSgnDiffM(set[an].p,p->p))))
5931 return en;
5932 return an;
5933 }
5934 i=(an+en) / 2;
5935 op = set[i].GetpFDeg();
5936 if ((op > o)
5937 || ((op == o) && (pLtCmpOrdSgnDiffM(set[i].p,p->p))))
5938 an=i;
5939 else
5940 en=i;
5941 }
5942}

◆ posInLSig()

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

Definition at line 5703 of file kutil.cc.

5705{
5706 if (length<0) return 0;
5707 int cmp_int=currRing->OrdSgn;
5708 if (pLtCmp(set[length].sig,p->sig)==cmp_int)
5709 return length+1;
5710
5711 int i;
5712 int an = 0;
5713 int en= length;
5714 loop
5715 {
5716 if (an >= en-1)
5717 {
5718 if (pLtCmp(set[an].sig,p->sig) == cmp_int) return en;
5719 return an;
5720 }
5721 i=(an+en) / 2;
5722 if (pLtCmp(set[i].sig,p->sig) == cmp_int) an=i;
5723 else en=i;
5724 /*aend. fuer lazy == in !=- machen */
5725 }
5726}

◆ posInLSigRing()

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

Definition at line 5728 of file kutil.cc.

5730{
5731 assume(currRing->OrdSgn == 1 && rField_is_Ring(currRing));
5732 if (length<0) return 0;
5733 if (pLtCmp(set[length].sig,p->sig)== 1)
5734 return length+1;
5735
5736 int an,en,i;
5737 an = 0;
5738 en = length+1;
5739 int cmp;
5740 loop
5741 {
5742 if (an >= en-1)
5743 {
5744 if(an == en)
5745 return en;
5746 cmp = pLtCmp(set[an].sig,p->sig);
5747 if (cmp == 1)
5748 return en;
5749 if (cmp == -1)
5750 return an;
5751 if (cmp == 0)
5752 {
5753 if (set[an].FDeg > p->FDeg)
5754 return en;
5755 if (set[an].FDeg < p->FDeg)
5756 return an;
5757 if (set[an].FDeg == p->FDeg)
5758 {
5759 cmp = pLtCmp(set[an].p,p->p);
5760 if(cmp == 1)
5761 return en;
5762 else
5763 return an;
5764 }
5765 }
5766 }
5767 i=(an+en) / 2;
5768 cmp = pLtCmp(set[i].sig,p->sig);
5769 if (cmp == 1)
5770 an = i;
5771 if (cmp == -1)
5772 en = i;
5773 if (cmp == 0)
5774 {
5775 if (set[i].FDeg > p->FDeg)
5776 an = i;
5777 if (set[i].FDeg < p->FDeg)
5778 en = i;
5779 if (set[i].FDeg == p->FDeg)
5780 {
5781 cmp = pLtCmp(set[i].p,p->p);
5782 if(cmp == 1)
5783 an = i;
5784 else
5785 en = i;
5786 }
5787 }
5788 }
5789}

◆ posInS()

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

Definition at line 4685 of file kutil.cc.

4687{
4688 if(length==-1) return 0;
4689 polyset set=strat->S;
4690 int i;
4691 int an = 0;
4692 int en = length;
4693 int cmp_int = currRing->OrdSgn;
4694 if ((rHasMixedOrdering(currRing))
4695#ifdef HAVE_PLURAL
4696 && (currRing->real_var_start==0)
4697#endif
4698#if 0
4699 || ((strat->ak>0) && ((currRing->order[0]==ringorder_c)||((currRing->order[0]==ringorder_C))))
4700#endif
4701 )
4702 {
4703 int o=p_Deg(p,currRing);
4704 int oo=p_Deg(set[length],currRing);
4705
4706 if ((oo<o)
4707 || ((o==oo) && (pLmCmp(set[length],p)!= cmp_int)))
4708 return length+1;
4709
4710 loop
4711 {
4712 if (an >= en-1)
4713 {
4714 if ((p_Deg(set[an],currRing)>=o) && (pLmCmp(set[an],p) == cmp_int))
4715 {
4716 return an;
4717 }
4718 return en;
4719 }
4720 i=(an+en) / 2;
4721 if ((p_Deg(set[i],currRing)>=o) && (pLmCmp(set[i],p) == cmp_int)) en=i;
4722 else an=i;
4723 }
4724 }
4725 else
4726 {
4727 if (rField_is_Ring(currRing))
4728 {
4729 if (pLmCmp(set[length],p)== -cmp_int)
4730 return length+1;
4731 int cmp;
4732 loop
4733 {
4734 if (an >= en-1)
4735 {
4736 cmp = pLmCmp(set[an],p);
4737 if (cmp == cmp_int) return an;
4738 if (cmp == -cmp_int) return en;
4739 if (n_DivBy(pGetCoeff(p), pGetCoeff(set[an]), currRing->cf)) return en;
4740 return an;
4741 }
4742 i = (an+en) / 2;
4743 cmp = pLmCmp(set[i],p);
4744 if (cmp == cmp_int) en = i;
4745 else if (cmp == -cmp_int) an = i;
4746 else
4747 {
4748 if (n_DivBy(pGetCoeff(p), pGetCoeff(set[i]), currRing->cf)) an = i;
4749 else en = i;
4750 }
4751 }
4752 }
4753 else
4754 if (pLmCmp(set[length],p)== -cmp_int)
4755 return length+1;
4756
4757 loop
4758 {
4759 if (an >= en-1)
4760 {
4761 if (pLmCmp(set[an],p) == cmp_int) return an;
4762 if (pLmCmp(set[an],p) == -cmp_int) return en;
4763 if ((cmp_int!=1)
4764 && ((strat->ecartS[an])>ecart_p))
4765 return an;
4766 return en;
4767 }
4768 i=(an+en) / 2;
4769 if (pLmCmp(set[i],p) == cmp_int) en=i;
4770 else if (pLmCmp(set[i],p) == -cmp_int) an=i;
4771 else
4772 {
4773 if ((cmp_int!=1)
4774 &&((strat->ecartS[i])<ecart_p))
4775 en=i;
4776 else
4777 an=i;
4778 }
4779 }
4780 }
4781}

◆ posInSMonFirst()

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

Definition at line 4786 of file kutil.cc.

4787{
4788 if (length<0) return 0;
4789 polyset set=strat->S;
4790 if(pNext(p) == NULL)
4791 {
4792 int mon = 0;
4793 for(int i = 0;i<=length;i++)
4794 {
4795 if(set[i] != NULL && pNext(set[i]) == NULL)
4796 mon++;
4797 }
4798 int o = p_Deg(p,currRing);
4799 int op = p_Deg(set[mon],currRing);
4800
4801 if ((op < o)
4802 || ((op == o) && (pLtCmp(set[mon],p) == -1)))
4803 return length+1;
4804 int i;
4805 int an = 0;
4806 int en= mon;
4807 loop
4808 {
4809 if (an >= en-1)
4810 {
4811 op = p_Deg(set[an],currRing);
4812 if ((op < o)
4813 || ((op == o) && (pLtCmp(set[an],p) == -1)))
4814 return en;
4815 return an;
4816 }
4817 i=(an+en) / 2;
4818 op = p_Deg(set[i],currRing);
4819 if ((op < o)
4820 || ((op == o) && (pLtCmp(set[i],p) == -1)))
4821 an=i;
4822 else
4823 en=i;
4824 }
4825 }
4826 else /*if(pNext(p) != NULL)*/
4827 {
4828 int o = p_Deg(p,currRing);
4829 int op = p_Deg(set[length],currRing);
4830
4831 if ((op < o)
4832 || ((op == o) && (pLtCmp(set[length],p) == -1)))
4833 return length+1;
4834 int i;
4835 int an = 0;
4836 for(i=0;i<=length;i++)
4837 if(set[i] != NULL && pNext(set[i]) == NULL)
4838 an++;
4839 int en= length;
4840 loop
4841 {
4842 if (an >= en-1)
4843 {
4844 op = p_Deg(set[an],currRing);
4845 if ((op < o)
4846 || ((op == o) && (pLtCmp(set[an],p) == -1)))
4847 return en;
4848 return an;
4849 }
4850 i=(an+en) / 2;
4851 op = p_Deg(set[i],currRing);
4852 if ((op < o)
4853 || ((op == o) && (pLtCmp(set[i],p) == -1)))
4854 an=i;
4855 else
4856 en=i;
4857 }
4858 }
4859}

◆ posInSyz()

int posInSyz ( const kStrategy  strat,
const poly  sig 
)

Definition at line 5792 of file kutil.cc.

5793{
5794 if (strat->syzl==0) return 0;
5795 int cmp_int=currRing->OrdSgn;
5796 if (pLtCmp(strat->syz[strat->syzl-1],sig) != cmp_int)
5797 return strat->syzl;
5798 int i;
5799 int an = 0;
5800 int en= strat->syzl-1;
5801 loop
5802 {
5803 if (an >= en-1)
5804 {
5805 if (pLtCmp(strat->syz[an],sig) != cmp_int) return en;
5806 return an;
5807 }
5808 i=(an+en) / 2;
5809 if (pLtCmp(strat->syz[i],sig) != cmp_int) an=i;
5810 else en=i;
5811 /*aend. fuer lazy == in !=- machen */
5812 }
5813}

◆ posInT0()

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

Definition at line 4907 of file kutil.cc.

4908{
4909 return (length+1);
4910}

◆ posInT1()

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

Definition at line 4918 of file kutil.cc.

4919{
4920 if (length==-1) return 0;
4921
4922 if (pLmCmp(set[length].p,p.p)!= currRing->OrdSgn) return length+1;
4923
4924 int i;
4925 int an = 0;
4926 int en= length;
4927 int cmp_int=currRing->OrdSgn;
4928
4929 loop
4930 {
4931 if (an >= en-1)
4932 {
4933 if (pLmCmp(set[an].p,p.p) == cmp_int) return an;
4934 return en;
4935 }
4936 i=(an+en) / 2;
4937 if (pLmCmp(set[i].p,p.p) == cmp_int) en=i;
4938 else an=i;
4939 }
4940}

◆ posInT11()

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

Definition at line 4975 of file kutil.cc.

4976{
4977 if (length==-1) return 0;
4978
4979 int o = p.GetpFDeg();
4980 int op = set[length].GetpFDeg();
4981 int cmp_int=currRing->OrdSgn;
4982
4983 if ((op < o)
4984 || ((op == o) && (pLmCmp(set[length].p,p.p) != cmp_int)))
4985 return length+1;
4986
4987 int i;
4988 int an = 0;
4989 int en= length;
4990
4991 loop
4992 {
4993 if (an >= en-1)
4994 {
4995 op= set[an].GetpFDeg();
4996 if ((op > o)
4997 || (( op == o) && (pLmCmp(set[an].p,p.p) == cmp_int)))
4998 return an;
4999 return en;
5000 }
5001 i=(an+en) / 2;
5002 op = set[i].GetpFDeg();
5003 if (( op > o)
5004 || (( op == o) && (pLmCmp(set[i].p,p.p) == cmp_int)))
5005 en=i;
5006 else
5007 an=i;
5008 }
5009}

◆ posInT110()

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

Definition at line 5053 of file kutil.cc.

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

◆ posInT13()

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

Definition at line 5143 of file kutil.cc.

5144{
5145 if (length==-1) return 0;
5146
5147 int o = p.GetpFDeg();
5148
5149 if (set[length].GetpFDeg() <= o)
5150 return length+1;
5151
5152 int i;
5153 int an = 0;
5154 int en= length;
5155 loop
5156 {
5157 if (an >= en-1)
5158 {
5159 if (set[an].GetpFDeg() > o)
5160 return an;
5161 return en;
5162 }
5163 i=(an+en) / 2;
5164 if (set[i].GetpFDeg() > o)
5165 en=i;
5166 else
5167 an=i;
5168 }
5169}

◆ posInT15()

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

Definition at line 5210 of file kutil.cc.

5229{
5230 if (length==-1) return 0;
5231
5232 int o = p.GetpFDeg() + p.ecart;
5233 int op = set[length].GetpFDeg()+set[length].ecart;
5234 int cmp_int=currRing->OrdSgn;
5235
5236 if ((op < o)
5237 || ((op == o)
5238 && (pLmCmp(set[length].p,p.p) != cmp_int)))
5239 return length+1;
5240
5241 int i;
5242 int an = 0;
5243 int en= length;
5244 loop
5245 {
5246 if (an >= en-1)
5247 {
5248 op = set[an].GetpFDeg()+set[an].ecart;
5249 if (( op > o)
5250 || (( op == o) && (pLmCmp(set[an].p,p.p) == cmp_int)))
5251 return an;
5252 return en;
5253 }
5254 i=(an+en) / 2;
5255 op = set[i].GetpFDeg()+set[i].ecart;
5256 if (( op > o)
5257 || (( op == o) && (pLmCmp(set[i].p,p.p) == cmp_int)))
5258 en=i;
5259 else
5260 an=i;
5261 }
5262}

◆ posInT17()

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

Definition at line 5306 of file kutil.cc.

5327{
5328 if (length==-1) return 0;
5329
5330 int o = p.GetpFDeg() + p.ecart;
5331 int op = set[length].GetpFDeg()+set[length].ecart;
5332 int cmp_int=currRing->OrdSgn;
5333
5334 if ((op < o)
5335 || (( op == o) && (set[length].ecart > p.ecart))
5336 || (( op == o) && (set[length].ecart==p.ecart)
5337 && (pLmCmp(set[length].p,p.p) != cmp_int)))
5338 return length+1;
5339
5340 int i;
5341 int an = 0;
5342 int en= length;
5343 loop
5344 {
5345 if (an >= en-1)
5346 {
5347 op = set[an].GetpFDeg()+set[an].ecart;
5348 if (( op > o)
5349 || (( op == o) && (set[an].ecart < p.ecart))
5350 || (( op == o) && (set[an].ecart==p.ecart)
5351 && (pLmCmp(set[an].p,p.p) == cmp_int)))
5352 return an;
5353 return en;
5354 }
5355 i=(an+en) / 2;
5356 op = set[i].GetpFDeg()+set[i].ecart;
5357 if ((op > o)
5358 || (( op == o) && (set[i].ecart < p.ecart))
5359 || (( op == o) && (set[i].ecart == p.ecart)
5360 && (pLmCmp(set[i].p,p.p) == cmp_int)))
5361 en=i;
5362 else
5363 an=i;
5364 }
5365}

◆ posInT17_c()

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

Definition at line 5414 of file kutil.cc.

5415{
5416 if (length==-1) return 0;
5417
5418 int cc = (-1+2*currRing->order[0]==ringorder_c);
5419 /* cc==1 for (c,..), cc==-1 for (C,..) */
5420 int o = p.GetpFDeg() + p.ecart;
5421 int c = pGetComp(p.p)*cc;
5422 int cmp_int=currRing->OrdSgn;
5423
5424 if (pGetComp(set[length].p)*cc < c)
5425 return length+1;
5426 if (pGetComp(set[length].p)*cc == c)
5427 {
5428 int op = set[length].GetpFDeg()+set[length].ecart;
5429 if ((op < o)
5430 || ((op == o) && (set[length].ecart > p.ecart))
5431 || ((op == o) && (set[length].ecart==p.ecart)
5432 && (pLmCmp(set[length].p,p.p) != cmp_int)))
5433 return length+1;
5434 }
5435
5436 int i;
5437 int an = 0;
5438 int en= length;
5439 loop
5440 {
5441 if (an >= en-1)
5442 {
5443 if (pGetComp(set[an].p)*cc < c)
5444 return en;
5445 if (pGetComp(set[an].p)*cc == c)
5446 {
5447 int op = set[an].GetpFDeg()+set[an].ecart;
5448 if ((op > o)
5449 || ((op == o) && (set[an].ecart < p.ecart))
5450 || ((op == o) && (set[an].ecart==p.ecart)
5451 && (pLmCmp(set[an].p,p.p) == cmp_int)))
5452 return an;
5453 }
5454 return en;
5455 }
5456 i=(an+en) / 2;
5457 if (pGetComp(set[i].p)*cc > c)
5458 en=i;
5459 else if (pGetComp(set[i].p)*cc == c)
5460 {
5461 int op = set[i].GetpFDeg()+set[i].ecart;
5462 if ((op > o)
5463 || ((op == o) && (set[i].ecart < p.ecart))
5464 || ((op == o) && (set[i].ecart == p.ecart)
5465 && (pLmCmp(set[i].p,p.p) == cmp_int)))
5466 en=i;
5467 else
5468 an=i;
5469 }
5470 else
5471 an=i;
5472 }
5473}

◆ posInT19()

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

Definition at line 5542 of file kutil.cc.

5543{
5544 p.GetpLength();
5545 if (length==-1) return 0;
5546
5547 int o = p.ecart;
5548 int op=p.GetpFDeg();
5549
5550 if (set[length].ecart < o)
5551 return length+1;
5552 if (set[length].ecart == o)
5553 {
5554 int oo=set[length].GetpFDeg();
5555 if ((oo < op) || ((oo==op) && (set[length].length < p.length)))
5556 return length+1;
5557 }
5558
5559 int i;
5560 int an = 0;
5561 int en= length;
5562 loop
5563 {
5564 if (an >= en-1)
5565 {
5566 if (set[an].ecart > o)
5567 return an;
5568 if (set[an].ecart == o)
5569 {
5570 int oo=set[an].GetpFDeg();
5571 if((oo > op)
5572 || ((oo==op) && (set[an].length > p.length)))
5573 return an;
5574 }
5575 return en;
5576 }
5577 i=(an+en) / 2;
5578 if (set[i].ecart > o)
5579 en=i;
5580 else if (set[i].ecart == o)
5581 {
5582 int oo=set[i].GetpFDeg();
5583 if ((oo > op)
5584 || ((oo == op) && (set[i].length > p.length)))
5585 en=i;
5586 else
5587 an=i;
5588 }
5589 else
5590 an=i;
5591 }
5592}

◆ posInT2()

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

Definition at line 4947 of file kutil.cc.

4948{
4949 if (length==-1) return 0;
4950 p.GetpLength();
4951 if (set[length].length<p.length) return length+1;
4952
4953 int i;
4954 int an = 0;
4955 int en= length;
4956
4957 loop
4958 {
4959 if (an >= en-1)
4960 {
4961 if (set[an].length>p.length) return an;
4962 return en;
4963 }
4964 i=(an+en) / 2;
4965 if (set[i].length>p.length) en=i;
4966 else an=i;
4967 }
4968}

◆ posInT_EcartFDegpLength()

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

Definition at line 11435 of file kutil.cc.

11436{
11437
11438 if (length==-1) return 0;
11439
11440 int o = p.ecart;
11441 int op=p.GetpFDeg();
11442 int ol = p.GetpLength();
11443
11444 if (set[length].ecart < o)
11445 return length+1;
11446 if (set[length].ecart == o)
11447 {
11448 int oo=set[length].GetpFDeg();
11449 if ((oo < op) || ((oo==op) && (set[length].length < ol)))
11450 return length+1;
11451 }
11452
11453 int i;
11454 int an = 0;
11455 int en= length;
11456 loop
11457 {
11458 if (an >= en-1)
11459 {
11460 if (set[an].ecart > o)
11461 return an;
11462 if (set[an].ecart == o)
11463 {
11464 int oo=set[an].GetpFDeg();
11465 if((oo > op)
11466 || ((oo==op) && (set[an].pLength > ol)))
11467 return an;
11468 }
11469 return en;
11470 }
11471 i=(an+en) / 2;
11472 if (set[i].ecart > o)
11473 en=i;
11474 else if (set[i].ecart == o)
11475 {
11476 int oo=set[i].GetpFDeg();
11477 if ((oo > op)
11478 || ((oo == op) && (set[i].pLength > ol)))
11479 en=i;
11480 else
11481 an=i;
11482 }
11483 else
11484 an=i;
11485 }
11486}

◆ posInT_EcartpLength()

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

Definition at line 5172 of file kutil.cc.

5173{
5174 if (length==-1) return 0;
5175 int ol = p.GetpLength();
5176 int op=p.ecart;
5177 int oo=set[length].ecart;
5178
5179 if ((oo < op) || ((oo==op) && (set[length].length <= ol)))
5180 return length+1;
5181
5182 int i;
5183 int an = 0;
5184 int en= length;
5185 loop
5186 {
5187 if (an >= en-1)
5188 {
5189 int oo=set[an].ecart;
5190 if((oo > op)
5191 || ((oo==op) && (set[an].pLength > ol)))
5192 return an;
5193 return en;
5194 }
5195 i=(an+en) / 2;
5196 int oo=set[i].ecart;
5197 if ((oo > op)
5198 || ((oo == op) && (set[i].pLength > ol)))
5199 en=i;
5200 else
5201 an=i;
5202 }
5203}

◆ posInT_FDegpLength()

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

Definition at line 11489 of file kutil.cc.

11490{
11491
11492 if (length==-1) return 0;
11493
11494 int op=p.GetpFDeg();
11495 int ol = p.GetpLength();
11496
11497 int oo=set[length].GetpFDeg();
11498 if ((oo < op) || ((oo==op) && (set[length].length < ol)))
11499 return length+1;
11500
11501 int i;
11502 int an = 0;
11503 int en= length;
11504 loop
11505 {
11506 if (an >= en-1)
11507 {
11508 int oo=set[an].GetpFDeg();
11509 if((oo > op)
11510 || ((oo==op) && (set[an].pLength > ol)))
11511 return an;
11512 return en;
11513 }
11514 i=(an+en) / 2;
11515 int oo=set[i].GetpFDeg();
11516 if ((oo > op)
11517 || ((oo == op) && (set[i].pLength > ol)))
11518 en=i;
11519 else
11520 an=i;
11521 }
11522}

◆ posInT_pLength()

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

Definition at line 11526 of file kutil.cc.

11527{
11528 int ol = p.GetpLength();
11529 if (length==-1)
11530 return 0;
11531 if (set[length].length<p.length)
11532 return length+1;
11533
11534 int i;
11535 int an = 0;
11536 int en= length;
11537
11538 loop
11539 {
11540 if (an >= en-1)
11541 {
11542 if (set[an].pLength>ol) return an;
11543 return en;
11544 }
11545 i=(an+en) / 2;
11546 if (set[i].pLength>ol) en=i;
11547 else an=i;
11548 }
11549}

◆ posInTSig()

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

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

10764{
10765 if(!nCoeff_is_Z(currRing->cf))
10766 return;
10767 poly pH = h->GetP();
10768 poly p,pp;
10769 p = pH;
10770 bool deleted = FALSE, ok = FALSE;
10771 for(int i = 0; i<=strat->sl; i++)
10772 {
10773 p = pH;
10774 if(pNext(strat->S[i]) == NULL)
10775 {
10776 //pWrite(p);
10777 //pWrite(strat->S[i]);
10778 while(ok == FALSE && p != NULL)
10779 {
10780 if(pLmDivisibleBy(strat->S[i], p)
10781#ifdef HAVE_SHIFTBBA
10782 || (rIsLPRing(currRing) && pLPLmDivisibleBy(strat->S[i], p))
10783#endif
10784 )
10785 {
10786 number dummy = n_IntMod(p->coef, strat->S[i]->coef, currRing->cf);
10787 p_SetCoeff(p,dummy,currRing);
10788 }
10789 if(nIsZero(p->coef))
10790 {
10791 pLmDelete(&p);
10792 h->p = p;
10793 deleted = TRUE;
10794 }
10795 else
10796 {
10797 ok = TRUE;
10798 }
10799 }
10800 if (p!=NULL)
10801 {
10802 pp = pNext(p);
10803 while(pp != NULL)
10804 {
10805 if(pLmDivisibleBy(strat->S[i], pp)
10806#ifdef HAVE_SHIFTBBA
10807 || (rIsLPRing(currRing) && pLPLmDivisibleBy(strat->S[i], pp))
10808#endif
10809 )
10810 {
10811 number dummy = n_IntMod(pp->coef, strat->S[i]->coef, currRing->cf);
10812 p_SetCoeff(pp,dummy,currRing);
10813 if(nIsZero(pp->coef))
10814 {
10815 pLmDelete(&pNext(p));
10816 pp = pNext(p);
10817 deleted = TRUE;
10818 }
10819 else
10820 {
10821 p = pp;
10822 pp = pNext(p);
10823 }
10824 }
10825 else
10826 {
10827 p = pp;
10828 pp = pNext(p);
10829 }
10830 }
10831 }
10832 }
10833 }
10834 h->SetLmCurrRing();
10835 if((deleted)&&(h->p!=NULL))
10836 strat->initEcart(h);
10837}

◆ postReduceByMonSig()

void postReduceByMonSig ( LObject *  h,
kStrategy  strat 
)

Definition at line 10839 of file kutil.cc.

10840{
10841 if(!nCoeff_is_Z(currRing->cf))
10842 return;
10843 poly hSig = h->sig;
10844 poly pH = h->GetP();
10845 poly p,pp;
10846 p = pH;
10847 bool deleted = FALSE, ok = FALSE;
10848 for(int i = 0; i<=strat->sl; i++)
10849 {
10850 p = pH;
10851 if(pNext(strat->S[i]) == NULL)
10852 {
10853 while(ok == FALSE && p!=NULL)
10854 {
10855 if(pLmDivisibleBy(strat->S[i], p))
10856 {
10857 poly sigMult = pDivideM(pHead(p),pHead(strat->S[i]));
10858 sigMult = ppMult_mm(sigMult,pCopy(strat->sig[i]));
10859 if(sigMult!= NULL && pLtCmp(hSig,sigMult) == 1)
10860 {
10861 number dummy = n_IntMod(p->coef, strat->S[i]->coef, currRing->cf);
10862 p_SetCoeff(p,dummy,currRing);
10863 }
10864 pDelete(&sigMult);
10865 }
10866 if(nIsZero(p->coef))
10867 {
10868 pLmDelete(&p);
10869 h->p = p;
10870 deleted = TRUE;
10871 }
10872 else
10873 {
10874 ok = TRUE;
10875 }
10876 }
10877 if(p == NULL)
10878 return;
10879 pp = pNext(p);
10880 while(pp != NULL)
10881 {
10882 if(pLmDivisibleBy(strat->S[i], pp))
10883 {
10884 poly sigMult = pDivideM(pHead(p),pHead(strat->S[i]));
10885 sigMult = ppMult_mm(sigMult,pCopy(strat->sig[i]));
10886 if(sigMult!= NULL && pLtCmp(hSig,sigMult) == 1)
10887 {
10888 number dummy = n_IntMod(pp->coef, strat->S[i]->coef, currRing->cf);
10889 p_SetCoeff(pp,dummy,currRing);
10890 if(nIsZero(pp->coef))
10891 {
10892 pLmDelete(&pNext(p));
10893 pp = pNext(p);
10894 deleted = TRUE;
10895 }
10896 else
10897 {
10898 p = pp;
10899 pp = pNext(p);
10900 }
10901 }
10902 else
10903 {
10904 p = pp;
10905 pp = pNext(p);
10906 }
10907 pDelete(&sigMult);
10908 }
10909 else
10910 {
10911 p = pp;
10912 pp = pNext(p);
10913 }
10914 }
10915 }
10916 }
10917 h->SetLmCurrRing();
10918 if(deleted)
10919 strat->initEcart(h);
10920
10921}
ppMult_mm
#define ppMult_mm(p, m)
Definition: polys.h:201
pDivideM
#define pDivideM(a, b)
Definition: polys.h:294

◆ preIntegerCheck()

poly preIntegerCheck ( ideal  F,
ideal  Q 
)

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

Definition at line 10596 of file kutil.cc.

10597{
10598 if(!nCoeff_is_Z(currRing->cf))
10599 return NULL;
10600 ideal F = idCopy(Forig);
10601 idSkipZeroes(F);
10602 poly pmon;
10603 ring origR = currRing;
10604 ideal monred = idInit(1,1);
10605 for(int i=0; i<idElem(F); i++)
10606 {
10607 if(pNext(F->m[i]) == NULL)
10608 idInsertPoly(monred, pCopy(F->m[i]));
10609 }
10610 int posconst = idPosConstant(F);
10611 if((posconst != -1) && (!nIsZero(F->m[posconst]->coef)))
10612 {
10613 idDelete(&F);
10614 idDelete(&monred);
10615 return NULL;
10616 }
10617 int idelemQ = 0;
10618 if(Q!=NULL)
10619 {
10620 idelemQ = IDELEMS(Q);
10621 for(int i=0; i<idelemQ; i++)
10622 {
10623 if(pNext(Q->m[i]) == NULL)
10624 idInsertPoly(monred, pCopy(Q->m[i]));
10625 }
10626 idSkipZeroes(monred);
10627 posconst = idPosConstant(monred);
10628 //the constant, if found, will be from Q
10629 if((posconst != -1) && (!nIsZero(monred->m[posconst]->coef)))
10630 {
10631 pmon = pCopy(monred->m[posconst]);
10632 idDelete(&F);
10633 idDelete(&monred);
10634 return pmon;
10635 }
10636 }
10637 ring QQ_ring = rCopy0(currRing,FALSE);
10638 nKillChar(QQ_ring->cf);
10639 QQ_ring->cf = nInitChar(n_Q, NULL);
10640 rComplete(QQ_ring,1);
10641 QQ_ring = rAssure_c_dp(QQ_ring);
10642 rChangeCurrRing(QQ_ring);
10643 nMapFunc nMap = n_SetMap(origR->cf, QQ_ring->cf);
10644 ideal II = idInit(IDELEMS(F)+idelemQ+2,id_RankFreeModule(F, origR));
10645 for(int i = 0, j = 0; i<IDELEMS(F); i++)
10646 II->m[j++] = prMapR(F->m[i], nMap, origR, QQ_ring);
10647 for(int i = 0, j = IDELEMS(F); i<idelemQ; i++)
10648 II->m[j++] = prMapR(Q->m[i], nMap, origR, QQ_ring);
10649 ideal one = kStd(II, NULL, isNotHomog, NULL);
10650 idSkipZeroes(one);
10651 if(idIsConstant(one))
10652 {
10653 //one should be <1>
10654 for(int i = IDELEMS(II)-1; i>=0; i--)
10655 if(II->m[i] != NULL)
10656 II->m[i+1] = II->m[i];
10657 II->m[0] = pOne();
10658 ideal syz = idSyzygies(II, isNotHomog, NULL);
10659 poly integer = NULL;
10660 for(int i = IDELEMS(syz)-1;i>=0; i--)
10661 {
10662 if(pGetComp(syz->m[i]) == 1)
10663 {
10664 pSetComp(syz->m[i],0);
10665 if(pIsConstant(pHead(syz->m[i])))
10666 {
10667 integer = pHead(syz->m[i]);
10668 break;
10669 }
10670 }
10671 }
10672 rChangeCurrRing(origR);
10673 nMapFunc nMap2 = n_SetMap(QQ_ring->cf, origR->cf);
10674 pmon = prMapR(integer, nMap2, QQ_ring, origR);
10675 idDelete(&monred);
10676 idDelete(&F);
10677 id_Delete(&II,QQ_ring);
10678 id_Delete(&one,QQ_ring);
10679 id_Delete(&syz,QQ_ring);
10680 p_Delete(&integer,QQ_ring);
10681 rDelete(QQ_ring);
10682 return pmon;
10683 }
10684 else
10685 {
10686 if(idIs0(monred))
10687 {
10688 poly mindegmon = NULL;
10689 for(int i = 0; i<IDELEMS(one); i++)
10690 {
10691 if(pNext(one->m[i]) == NULL)
10692 {
10693 if(mindegmon == NULL)
10694 mindegmon = pCopy(one->m[i]);
10695 else
10696 {
10697 if(p_Deg(one->m[i], QQ_ring) < p_Deg(mindegmon, QQ_ring))
10698 mindegmon = pCopy(one->m[i]);
10699 }
10700 }
10701 }
10702 if(mindegmon != NULL)
10703 {
10704 for(int i = IDELEMS(II)-1; i>=0; i--)
10705 if(II->m[i] != NULL)
10706 II->m[i+1] = II->m[i];
10707 II->m[0] = pCopy(mindegmon);
10708 ideal syz = idSyzygies(II, isNotHomog, NULL);
10709 bool found = FALSE;
10710 for(int i = IDELEMS(syz)-1;i>=0; i--)
10711 {
10712 if(pGetComp(syz->m[i]) == 1)
10713 {
10714 pSetComp(syz->m[i],0);
10715 if(pIsConstant(pHead(syz->m[i])))
10716 {
10717 pSetCoeff(mindegmon, nCopy(syz->m[i]->coef));
10718 found = TRUE;
10719 break;
10720 }
10721 }
10722 }
10723 id_Delete(&syz,QQ_ring);
10724 if (found == FALSE)
10725 {
10726 rChangeCurrRing(origR);
10727 idDelete(&monred);
10728 idDelete(&F);
10729 id_Delete(&II,QQ_ring);
10730 id_Delete(&one,QQ_ring);
10731 rDelete(QQ_ring);
10732 return NULL;
10733 }
10734 rChangeCurrRing(origR);
10735 nMapFunc nMap2 = n_SetMap(QQ_ring->cf, origR->cf);
10736 pmon = prMapR(mindegmon, nMap2, QQ_ring, origR);
10737 idDelete(&monred);
10738 idDelete(&F);
10739 id_Delete(&II,QQ_ring);
10740 id_Delete(&one,QQ_ring);
10741 id_Delete(&syz,QQ_ring);
10742 rDelete(QQ_ring);
10743 return pmon;
10744 }
10745 }
10746 }
10747 rChangeCurrRing(origR);
10748 idDelete(&monred);
10749 idDelete(&F);
10750 id_Delete(&II,QQ_ring);
10751 id_Delete(&one,QQ_ring);
10752 rDelete(QQ_ring);
10753 return NULL;
10754}
n_Q
@ n_Q
rational (GMP) numbers
Definition: coeffs.h:30
n_SetMap
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:697
nInitChar
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition: numbers.cc:413
nMapFunc
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:73
nKillChar
void nKillChar(coeffs r)
undo all initialisations
Definition: numbers.cc:568
idSyzygies
ideal idSyzygies(ideal h1, tHomog h, intvec **w, BOOLEAN setSyzComp, BOOLEAN setRegularity, int *deg, GbVariant alg)
Definition: ideals.cc:830
idIsConstant
#define idIsConstant(I)
Definition: ideals.h:40
idInsertPoly
BOOLEAN idInsertPoly(ideal h1, poly h2)
insert h2 into h1 (if h2 is not the zero polynomial) return TRUE iff h2 was indeed inserted
Definition: simpleideals.cc:789
idCopy
ideal idCopy(ideal A)
Definition: ideals.h:60
idPosConstant
#define idPosConstant(I)
index of generator with leading term in ground ring (if any); otherwise -1
Definition: ideals.h:37
kStd
ideal kStd(ideal F, ideal Q, tHomog h, intvec **w, intvec *hilb, int syzComp, int newIdeal, intvec *vw, s_poly_proc_t sp)
Definition: kstd1.cc:2447
rChangeCurrRing
void rChangeCurrRing(ring r)
Definition: polys.cc:15
prMapR
poly prMapR(poly src, nMapFunc nMap, ring src_r, ring dest_r)
Definition: prCopy.cc:45
rComplete
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:3450
rAssure_c_dp
ring rAssure_c_dp(const ring r)
Definition: ring.cc:4990
rCopy0
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
Definition: ring.cc:1421
rDelete
void rDelete(ring r)
unconditionally deletes fields in r
Definition: ring.cc:450
id_Delete
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
Definition: simpleideals.cc:123
id_RankFreeModule
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
Definition: simpleideals.cc:931
idElem
static int idElem(const ideal F)
number of non-zero polys in F
Definition: simpleideals.h:67
isNotHomog
@ isNotHomog
Definition: structs.h:36

◆ redFirstShift()

int redFirstShift ( LObject *  h,
kStrategy  strat 
)

Definition at line 4988 of file kstd2.cc.

4989{
4990 if (h->IsNull()) return 0;
4991
4992 int at, reddeg,d;
4993 int pass = 0;
4994 int j = 0;
4995
4996 if (! strat->homog)
4997 {
4998 d = h->GetpFDeg() + h->ecart;
4999 reddeg = strat->LazyDegree+d;
5000 }
5001 h->SetShortExpVector();
5002 loop
5003 {
5004 j = kFindDivisibleByInT(strat, h);
5005 if (j < 0)
5006 {
5007 h->SetDegStuffReturnLDeg(strat->LDegLast);
5008 return 1;
5009 }
5010
5011 if (!TEST_OPT_INTSTRATEGY)
5012 strat->T[j].pNorm();
5013#ifdef KDEBUG
5014 if (TEST_OPT_DEBUG)
5015 {
5016 PrintS("reduce ");
5017 h->wrp();
5018 PrintS(" with ");
5019 strat->T[j].wrp();
5020 }
5021#endif
5022 ksReducePoly(h, &(strat->T[j]), strat->kNoetherTail(), NULL, NULL, strat);
5023
5024#ifdef KDEBUG
5025 if (TEST_OPT_DEBUG)
5026 {
5027 PrintS("\nto ");
5028 wrp(h->p);
5029 PrintLn();
5030 }
5031#endif
5032 if (h->IsNull())
5033 {
5034 kDeleteLcm(h);
5035 h->Clear();
5036 return 0;
5037 }
5038 h->SetShortExpVector();
5039
5040#if 0
5041 if ((strat->syzComp!=0) && !strat->honey)
5042 {
5043 if ((strat->syzComp>0) &&
5044 (h->Comp() > strat->syzComp))
5045 {
5046 assume(h->MinComp() > strat->syzComp);
5047#ifdef KDEBUG
5048 if (TEST_OPT_DEBUG) PrintS(" > syzComp\n");
5049#endif
5050 if (strat->homog)
5051 h->SetDegStuffReturnLDeg(strat->LDegLast);
5052 return -2;
5053 }
5054 }
5055#endif
5056 if (!strat->homog)
5057 {
5058 if (!TEST_OPT_OLDSTD && strat->honey)
5059 {
5060 h->SetpFDeg();
5061 if (strat->T[j].ecart <= h->ecart)
5062 h->ecart = d - h->GetpFDeg();
5063 else
5064 h->ecart = d - h->GetpFDeg() + strat->T[j].ecart - h->ecart;
5065
5066 d = h->GetpFDeg() + h->ecart;
5067 }
5068 else
5069 d = h->SetDegStuffReturnLDeg(strat->LDegLast);
5070 /*- try to reduce the s-polynomial -*/
5071 pass++;
5072 /*
5073 *test whether the polynomial should go to the lazyset L
5074 *-if the degree jumps
5075 *-if the number of pre-defined reductions jumps
5076 */
5077 if (!TEST_OPT_REDTHROUGH && (strat->Ll >= 0)
5078 && ((d >= reddeg) || (pass > strat->LazyPass)))
5079 {
5080 h->SetLmCurrRing();
5081 if (strat->posInLDependsOnLength)
5082 h->SetLength(strat->length_pLength);
5083 at = strat->posInL(strat->L,strat->Ll,h,strat);
5084 if (at <= strat->Ll)
5085 {
5086 //int dummy=strat->sl;
5087 /* if (kFindDivisibleByInS(strat,&dummy, h) < 0) */
5088 //if (kFindDivisibleByInT(strat->T,strat->sevT, dummy, h) < 0)
5089 if (kFindDivisibleByInT(strat, h) < 0)
5090 return 1;
5091 enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
5092#ifdef KDEBUG
5093 if (TEST_OPT_DEBUG) Print(" degree jumped; ->L%d\n",at);
5094#endif
5095 h->Clear();
5096 return -1;
5097 }
5098 }
5099 if ((TEST_OPT_PROT) && (strat->Ll < 0) && (d >= reddeg))
5100 {
5101 reddeg = d+1;
5102 Print(".%d",d);mflush();
5103 }
5104 }
5105 }
5106}
skStrategy::length_pLength
char length_pLength
Definition: kutil.h:387
kFindDivisibleByInT
int kFindDivisibleByInT(const kStrategy strat, const LObject *L, const int start)
return -1 if no divisor is found number of first divisor in T, otherwise
Definition: kstd2.cc:321
TEST_OPT_REDTHROUGH
#define TEST_OPT_REDTHROUGH
Definition: options.h:123

◆ redHomog()

int redHomog ( LObject *  h,
kStrategy  strat 
)

Definition at line 1121 of file kstd2.cc.

1122{
1123 if (strat->tl<0) return 1;
1124 //if (h->GetLmTailRing()==NULL) return 0; // HS: SHOULD NOT BE NEEDED!
1125 assume(h->FDeg == h->pFDeg());
1126
1127 poly h_p;
1128 int i,j,at,pass,cnt,ii;
1129 // long reddeg,d;
1130 int li;
1131 BOOLEAN test_opt_length=TEST_OPT_LENGTH;
1132
1133 pass = j = 0;
1134 cnt = RED_CANONICALIZE;
1135 // d = reddeg = h->GetpFDeg();
1136 h->SetShortExpVector();
1137 h_p = h->GetLmTailRing();
1138 h->PrepareRed(strat->use_buckets);
1139 loop
1140 {
1141 j = kFindDivisibleByInT(strat, h);
1142 if (j < 0) return 1;
1143
1144 li = strat->T[j].pLength;
1145 ii = j;
1146 /*
1147 * the polynomial to reduce with (up to the moment) is;
1148 * pi with length li
1149 */
1150 i = j;
1151#if 1
1152 if (test_opt_length)
1153 {
1154 if (li<=0) li=strat->T[j].GetpLength();
1155 if (li>2)
1156 {
1157 unsigned long not_sev = ~ h->sev;
1158 loop
1159 {
1160 /*- search the shortest possible with respect to length -*/
1161 i++;
1162 if (i > strat->tl)
1163 break;
1164 if ((strat->T[i].pLength < li)
1165 &&
1166 p_LmShortDivisibleBy(strat->T[i].GetLmTailRing(), strat->sevT[i],
1167 h_p, not_sev, strat->tailRing))
1168 {
1169 /*
1170 * the polynomial to reduce with is now;
1171 */
1172 li = strat->T[i].pLength;
1173 if (li<=0) li=strat->T[i].GetpLength();
1174 ii = i;
1175 if (li<3) break;
1176 }
1177 }
1178 }
1179 }
1180#endif
1181
1182 /*
1183 * end of search: have to reduce with pi
1184 */
1185#ifdef KDEBUG
1186 if (TEST_OPT_DEBUG)
1187 {
1188 PrintS("red:");
1189 h->wrp();
1190 PrintS(" with ");
1191 strat->T[ii].wrp();
1192 }
1193#endif
1194 assume(strat->fromT == FALSE);
1195
1196 ksReducePoly(h, &(strat->T[ii]), NULL, NULL, NULL, strat);
1197#if SBA_PRINT_REDUCTION_STEPS
1198 sba_interreduction_steps++;
1199#endif
1200#if SBA_PRINT_OPERATIONS
1201 sba_interreduction_operations += pLength(strat->T[ii].p);
1202#endif
1203
1204#ifdef KDEBUG
1205 if (TEST_OPT_DEBUG)
1206 {
1207 PrintS("\nto ");
1208 h->wrp();
1209 PrintLn();
1210 }
1211#endif
1212
1213 h_p = h->GetLmTailRing();
1214 if (h_p == NULL)
1215 {
1216 kDeleteLcm(h);
1217 return 0;
1218 }
1219 #if 0 // red is redLiftstd if OPT_IDLIFT
1220 if (UNLIKELY(TEST_OPT_IDLIFT))
1221 {
1222 if (h->p!=NULL)
1223 {
1224 if(p_GetComp(h->p,currRing)>strat->syzComp)
1225 {
1226 h->Delete();
1227 return 0;
1228 }
1229 }
1230 else if (h->t_p!=NULL)
1231 {
1232 if(p_GetComp(h->t_p,strat->tailRing)>strat->syzComp)
1233 {
1234 h->Delete();
1235 return 0;
1236 }
1237 }
1238 }
1239 #endif
1240 #if 0
1241 else if ((strat->syzComp > 0)&&(!TEST_OPT_REDTAIL_SYZ))
1242 {
1243 if (h->p!=NULL)
1244 {
1245 if(p_GetComp(h->p,currRing)>strat->syzComp)
1246 {
1247 return 1;
1248 }
1249 }
1250 else if (h->t_p!=NULL)
1251 {
1252 if(p_GetComp(h->t_p,strat->tailRing)>strat->syzComp)
1253 {
1254 return 1;
1255 }
1256 }
1257 }
1258 #endif
1259 h->SetShortExpVector();
1260 /*
1261 * try to reduce the s-polynomial h
1262 *test first whether h should go to the lazyset L
1263 *-if the degree jumps
1264 *-if the number of pre-defined reductions jumps
1265 */
1266 cnt--;
1267 pass++;
1268 if (!TEST_OPT_REDTHROUGH && (strat->Ll >= 0) && (pass > strat->LazyPass))
1269 {
1270 h->SetLmCurrRing();
1271 at = strat->posInL(strat->L,strat->Ll,h,strat);
1272 if (at <= strat->Ll)
1273 {
1274#ifdef HAVE_SHIFTBBA
1275 if (rIsLPRing(currRing))
1276 {
1277 if (kFindDivisibleByInT(strat, h) < 0)
1278 return 1;
1279 }
1280 else
1281#endif
1282 {
1283 int dummy=strat->sl;
1284 if (kFindDivisibleByInS(strat, &dummy, h) < 0)
1285 return 1;
1286 }
1287 enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
1288#ifdef KDEBUG
1289 if (TEST_OPT_DEBUG)
1290 Print(" lazy: -> L%d\n",at);
1291#endif
1292 h->Clear();
1293 return -1;
1294 }
1295 }
1296 else if (UNLIKELY(cnt==0))
1297 {
1298 h->CanonicalizeP();
1299 cnt=RED_CANONICALIZE;
1300 //if (TEST_OPT_PROT) { PrintS("!");mflush(); }
1301 }
1302 }
1303}
UNLIKELY
#define UNLIKELY(X)
Definition: auxiliary.h:404
kFindDivisibleByInS
int kFindDivisibleByInS(const kStrategy strat, int *max_ind, LObject *L)
return -1 if no divisor is found number of first divisor in S, otherwise
Definition: kstd2.cc:421
RED_CANONICALIZE
#define RED_CANONICALIZE
Definition: kutil.h:36
TEST_OPT_LENGTH
#define TEST_OPT_LENGTH
Definition: options.h:132
TEST_OPT_REDTAIL_SYZ
#define TEST_OPT_REDTAIL_SYZ
Definition: options.h:118

◆ redHoney()

int redHoney ( LObject *  h,
kStrategy  strat 
)

Definition at line 2088 of file kstd2.cc.

2089{
2090 if (strat->tl<0) return 1;
2091 //if (h->GetLmTailRing()==NULL) return 0; // HS: SHOULD NOT BE NEEDED!
2092 assume(h->FDeg == h->pFDeg());
2093 poly h_p;
2094 int i,j,at,pass,ei, ii, h_d;
2095 long reddeg,d;
2096 int li;
2097 BOOLEAN test_opt_length=TEST_OPT_LENGTH;
2098
2099 pass = j = 0;
2100 d = reddeg = h->GetpFDeg() + h->ecart;
2101 h->SetShortExpVector();
2102 h_p = h->GetLmTailRing();
2103
2104 h->PrepareRed(strat->use_buckets);
2105 loop
2106 {
2107 j=kFindDivisibleByInT(strat, h);
2108 if (j < 0) return 1;
2109
2110 ei = strat->T[j].ecart;
2111 li = strat->T[j].pLength;
2112 ii = j;
2113 /*
2114 * the polynomial to reduce with (up to the moment) is;
2115 * pi with ecart ei (T[ii])
2116 */
2117 i = j;
2118 if (test_opt_length)
2119 {
2120 if (li<=0) li=strat->T[j].GetpLength();
2121 if (li>2)
2122 {
2123 unsigned long not_sev = ~ h->sev;
2124 loop
2125 {
2126 /*- takes the first possible with respect to ecart -*/
2127 i++;
2128 if (i > strat->tl) break;
2129 if (ei <= h->ecart) break;
2130 if(p_LmShortDivisibleBy(strat->T[i].GetLmTailRing(), strat->sevT[i],
2131 h_p, not_sev, strat->tailRing))
2132 {
2133 strat->T[i].GetpLength();
2134 if (((strat->T[i].ecart < ei) && (ei> h->ecart))
2135 || ((strat->T[i].ecart <= h->ecart) && (strat->T[i].pLength < li)))
2136 {
2137 /*
2138 * the polynomial to reduce with is now;
2139 */
2140 ei = strat->T[i].ecart;
2141 li = strat->T[i].pLength;
2142 ii = i;
2143 if (li==1) break;
2144 if (ei<=h->ecart) break;
2145 }
2146 }
2147 }
2148 }
2149 }
2150
2151 /*
2152 * end of search: have to reduce with pi
2153 */
2154 if (UNLIKELY(!TEST_OPT_REDTHROUGH && (pass!=0) && (ei > h->ecart)))
2155 {
2156 h->GetTP(); // clears bucket
2157 h->SetLmCurrRing();
2158 /*
2159 * It is not possible to reduce h with smaller ecart;
2160 * if possible h goes to the lazy-set L,i.e
2161 * if its position in L would be not the last one
2162 */
2163 if (strat->Ll >= 0) /* L is not empty */
2164 {
2165 at = strat->posInL(strat->L,strat->Ll,h,strat);
2166 if(at <= strat->Ll)
2167 /*- h will not become the next element to reduce -*/
2168 {
2169 enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
2170#ifdef KDEBUG
2171 if (TEST_OPT_DEBUG) Print(" ecart too big: -> L%d\n",at);
2172#endif
2173 h->Clear();
2174 return -1;
2175 }
2176 }
2177 }
2178#ifdef KDEBUG
2179 if (TEST_OPT_DEBUG)
2180 {
2181 PrintS("red:");
2182 h->wrp();
2183 Print("\nwith T[%d]:",ii);
2184 strat->T[ii].wrp();
2185 }
2186#endif
2187 assume(strat->fromT == FALSE);
2188
2189 ksReducePoly(h,&(strat->T[ii]),strat->kNoetherTail(),NULL,NULL, strat);
2190#if SBA_PRINT_REDUCTION_STEPS
2191 sba_interreduction_steps++;
2192#endif
2193#if SBA_PRINT_OPERATIONS
2194 sba_interreduction_operations += strat->T[ii].pLength;
2195#endif
2196#ifdef KDEBUG
2197 if (TEST_OPT_DEBUG)
2198 {
2199 PrintS("\nto:");
2200 h->wrp();
2201 PrintLn();
2202 }
2203#endif
2204 if(h->IsNull())
2205 {
2206 kDeleteLcm(h);
2207 h->Clear();
2208 return 0;
2209 }
2210 #if 0 // red is redLiftstd if OPT_IDLIFT
2211 if (UNLIKELY(TEST_OPT_IDLIFT))
2212 {
2213 if (h->p!=NULL)
2214 {
2215 if(p_GetComp(h->p,currRing)>strat->syzComp)
2216 {
2217 h->Delete();
2218 return 0;
2219 }
2220 }
2221 else if (h->t_p!=NULL)
2222 {
2223 if(p_GetComp(h->t_p,strat->tailRing)>strat->syzComp)
2224 {
2225 h->Delete();
2226 return 0;
2227 }
2228 }
2229 }
2230 else
2231 #endif
2232 if (UNLIKELY((strat->syzComp > 0)&&(!TEST_OPT_REDTAIL_SYZ)))
2233 {
2234 if (h->p!=NULL)
2235 {
2236 if(p_GetComp(h->p,currRing)>strat->syzComp)
2237 {
2238 return 1;
2239 }
2240 }
2241 else if (h->t_p!=NULL)
2242 {
2243 if(p_GetComp(h->t_p,strat->tailRing)>strat->syzComp)
2244 {
2245 return 1;
2246 }
2247 }
2248 }
2249 h->SetShortExpVector();
2250 h_d = h->SetpFDeg();
2251 /* compute the ecart */
2252 if (ei <= h->ecart)
2253 h->ecart = d-h_d;
2254 else
2255 h->ecart = d-h_d+ei-h->ecart;
2256
2257 /*
2258 * try to reduce the s-polynomial h
2259 *test first whether h should go to the lazyset L
2260 *-if the degree jumps
2261 *-if the number of pre-defined reductions jumps
2262 */
2263 pass++;
2264 d = h_d + h->ecart;
2265 if (UNLIKELY(!TEST_OPT_REDTHROUGH
2266 && (strat->Ll >= 0)
2267 && ((d > reddeg) || (pass > strat->LazyPass))))
2268 {
2269 h->GetTP(); // clear bucket
2270 h->SetLmCurrRing();
2271 at = strat->posInL(strat->L,strat->Ll,h,strat);
2272 if (at <= strat->Ll)
2273 {
2274#ifdef HAVE_SHIFTBBA
2275 if (rIsLPRing(currRing))
2276 {
2277 if (kFindDivisibleByInT(strat, h) < 0)
2278 return 1;
2279 }
2280 else
2281#endif
2282 {
2283 int dummy=strat->sl;
2284 if (kFindDivisibleByInS(strat, &dummy, h) < 0)
2285 return 1;
2286 }
2287 enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
2288#ifdef KDEBUG
2289 if (TEST_OPT_DEBUG)
2290 Print(" degree jumped: -> L%d\n",at);
2291#endif
2292 h->Clear();
2293 return -1;
2294 }
2295 }
2296 else if (d > reddeg)
2297 {
2298 if (UNLIKELY(d>=(long)strat->tailRing->bitmask))
2299 {
2300 if (h->pTotalDeg()+h->ecart >= (long)strat->tailRing->bitmask)
2301 {
2302 strat->overflow=TRUE;
2303 //Print("OVERFLOW in redHoney d=%ld, max=%ld\n",d,strat->tailRing->bitmask);
2304 h->GetP();
2305 at = strat->posInL(strat->L,strat->Ll,h,strat);
2306 enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
2307 h->Clear();
2308 return -1;
2309 }
2310 }
2311 else if (UNLIKELY(TEST_OPT_PROT && (strat->Ll < 0) ))
2312 {
2313 //h->wrp(); Print("<%d>\n",h->GetpLength());
2314 reddeg = d;
2315 Print(".%ld",d); mflush();
2316 }
2317 }
2318 }
2319}

◆ redHoneyM()

int redHoneyM ( LObject *  h,
kStrategy  strat 
)

◆ redLazy()

int redLazy ( LObject *  h,
kStrategy  strat 
)

TEST_OPT_REDTHROUGH &&

Definition at line 1881 of file kstd2.cc.

1882{
1883 if (strat->tl<0) return 1;
1884 int at,i,ii,li;
1885 int j = 0;
1886 int pass = 0;
1887 int cnt = RED_CANONICALIZE;
1888 assume(h->pFDeg() == h->FDeg);
1889 long reddeg = h->GetpFDeg();
1890 long d;
1891 BOOLEAN test_opt_length=TEST_OPT_LENGTH;
1892
1893 h->SetShortExpVector();
1894 poly h_p = h->GetLmTailRing();
1895 h->PrepareRed(strat->use_buckets);
1896 loop
1897 {
1898 j = kFindDivisibleByInT(strat, h);
1899 if (j < 0) return 1;
1900
1901 li = strat->T[j].pLength;
1902 ii = j;
1903 /*
1904 * the polynomial to reduce with (up to the moment) is;
1905 * pi with length li
1906 */
1907
1908 i = j;
1909#if 1
1910 if (test_opt_length)
1911 {
1912 if (li<=0) li=strat->T[j].GetpLength();
1913 if(li>2)
1914 {
1915 unsigned long not_sev = ~ h->sev;
1916 loop
1917 {
1918 /*- search the shortest possible with respect to length -*/
1919 i++;
1920 if (i > strat->tl)
1921 break;
1922 if ((strat->T[i].pLength < li)
1923 &&
1924 p_LmShortDivisibleBy(strat->T[i].GetLmTailRing(), strat->sevT[i],
1925 h_p, not_sev, strat->tailRing))
1926 {
1927 /*
1928 * the polynomial to reduce with is now;
1929 */
1930 li = strat->T[i].pLength;
1931 if (li<=0) li=strat->T[i].GetpLength();
1932 ii = i;
1933 if (li<3) break;
1934 }
1935 }
1936 }
1937 }
1938#endif
1939
1940 /*
1941 * end of search: have to reduce with pi
1942 */
1943
1944
1945#ifdef KDEBUG
1946 if (TEST_OPT_DEBUG)
1947 {
1948 PrintS("red:");
1949 h->wrp();
1950 PrintS(" with ");
1951 strat->T[ii].wrp();
1952 }
1953#endif
1954
1955 ksReducePoly(h, &(strat->T[ii]), NULL, NULL, NULL, strat);
1956#if SBA_PRINT_REDUCTION_STEPS
1957 sba_interreduction_steps++;
1958#endif
1959#if SBA_PRINT_OPERATIONS
1960 sba_interreduction_operations += pLength(strat->T[ii].p);
1961#endif
1962
1963#ifdef KDEBUG
1964 if (TEST_OPT_DEBUG)
1965 {
1966 PrintS("\nto ");
1967 h->wrp();
1968 PrintLn();
1969 }
1970#endif
1971
1972 h_p=h->GetLmTailRing();
1973
1974 if (h_p == NULL)
1975 {
1976 kDeleteLcm(h);
1977 return 0;
1978 }
1979 #if 0 // red id redLiftstd if OPT_IDLIFT
1980 if (UNLIKELY(TEST_OPT_IDLIFT))
1981 {
1982 if (h->p!=NULL)
1983 {
1984 if(p_GetComp(h->p,currRing)>strat->syzComp)
1985 {
1986 h->Delete();
1987 return 0;
1988 }
1989 }
1990 else if (h->t_p!=NULL)
1991 {
1992 if(p_GetComp(h->t_p,strat->tailRing)>strat->syzComp)
1993 {
1994 h->Delete();
1995 return 0;
1996 }
1997 }
1998 }
1999 #endif
2000 #if 0
2001 else if ((strat->syzComp > 0)&&(!TEST_OPT_REDTAIL_SYZ))
2002 {
2003 if (h->p!=NULL)
2004 {
2005 if(p_GetComp(h->p,currRing)>strat->syzComp)
2006 {
2007 return 1;
2008 }
2009 }
2010 else if (h->t_p!=NULL)
2011 {
2012 if(p_GetComp(h->t_p,strat->tailRing)>strat->syzComp)
2013 {
2014 return 1;
2015 }
2016 }
2017 }
2018 #endif
2019 h->SetShortExpVector();
2020 d = h->SetpFDeg();
2021 /*- try to reduce the s-polynomial -*/
2022 cnt--;
2023 pass++;
2024 if (//!TEST_OPT_REDTHROUGH &&
2025 (strat->Ll >= 0) && ((d > reddeg) || (pass > strat->LazyPass)))
2026 {
2027 h->SetLmCurrRing();
2028 at = strat->posInL(strat->L,strat->Ll,h,strat);
2029 if (at <= strat->Ll)
2030 {
2031#if 1
2032#ifdef HAVE_SHIFTBBA
2033 if (rIsLPRing(currRing))
2034 {
2035 if (kFindDivisibleByInT(strat, h) < 0)
2036 return 1;
2037 }
2038 else
2039#endif
2040 {
2041 int dummy=strat->sl;
2042 if (kFindDivisibleByInS(strat, &dummy, h) < 0)
2043 return 1;
2044 }
2045#endif
2046#ifdef KDEBUG
2047 if (TEST_OPT_DEBUG) Print(" ->L[%d]\n",at);
2048#endif
2049 enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
2050 h->Clear();
2051 return -1;
2052 }
2053 }
2054 else if (d != reddeg)
2055 {
2056 if (UNLIKELY(d>=(long)strat->tailRing->bitmask))
2057 {
2058 if (h->pTotalDeg() >= (long)strat->tailRing->bitmask)
2059 {
2060 strat->overflow=TRUE;
2061 //Print("OVERFLOW in redLazy d=%ld, max=%ld\n",d,strat->tailRing->bitmask);
2062 h->GetP();
2063 at = strat->posInL(strat->L,strat->Ll,h,strat);
2064 enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
2065 h->Clear();
2066 return -1;
2067 }
2068 }
2069 else if ((TEST_OPT_PROT) && (strat->Ll < 0))
2070 {
2071 Print(".%ld",d);mflush();
2072 reddeg = d;
2073 }
2074 }
2075 else if (UNLIKELY(cnt==0))
2076 {
2077 h->CanonicalizeP();
2078 cnt=RED_CANONICALIZE;
2079 //if (TEST_OPT_PROT) { PrintS("!");mflush(); }
2080 }
2081 }
2082}

◆ redLiftstd()

int redLiftstd ( LObject *  h,
kStrategy  strat 
)

Definition at line 167 of file kLiftstd.cc.

168{
169 if (strat->tl<0) return 1;
170 assume(h->FDeg == h->pFDeg());
171 assume(TEST_OPT_IDLIFT);
172 poly h_p;
173 int i,j,pass,ei, ii, h_d,ci;
174 unsigned long not_sev;
175 long reddeg,d;
176 #define START_REDUCE 512
177 int red_size=START_REDUCE;
178 number *A=(number*)omAlloc0(red_size*sizeof(number));
179 poly *C=(poly*)omAlloc0(red_size*sizeof(poly));
180 poly *T=(poly*)omAlloc0(red_size*sizeof(poly));
181 const ring tailRing=strat->tailRing;
182
183 pass = j = 0;
184 d = reddeg = h->GetpFDeg() + h->ecart;
185 h->SetShortExpVector();
186 int li;
187 h_p = h->GetLmTailRing();
188 not_sev = ~ h->sev;
189
190 // split h into mina part (h) and tail (h_tail)
191 poly h_tail=kSplitAt(strat->syzComp,h,strat);
192 // fix h-pLength
193 h->pLength=0;
194 h->PrepareRed(strat->use_buckets);
195 loop
196 {
197 j=kFindDivisibleByInT(strat, h);
198 if (j < 0)
199 {
200 // lazy computation:
201 int l;
202 poly p=lazyComp(A,C,T,pass,h_tail,&l,strat->tailRing);
203 kBucket_Add_q(h->bucket,p,&l);
204 omFreeSize(A,red_size*sizeof(number));
205 omFreeSize(T,red_size*sizeof(poly));
206 omFreeSize(C,red_size*sizeof(poly));
207 return 1;
208 }
209
210 ei = strat->T[j].ecart;
211 li = strat->T[j].pLength;
212 ci = nSize(pGetCoeff(strat->T[j].p));
213 ii = j;
214 /*
215 * the polynomial to reduce with (up to the moment) is;
216 * pi with ecart ei (T[ii])
217 */
218 i = j;
219 if (TEST_OPT_LENGTH)
220 {
221 if (li<=0) li=strat->T[j].GetpLength();
222 if (li>1)
223 loop
224 {
225 /*- possible with respect to ecart, minimal nSize -*/
226 i++;
227 if (i > strat->tl)
228 break;
229 //if (ei < h->ecart)
230 // break;
231 if ((((strat->T[i].ecart < ei) && (ei> h->ecart))
232 || ((strat->T[i].ecart <= h->ecart)
233 && (strat->T[i].pLength <= li)
234 && (nSize(pGetCoeff(strat->T[i].p)) <ci)))
235 &&
236 p_LmShortDivisibleBy(strat->T[i].GetLmTailRing(), strat->sevT[i],
237 h_p, not_sev, tailRing))
238 {
239 /*
240 * the polynomial to reduce with is now;
241 */
242 ei = strat->T[i].ecart;
243 li = strat->T[i].pLength;
244 if (li<=0) li=strat->T[i].GetpLength();
245 ii = i;
246 if (li==1) break;
247 }
248 }
249 }
250
251 /*
252 * end of search: have to reduce with pi
253 */
254#ifdef KDEBUG
255 if (TEST_OPT_DEBUG)
256 {
257 PrintS("red:");
258 h->wrp();
259 Print("\nwith T[%d]:",ii);
260 strat->T[ii].wrp();
261 }
262#endif
263 assume(strat->fromT == FALSE);
264
265 //strat->T[ii].pCleardenom();
266 // split T[ii]:
267 // remember pLength of strat->T[ii]
268 int l_orig=strat->T[ii].pLength;
269 // split strat->T[ii]
270 poly T_tail=kSplitAt(strat->syzComp,&strat->T[ii],strat);
271 h->pLength=0; // force re-computation of length
272 ksReducePoly(h,&(strat->T[ii]),NULL,&A[pass],&C[pass], strat);
273 // restore T[ii]:
274 kAppend(T_tail,&strat->T[ii]);
275 strat->T[ii].pLength=l_orig;
276 // store T_tail
277 T[pass]=T_tail;
278 // delayed computation: A[pass]*tail-M[pass]*T[pass]
279#ifdef KDEBUG
280 if (TEST_OPT_DEBUG)
281 {
282 PrintS("\nto:");
283 h->wrp();
284 PrintLn();
285 }
286#endif
287 if(h->IsNull())
288 {
289 // clean up A,C,h_tail:
290 for(int i=0;i<=pass;i++)
291 {
292 n_Delete(&A[i],tailRing->cf);
293 p_Delete(&C[i],tailRing);
294 }
295 p_Delete(&h_tail,tailRing);
296 kDeleteLcm(h);
297 h->Clear();
298 omFreeSize(A,red_size*sizeof(number));
299 omFreeSize(T,red_size*sizeof(poly));
300 omFreeSize(C,red_size*sizeof(poly));
301 return 0;
302 }
303 h->SetShortExpVector();
304 not_sev = ~ h->sev;
305 h_d = h->SetpFDeg();
306 /* compute the ecart */
307 if (ei <= h->ecart)
308 h->ecart = d-h_d;
309 else
310 h->ecart = d-h_d+ei-h->ecart;
311
312 /*
313 * try to reduce the s-polynomial h
314 *test first whether h should go to the lazyset L
315 *-if the degree jumps
316 *-if the number of pre-defined reductions jumps
317 */
318 pass++;
319 d = h_d + h->ecart;
320 if (pass%RED_CANONICALIZE==0) kBucketCanonicalize(h->bucket);
321 // if cache is to small, double its size:
322 if (pass>=red_size-1)
323 {
324 A=(number*)omRealloc0Size(A,red_size*sizeof(number),2*red_size*sizeof(number));
325 C=(poly*)omRealloc0Size(C,red_size*sizeof(poly),2*red_size*sizeof(poly));
326 T=(poly*)omRealloc0Size(T,red_size*sizeof(poly),2*red_size*sizeof(poly));
327 if(TEST_OPT_PROT) {Print("+%d+",red_size);mflush();}
328 red_size*=2;
329 }
330 }
331}
lazyComp
static poly lazyComp(number *A, poly *M, poly *T, int index, poly s, int *l, const ring tailR)
Definition: kLiftstd.cc:132
kAppend
static void kAppend(poly t, TObject *h)
Definition: kLiftstd.cc:121
START_REDUCE
#define START_REDUCE
kSplitAt
static poly kSplitAt(int k, TObject *h, kStrategy strat)
Definition: kLiftstd.cc:28
kBucket_Add_q
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
kBucketCanonicalize
int kBucketCanonicalize(kBucket_pt bucket)
Canonicalizes Bpoly, i.e. converts polys of buckets into one poly in one bucket: Returns number of bu...
nSize
#define nSize(n)
Definition: numbers.h:39
A
#define A
Definition: sirandom.c:24

◆ redNF()

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

Definition at line 2325 of file kstd2.cc.

2326{
2327 if (h==NULL) return NULL;
2328 int j,j_ring;
2329 int cnt=REDNF_CANONICALIZE;
2330 max_ind=strat->sl;
2331
2332 if (0 > strat->sl)
2333 {
2334 return h;
2335 }
2336 LObject P(h);
2337 P.SetShortExpVector();
2338 P.t_p=NULL;
2339#ifdef HAVE_RINGS
2340 BOOLEAN is_ring = rField_is_Ring(currRing);
2341 if(is_ring) nonorm=TRUE;
2342#endif
2343#ifdef KDEBUG
2344// if (TEST_OPT_DEBUG)
2345// {
2346// PrintS("redNF: starting S:\n");
2347// for( j = 0; j <= max_ind; j++ )
2348// {
2349// Print("S[%d] (of size: %d): ", j, pSize(strat->S[j]));
2350// pWrite(strat->S[j]);
2351// }
2352// };
2353#endif
2354 if (rField_is_Z(currRing))
2355 {
2356 redRing_Z_S(&P,strat);
2357 if (P.bucket!=NULL)
2358 {
2359 P.p=kBucketClear(P.bucket);
2360 kBucketDestroy(&P.bucket);
2361 }
2362 return P.p;
2363 }
2364 else if (rField_is_Ring(currRing))
2365 {
2366 redRing_S(&P,strat);
2367 if (P.bucket!=NULL)
2368 {
2369 P.p=kBucketClear(P.bucket);
2370 kBucketDestroy(&P.bucket);
2371 }
2372 return P.p;
2373 }
2374
2375 P.bucket = kBucketCreate(currRing);
2376 kBucketInit(P.bucket,P.p,pLength(P.p));
2377 kbTest(P.bucket);
2378 P.p=kBucketGetLm(P.bucket);
2379 loop
2380 {
2381 j_ring=j=kFindDivisibleByInS_noCF(strat,&max_ind,&P);
2382 while ((j>=0)
2383 && (nonorm)
2384 && (!n_DivBy(pGetCoeff(P.p),pGetCoeff(strat->S[j]),currRing->cf)))
2385 j=kFindNextDivisibleByInS(strat,j+1,max_ind,&P);
2386 if (j>=0)
2387 {
2388 int sl=pSize(strat->S[j]);
2389 int jj=j;
2390 loop
2391 {
2392 int sll;
2393 jj=kFindNextDivisibleByInS(strat,jj+1,max_ind,&P);
2394 if (jj<0) break;
2395 if ((!nonorm)
2396 || (n_DivBy(pGetCoeff(P.p),pGetCoeff(strat->S[jj]),currRing->cf)))
2397 {
2398 sll=pSize(strat->S[jj]);
2399 if (sll<sl)
2400 {
2401 #ifdef KDEBUG
2402 if (TEST_OPT_DEBUG) Print("better(S%d:%d -> S%d:%d)\n",j,sl,jj,sll);
2403 #endif
2404 //else if (TEST_OPT_PROT) { PrintS("b"); mflush(); }
2405 j=jj;
2406 sl=sll;
2407 }
2408 }
2409 }
2410 if ((nonorm==0) && (!nIsOne(pGetCoeff(strat->S[j]))))
2411 {
2412 pNorm(strat->S[j]);
2413 //if (TEST_OPT_PROT) { PrintS("n"); mflush(); }
2414 }
2415 nNormalize(pGetCoeff(P.p));
2416#ifdef KDEBUG
2417 if (TEST_OPT_DEBUG)
2418 {
2419 PrintS("red:");
2420 wrp(P.p);
2421 PrintS(" with ");
2422 wrp(strat->S[j]);
2423 }
2424#endif
2425#ifdef HAVE_PLURAL
2426 if (rIsPluralRing(currRing))
2427 {
2428 number coef;
2429 nc_kBucketPolyRed_NF(P.bucket,strat->S[j],&coef,nonorm);
2430 nDelete(&coef);
2431 }
2432 else
2433#endif
2434 {
2435 kBucketPolyRedNF(P.bucket,strat->S[j],pLength(strat->S[j]),
2436 strat->kNoether);
2437 }
2438 cnt--;
2439 if (cnt==0)
2440 {
2441 kBucketCanonicalize(P.bucket);
2442 cnt=REDNF_CANONICALIZE;
2443 }
2444 P.p=kBucketGetLm(P.bucket);
2445 //P.t_p=NULL;
2446#ifdef KDEBUG
2447 if (TEST_OPT_DEBUG)
2448 {
2449 PrintS("\nto:");
2450 wrp(P.p);
2451 PrintLn();
2452 }
2453#endif
2454 if (P.p==NULL)
2455 {
2456 kBucketDestroy(&P.bucket);
2457 return NULL;
2458 }
2459 kbTest(P.bucket);
2460 P.SetShortExpVector();
2461 }
2462#ifdef HAVE_RINGS
2463 else if (is_ring && (j_ring>=0) && (currRing->cf->cfQuotRem!=ndQuotRem))
2464 {
2465 number r;
2466 number n=n_QuotRem(pGetCoeff(P.p),pGetCoeff(strat->S[j_ring]),&r,currRing->cf);
2467 if(!n_IsZero(n,currRing->cf))
2468 {
2469 poly lm=kBucketGetLm(P.bucket);
2470 poly m=p_Head(lm,currRing);
2471 p_ExpVectorSub(m,strat->S[j_ring],currRing);
2472 if (p_GetComp(strat->S[j_ring], currRing) != p_GetComp(lm, currRing))
2473 {
2474 p_SetComp(m,p_GetComp(lm, currRing),currRing);
2475 }
2476 p_SetCoeff(m,n,currRing);
2477 p_Setm(m,currRing);
2478#ifdef KDEBUG
2479 if (TEST_OPT_DEBUG)
2480 {
2481 PrintS("redi (coeff):");
2482 wrp(P.p);
2483 PrintS(" with ");
2484 wrp(strat->S[j]);
2485 }
2486#endif
2487 int l=-1;
2488 kBucket_Minus_m_Mult_p(P.bucket,m,strat->S[j_ring],&l);
2489 P.p=kBucketGetLm(P.bucket);
2490 p_Delete(&m,currRing);
2491#ifdef KDEBUG
2492 if (TEST_OPT_DEBUG)
2493 {
2494 PrintS("\nto:");
2495 wrp(P.p);
2496 PrintLn();
2497 }
2498#endif
2499 }
2500 else
2501 {
2502 n_Delete(&n,currRing->cf);
2503 }
2504 n_Delete(&r,currRing->cf);
2505 P.p=kBucketClear(P.bucket);
2506 kBucketDestroy(&P.bucket);
2507 pNormalize(P.p);
2508 return P.p;
2509 }
2510#endif
2511 else
2512 {
2513 P.p=kBucketClear(P.bucket);
2514 kBucketDestroy(&P.bucket);
2515 pNormalize(P.p);
2516 return P.p;
2517 }
2518 }
2519}
m
int m
Definition: cfEzgcd.cc:128
kBucketClear
void kBucketClear(kBucket_pt bucket, poly *p, int *length)
Definition: kbuckets.cc:521
kBucket_Minus_m_Mult_p
void kBucket_Minus_m_Mult_p(kBucket_pt bucket, poly m, poly p, int *l, poly spNoether)
Bpoly == Bpoly - m*p; where m is a monom Does not destroy p and m assume (*l <= 0 || pLength(p) == *l...
Definition: kbuckets.cc:722
kBucketInit
void kBucketInit(kBucket_pt bucket, poly lm, int length)
Definition: kbuckets.cc:493
kBucketCreate
kBucket_pt kBucketCreate(const ring bucket_ring)
Creation/Destruction of buckets.
Definition: kbuckets.cc:209
kBucketPolyRedNF
void kBucketPolyRedNF(kBucket_pt bucket, poly p1, int l1, poly spNoether)
Definition: kbuckets.cc:1188
kBucketGetLm
const poly kBucketGetLm(kBucket_pt bucket)
Definition: kbuckets.cc:506
kFindNextDivisibleByInS
int kFindNextDivisibleByInS(const kStrategy strat, int start, int max_ind, LObject *L)
Definition: kstd2.cc:524
kFindDivisibleByInS_noCF
int kFindDivisibleByInS_noCF(const kStrategy strat, int *max_ind, LObject *L)
Definition: kstd2.cc:484
redRing_S
static int redRing_S(LObject *h, kStrategy strat)
Definition: kstd2.cc:1056
redRing_Z_S
static int redRing_Z_S(LObject *h, kStrategy strat)
Definition: kstd2.cc:841
REDNF_CANONICALIZE
#define REDNF_CANONICALIZE
Definition: kutil.h:37
nc_kBucketPolyRed_NF
static void nc_kBucketPolyRed_NF(kBucket_pt b, poly p, number *c, BOOLEAN reduce)
Definition: nc.h:275
nNormalize
#define nNormalize(n)
Definition: numbers.h:30
p_Head
static poly p_Head(const poly p, const ring r)
copy the (leading) term of p
Definition: p_polys.h:858
pNormalize
#define pNormalize(p)
Definition: polys.h:317
pSize
#define pSize(p)
Definition: polys.h:318

◆ redNF0()

int redNF0 ( LObject *  P,
kStrategy  strat 
)

◆ redNFTail()

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

◆ redRiloc()

int redRiloc ( LObject *  h,
kStrategy  strat 
)

Definition at line 387 of file kstd1.cc.

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

◆ redRing()

int redRing ( LObject *  h,
kStrategy  strat 
)

Definition at line 954 of file kstd2.cc.

955{
956 if (strat->tl<0) return 1;
957 if (h->IsNull()) return 0; // spoly is zero (can only occur with zero divisors)
958
959 int at/*,i*/;
960 long d;
961 int j = 0;
962 int pass = 0;
963 // poly zeroPoly = NULL;
964
965// TODO warum SetpFDeg notwendig?
966 h->SetpFDeg();
967 assume(h->pFDeg() == h->FDeg);
968 long reddeg = h->GetpFDeg();
969
970 h->SetShortExpVector();
971 loop
972 {
973 j = kFindDivisibleByInT(strat, h);
974 if (j < 0)
975 {
976 // over ZZ: cleanup coefficients by complete reduction with monomials
977 postReduceByMon(h, strat);
978 if(h->p == NULL)
979 {
980 kDeleteLcm(h);
981 h->Clear();
982 return 0;
983 }
984 if(nIsZero(pGetCoeff(h->p))) return 2;
985 j = kFindDivisibleByInT(strat, h);
986 if(j < 0)
987 {
988 if(strat->tl >= 0)
989 h->i_r1 = strat->tl;
990 else
991 h->i_r1 = -1;
992 if (h->GetLmTailRing() == NULL)
993 {
994 kDeleteLcm(h);
995 h->Clear();
996 return 0;
997 }
998 return 1;
999 }
1000 }
1001 //printf("\nFound one: ");pWrite(strat->T[j].p);
1002 //enterT(*h, strat);
1003 ksReducePoly(h, &(strat->T[j]), NULL, NULL, NULL, strat); // with debug output
1004 //printf("\nAfter small red: ");pWrite(h->p);
1005 if (h->GetLmTailRing() == NULL)
1006 {
1007 kDeleteLcm(h);
1008 h->Clear();
1009 return 0;
1010 }
1011 h->SetShortExpVector();
1012 d = h->SetpFDeg();
1013 /*- try to reduce the s-polynomial -*/
1014 pass++;
1015 if (!TEST_OPT_REDTHROUGH &&
1016 (strat->Ll >= 0) && ((d > reddeg) || (pass > strat->LazyPass)))
1017 {
1018 h->SetLmCurrRing();
1019 if (strat->posInLDependsOnLength)
1020 h->SetLength(strat->length_pLength);
1021 at = strat->posInL(strat->L,strat->Ll,h,strat);
1022 if (at <= strat->Ll)
1023 {
1024#ifdef KDEBUG
1025 if (TEST_OPT_DEBUG) Print(" ->L[%d]\n",at);
1026#endif
1027 enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at); // NOT RING CHECKED OLIVER
1028 h->Clear();
1029 return -1;
1030 }
1031 }
1032 if (d != reddeg)
1033 {
1034 if (UNLIKELY(d>=(long)strat->tailRing->bitmask))
1035 {
1036 if (h->pTotalDeg() >= (long)strat->tailRing->bitmask)
1037 {
1038 strat->overflow=TRUE;
1039 //Print("OVERFLOW in redRing d=%ld, max=%ld\n",d,strat->tailRing->bitmask);
1040 h->GetP();
1041 at = strat->posInL(strat->L,strat->Ll,h,strat);
1042 enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
1043 h->Clear();
1044 return -1;
1045 }
1046 }
1047 else if ((TEST_OPT_PROT) && (strat->Ll < 0))
1048 {
1049 Print(".%ld",d);mflush();
1050 reddeg = d;
1051 }
1052 }
1053 }
1054}

◆ redRing_Z()

int redRing_Z ( LObject *  h,
kStrategy  strat 
)

Definition at line 683 of file kstd2.cc.

684{
685 if (h->IsNull()) return 0; // spoly is zero (can only occur with zero divisors)
686 if (strat->tl<0) return 1;
687
688 int at;
689 long d;
690 int j = 0;
691 int pass = 0;
692
693// TODO warum SetpFDeg notwendig?
694 h->SetpFDeg();
695 assume(h->pFDeg() == h->FDeg);
696 long reddeg = h->GetpFDeg();
697
698 h->SetShortExpVector();
699 loop
700 {
701 /* check if a reducer of the lead term exists */
702 j = kFindDivisibleByInT(strat, h);
703 if (j < 0)
704 {
705#if STDZ_EXCHANGE_DURING_REDUCTION
706 /* check if a reducer with the same lead monomial exists */
707 j = kFindSameLMInT_Z(strat, h);
708 if (j < 0)
709 {
710#endif
711 /* check if a reducer of the lead monomial exists, by the above
712 * check this is a real divisor of the lead monomial */
713 j = kFindDivisibleByInT_Z(strat, h);
714 if (j < 0)
715 {
716 // over ZZ: cleanup coefficients by complete reduction with monomials
717 if (rHasLocalOrMixedOrdering(currRing))
718 postReduceByMon(h, strat);
719 if(h->p == NULL)
720 {
721 if (h->lcm!=NULL) pLmDelete(h->lcm);
722 h->Clear();
723 return 0;
724 }
725 if(nIsZero(pGetCoeff(h->p))) return 2;
726 j = kFindDivisibleByInT(strat, h);
727 if(j < 0)
728 {
729 if(strat->tl >= 0)
730 h->i_r1 = strat->tl;
731 else
732 h->i_r1 = -1;
733 if (h->GetLmTailRing() == NULL)
734 {
735 if (h->lcm!=NULL) pLmDelete(h->lcm);
736 h->Clear();
737 return 0;
738 }
739 return 1;
740 }
741 }
742 else
743 {
744 /* not(lc(reducer) | lc(poly)) && not(lc(poly) | lc(reducer))
745 * => we try to cut down the lead coefficient at least */
746 /* first copy T[j] in order to multiply it with a coefficient later on */
747 number mult, rest;
748 TObject tj = strat->T[j];
749 tj.Copy();
750 /* tj.max_exp = strat->T[j].max_exp; */
751 /* compute division with remainder of lc(h) and lc(T[j]) */
752 mult = n_QuotRem(pGetCoeff(h->p), pGetCoeff(strat->T[j].p),
753 &rest, currRing->cf);
754 /* set corresponding new lead coefficient already. we do not
755 * remove the lead term in ksReducePolyLC, but only apply
756 * a lead coefficient reduction */
757 tj.Mult_nn(mult);
758 ksReducePolyLC(h, &tj, NULL, &rest, strat);
759 tj.Delete();
760 tj.Clear();
761 }
762#if STDZ_EXCHANGE_DURING_REDUCTION
763 }
764 else
765 {
766 /* same lead monomial but lead coefficients do not divide each other:
767 * change the polys to h <- spoly(h,tj) and h2 <- gpoly(h,tj). */
768 LObject h2 = *h;
769 h2.Copy();
770
771 ksReducePolyZ(h, &(strat->T[j]), NULL, NULL, strat);
772 ksReducePolyGCD(&h2, &(strat->T[j]), NULL, NULL, strat);
773 if (!rHasLocalOrMixedOrdering(currRing))
774 {
775 redtailBbaAlsoLC_Z(&h2, j, strat);
776 }
777 /* replace h2 for tj in L (already generated pairs with tj), S and T */
778 replaceInLAndSAndT(h2, j, strat);
779 }
780#endif
781 }
782 else
783 {
784 ksReducePoly(h, &(strat->T[j]), NULL, NULL, NULL, strat);
785 }
786 /* printf("\nAfter small red: ");pWrite(h->p); */
787 if (h->GetLmTailRing() == NULL)
788 {
789 if (h->lcm!=NULL) pLmDelete(h->lcm);
790#ifdef KDEBUG
791 h->lcm=NULL;
792#endif
793 h->Clear();
794 return 0;
795 }
796 h->SetShortExpVector();
797 d = h->SetpFDeg();
798 /*- try to reduce the s-polynomial -*/
799 pass++;
800 if (!TEST_OPT_REDTHROUGH &&
801 (strat->Ll >= 0) && ((d > reddeg) || (pass > strat->LazyPass)))
802 {
803 h->SetLmCurrRing();
804 if (strat->posInLDependsOnLength)
805 h->SetLength(strat->length_pLength);
806 at = strat->posInL(strat->L,strat->Ll,h,strat);
807 if (at <= strat->Ll)
808 {
809#ifdef KDEBUG
810 if (TEST_OPT_DEBUG) Print(" ->L[%d]\n",at);
811#endif
812 enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at); // NOT RING CHECKED OLIVER
813 h->Clear();
814 return -1;
815 }
816 }
817 if (d != reddeg)
818 {
819 if (UNLIKELY(d>=(long)strat->tailRing->bitmask))
820 {
821 if (h->pTotalDeg() >= (long)strat->tailRing->bitmask)
822 {
823 strat->overflow=TRUE;
824 //Print("OVERFLOW in redRing d=%ld, max=%ld\n",d,strat->tailRing->bitmask);
825 h->GetP();
826 at = strat->posInL(strat->L,strat->Ll,h,strat);
827 enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
828 h->Clear();
829 return -1;
830 }
831 }
832 else if ((TEST_OPT_PROT) && (strat->Ll < 0))
833 {
834 Print(".%ld",d);mflush();
835 reddeg = d;
836 }
837 }
838 }
839}
ksReducePolyLC
int ksReducePolyLC(LObject *PR, TObject *PW, poly spNoether, number *coef, kStrategy strat)
Definition: kspoly.cc:481
kFindDivisibleByInT_Z
int kFindDivisibleByInT_Z(const kStrategy strat, const LObject *L, const int start)
Definition: kstd2.cc:213
replaceInLAndSAndT
void replaceInLAndSAndT(LObject &p, int tj, kStrategy strat)
Definition: kutil.cc:9087
ksReducePolyGCD
int ksReducePolyGCD(LObject *PR, TObject *PW, poly spNoether=NULL, number *coef=NULL, kStrategy strat=NULL)
kFindSameLMInT_Z
int kFindSameLMInT_Z(const kStrategy strat, const LObject *L, const int start=0)
ksReducePolyZ
int ksReducePolyZ(LObject *PR, TObject *PW, poly spNoether=NULL, number *coef=NULL, kStrategy strat=NULL)

◆ redSig()

int redSig ( LObject *  h,
kStrategy  strat 
)

Definition at line 1343 of file kstd2.cc.

1344{
1345 if (strat->tl<0) return 1;
1346 //if (h->GetLmTailRing()==NULL) return 0; // HS: SHOULD NOT BE NEEDED!
1347 //printf("FDEGS: %ld -- %ld\n",h->FDeg, h->pFDeg());
1348 assume(h->FDeg == h->pFDeg());
1349//#if 1
1350#ifdef DEBUGF5
1351 PrintS("------- IN REDSIG -------\n");
1352 Print("p: ");
1353 pWrite(pHead(h->p));
1354 PrintS("p1: ");
1355 pWrite(pHead(h->p1));
1356 PrintS("p2: ");
1357 pWrite(pHead(h->p2));
1358 PrintS("---------------------------\n");
1359#endif
1360 poly h_p;
1361 int i,j,at,pass, ii;
1362 int start=0;
1363 int sigSafe;
1364 unsigned long not_sev;
1365 // long reddeg,d;
1366 BOOLEAN test_opt_length=TEST_OPT_LENGTH;
1367 int li;
1368
1369 pass = j = 0;
1370 // d = reddeg = h->GetpFDeg();
1371 h->SetShortExpVector();
1372 h_p = h->GetLmTailRing();
1373 not_sev = ~ h->sev;
1374 loop
1375 {
1376 j = kFindDivisibleByInT(strat, h, start);
1377 if (j < 0)
1378 {
1379 return 1;
1380 }
1381
1382 li = strat->T[j].pLength;
1383 if (li<=0) li=strat->T[j].GetpLength();
1384 ii = j;
1385 /*
1386 * the polynomial to reduce with (up to the moment) is;
1387 * pi with length li
1388 */
1389 i = j;
1390#if 1
1391 if (test_opt_length)
1392 loop
1393 {
1394 /*- search the shortest possible with respect to length -*/
1395 i++;
1396 if (i > strat->tl)
1397 break;
1398 if (li==1)
1399 break;
1400 if ((strat->T[i].pLength < li)
1401 &&
1402 p_LmShortDivisibleBy(strat->T[i].GetLmTailRing(), strat->sevT[i],
1403 h_p, not_sev, strat->tailRing))
1404 {
1405 /*
1406 * the polynomial to reduce with is now;
1407 */
1408 li = strat->T[i].pLength;
1409 if (li<=0) li=strat->T[i].GetpLength();
1410 ii = i;
1411 }
1412 }
1413 start = ii+1;
1414#endif
1415
1416 /*
1417 * end of search: have to reduce with pi
1418 */
1419#ifdef KDEBUG
1420 if (TEST_OPT_DEBUG)
1421 {
1422 PrintS("red:");
1423 h->wrp();
1424 PrintS(" with ");
1425 strat->T[ii].wrp();
1426 }
1427#endif
1428 assume(strat->fromT == FALSE);
1429//#if 1
1430#ifdef DEBUGF5
1431 Print("BEFORE REDUCTION WITH %d:\n",ii);
1432 PrintS("--------------------------------\n");
1433 pWrite(h->sig);
1434 pWrite(strat->T[ii].sig);
1435 pWrite(h->GetLmCurrRing());
1436 pWrite(pHead(h->p1));
1437 pWrite(pHead(h->p2));
1438 pWrite(pHead(strat->T[ii].p));
1439 PrintS("--------------------------------\n");
1440 printf("INDEX OF REDUCER T: %d\n",ii);
1441#endif
1442 sigSafe = ksReducePolySig(h, &(strat->T[ii]), strat->S_2_R[ii], NULL, NULL, strat);
1443#if SBA_PRINT_REDUCTION_STEPS
1444 if (sigSafe != 3)
1445 sba_reduction_steps++;
1446#endif
1447#if SBA_PRINT_OPERATIONS
1448 if (sigSafe != 3)
1449 sba_operations += pLength(strat->T[ii].p);
1450#endif
1451 // if reduction has taken place, i.e. the reduction was sig-safe
1452 // otherwise start is already at the next position and the loop
1453 // searching reducers in T goes on from index start
1454//#if 1
1455#ifdef DEBUGF5
1456 Print("SigSAFE: %d\n",sigSafe);
1457#endif
1458 if (sigSafe != 3)
1459 {
1460 // start the next search for reducers in T from the beginning
1461 start = 0;
1462#ifdef KDEBUG
1463 if (TEST_OPT_DEBUG)
1464 {
1465 PrintS("\nto ");
1466 h->wrp();
1467 PrintLn();
1468 }
1469#endif
1470
1471 h_p = h->GetLmTailRing();
1472 if (h_p == NULL)
1473 {
1474 kDeleteLcm(h);
1475 return 0;
1476 }
1477 h->SetShortExpVector();
1478 not_sev = ~ h->sev;
1479 /*
1480 * try to reduce the s-polynomial h
1481 *test first whether h should go to the lazyset L
1482 *-if the degree jumps
1483 *-if the number of pre-defined reductions jumps
1484 */
1485 pass++;
1486 if (!TEST_OPT_REDTHROUGH && (strat->Ll >= 0) && (pass > strat->LazyPass))
1487 {
1488 h->SetLmCurrRing();
1489 at = strat->posInL(strat->L,strat->Ll,h,strat);
1490 if (at <= strat->Ll)
1491 {
1492 int dummy=strat->sl;
1493 if (kFindDivisibleByInS(strat, &dummy, h) < 0)
1494 {
1495 return 1;
1496 }
1497 enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
1498#ifdef KDEBUG
1499 if (TEST_OPT_DEBUG)
1500 Print(" lazy: -> L%d\n",at);
1501#endif
1502 h->Clear();
1503 return -1;
1504 }
1505 }
1506 }
1507 }
1508}
ksReducePolySig
int ksReducePolySig(LObject *PR, TObject *PW, long, poly spNoether, number *coef, kStrategy strat)
Definition: kspoly.cc:742

◆ redSigRing()

int redSigRing ( LObject *  h,
kStrategy  strat 
)

Definition at line 1511 of file kstd2.cc.

1512{
1513 //Since reduce is really bad for SBA we use the following idea:
1514 // We first check if we can build a gcd pair between h and S
1515 //where the sig remains the same and replace h by this gcd poly
1516 assume(rField_is_Ring(currRing));
1517 #if GCD_SBA
1518 while(sbaCheckGcdPair(h,strat))
1519 {
1520 h->sev = pGetShortExpVector(h->p);
1521 }
1522 #endif
1523 poly beforeredsig;
1524 beforeredsig = pCopy(h->sig);
1525
1526 if (strat->tl<0) return 1;
1527 //if (h->GetLmTailRing()==NULL) return 0; // HS: SHOULD NOT BE NEEDED!
1528 //printf("FDEGS: %ld -- %ld\n",h->FDeg, h->pFDeg());
1529 assume(h->FDeg == h->pFDeg());
1530//#if 1
1531#ifdef DEBUGF5
1532 Print("------- IN REDSIG -------\n");
1533 Print("p: ");
1534 pWrite(pHead(h->p));
1535 Print("p1: ");
1536 pWrite(pHead(h->p1));
1537 Print("p2: ");
1538 pWrite(pHead(h->p2));
1539 Print("---------------------------\n");
1540#endif
1541 poly h_p;
1542 int i,j,at,pass, ii;
1543 int start=0;
1544 int sigSafe;
1545 unsigned long not_sev;
1546 // long reddeg,d;
1547 int li;
1548 BOOLEAN test_opt_length=TEST_OPT_LENGTH;
1549
1550 pass = j = 0;
1551 // d = reddeg = h->GetpFDeg();
1552 h->SetShortExpVector();
1553 h_p = h->GetLmTailRing();
1554 not_sev = ~ h->sev;
1555 loop
1556 {
1557 j = kFindDivisibleByInT(strat, h, start);
1558 if (j < 0)
1559 {
1560 #if GCD_SBA
1561 while(sbaCheckGcdPair(h,strat))
1562 {
1563 h->sev = pGetShortExpVector(h->p);
1564 h->is_redundant = FALSE;
1565 start = 0;
1566 }
1567 #endif
1568 // over ZZ: cleanup coefficients by complete reduction with monomials
1569 postReduceByMonSig(h, strat);
1570 if(h->p == NULL || nIsZero(pGetCoeff(h->p))) return 2;
1571 j = kFindDivisibleByInT(strat, h,start);
1572 if(j < 0)
1573 {
1574 if(strat->tl >= 0)
1575 h->i_r1 = strat->tl;
1576 else
1577 h->i_r1 = -1;
1578 if (h->GetLmTailRing() == NULL)
1579 {
1580 kDeleteLcm(h);
1581 h->Clear();
1582 return 0;
1583 }
1584 //Check for sigdrop after reduction
1585 if(pLtCmp(beforeredsig,h->sig) == 1)
1586 {
1587 strat->sigdrop = TRUE;
1588 //Reduce it as much as you can
1589 int red_result = redRing(h,strat);
1590 if(red_result == 0)
1591 {
1592 //It reduced to 0, cancel the sigdrop
1593 strat->sigdrop = FALSE;
1594 p_Delete(&h->sig,currRing);h->sig = NULL;
1595 return 0;
1596 }
1597 else
1598 {
1599 //strat->enterS(*h, strat->sl+1, strat, strat->tl);
1600 return 0;
1601 }
1602 }
1603 p_Delete(&beforeredsig,currRing);
1604 return 1;
1605 }
1606 }
1607
1608 li = strat->T[j].pLength;
1609 if (li<=0) li=strat->T[j].GetpLength();
1610 ii = j;
1611 /*
1612 * the polynomial to reduce with (up to the moment) is;
1613 * pi with length li
1614 */
1615 i = j;
1616 if (test_opt_length)
1617 loop
1618 {
1619 /*- search the shortest possible with respect to length -*/
1620 i++;
1621 if (i > strat->tl)
1622 break;
1623 if (li==1)
1624 break;
1625 if ((strat->T[i].pLength < li)
1626 && n_DivBy(pGetCoeff(h_p),pGetCoeff(strat->T[i].p),currRing->cf)
1627 && p_LmShortDivisibleBy(strat->T[i].GetLmTailRing(), strat->sevT[i],
1628 h_p, not_sev, strat->tailRing))
1629 {
1630 /*
1631 * the polynomial to reduce with is now;
1632 */
1633 li = strat->T[i].pLength;
1634 if (li<=0) li=strat->T[i].GetpLength();
1635 ii = i;
1636 }
1637 }
1638
1639 start = ii+1;
1640
1641 /*
1642 * end of search: have to reduce with pi
1643 */
1644#ifdef KDEBUG
1645 if (TEST_OPT_DEBUG)
1646 {
1647 PrintS("red:");
1648 h->wrp();
1649 PrintS(" with ");
1650 strat->T[ii].wrp();
1651 }
1652#endif
1653 assume(strat->fromT == FALSE);
1654//#if 1
1655#ifdef DEBUGF5
1656 Print("BEFORE REDUCTION WITH %d:\n",ii);
1657 Print("--------------------------------\n");
1658 pWrite(h->sig);
1659 pWrite(strat->T[ii].sig);
1660 pWrite(h->GetLmCurrRing());
1661 pWrite(pHead(h->p1));
1662 pWrite(pHead(h->p2));
1663 pWrite(pHead(strat->T[ii].p));
1664 Print("--------------------------------\n");
1665 printf("INDEX OF REDUCER T: %d\n",ii);
1666#endif
1667 sigSafe = ksReducePolySigRing(h, &(strat->T[ii]), strat->S_2_R[ii], NULL, NULL, strat);
1668 if(h->p == NULL && h->sig == NULL)
1669 {
1670 //Trivial case catch
1671 strat->sigdrop = FALSE;
1672 }
1673 #if 0
1674 //If the reducer has the same lt (+ or -) as the other one, reduce it via redRing
1675 //In some cases this proves to be very bad
1676 if(rField_is_Ring(currRing) && h->p != NULL && pLmCmp(h->p,strat->T[ii].p)==0)
1677 {
1678 int red_result = redRing(h,strat);
1679 if(red_result == 0)
1680 {
1681 pDelete(&h->sig);h->sig = NULL;
1682 return 0;
1683 }
1684 else
1685 {
1686 strat->sigdrop = TRUE;
1687 return 1;
1688 }
1689 }
1690 #endif
1691 if(strat->sigdrop)
1692 return 1;
1693#if SBA_PRINT_REDUCTION_STEPS
1694 if (sigSafe != 3)
1695 sba_reduction_steps++;
1696#endif
1697#if SBA_PRINT_OPERATIONS
1698 if (sigSafe != 3)
1699 sba_operations += pLength(strat->T[ii].p);
1700#endif
1701 // if reduction has taken place, i.e. the reduction was sig-safe
1702 // otherwise start is already at the next position and the loop
1703 // searching reducers in T goes on from index start
1704//#if 1
1705#ifdef DEBUGF5
1706 Print("SigSAFE: %d\n",sigSafe);
1707#endif
1708 if (sigSafe != 3)
1709 {
1710 // start the next search for reducers in T from the beginning
1711 start = 0;
1712#ifdef KDEBUG
1713 if (TEST_OPT_DEBUG)
1714 {
1715 PrintS("\nto ");
1716 h->wrp();
1717 PrintLn();
1718 }
1719#endif
1720
1721 h_p = h->GetLmTailRing();
1722 if (h_p == NULL)
1723 {
1724 kDeleteLcm(h);
1725 return 0;
1726 }
1727 h->SetShortExpVector();
1728 not_sev = ~ h->sev;
1729 /*
1730 * try to reduce the s-polynomial h
1731 *test first whether h should go to the lazyset L
1732 *-if the degree jumps
1733 *-if the number of pre-defined reductions jumps
1734 */
1735 pass++;
1736 if (!TEST_OPT_REDTHROUGH && (strat->Ll >= 0) && (pass > strat->LazyPass))
1737 {
1738 h->SetLmCurrRing();
1739 at = strat->posInL(strat->L,strat->Ll,h,strat);
1740 if (at <= strat->Ll)
1741 {
1742 int dummy=strat->sl;
1743 if (kFindDivisibleByInS(strat, &dummy, h) < 0)
1744 {
1745 return 1;
1746 }
1747 enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
1748#ifdef KDEBUG
1749 if (TEST_OPT_DEBUG)
1750 Print(" lazy: -> L%d\n",at);
1751#endif
1752 h->Clear();
1753 return -1;
1754 }
1755 }
1756 }
1757 }
1758}
ksReducePolySigRing
int ksReducePolySigRing(LObject *PR, TObject *PW, long, poly spNoether, number *coef, kStrategy strat)
Definition: kspoly.cc:948
postReduceByMonSig
void postReduceByMonSig(LObject *h, kStrategy strat)
Definition: kutil.cc:10839
sbaCheckGcdPair
BOOLEAN sbaCheckGcdPair(LObject *h, kStrategy strat)
Definition: kutil.cc:1700

◆ redtail() [1/2]

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

Definition at line 6883 of file kutil.cc.

6884{
6885 poly h, hn;
6886 strat->redTailChange=FALSE;
6887
6888 L->GetP();
6889 poly p = L->p;
6890 if (strat->noTailReduction || pNext(p) == NULL)
6891 return p;
6892
6893 LObject Ln(strat->tailRing);
6894 TObject* With;
6895 // placeholder in case strat->tl < 0
6896 TObject With_s(strat->tailRing);
6897 h = p;
6898 hn = pNext(h);
6899 long op = strat->tailRing->pFDeg(hn, strat->tailRing);
6900 long e;
6901 int l;
6902 BOOLEAN save_HE=strat->kAllAxis;
6903 strat->kAllAxis |=
6904 ((Kstd1_deg>0) && (op<=Kstd1_deg)) || TEST_OPT_INFREDTAIL;
6905
6906 while(hn != NULL)
6907 {
6908 op = strat->tailRing->pFDeg(hn, strat->tailRing);
6909 if ((Kstd1_deg>0)&&(op>Kstd1_deg)) goto all_done;
6910 e = strat->tailRing->pLDeg(hn, &l, strat->tailRing) - op;
6911 loop
6912 {
6913 Ln.Set(hn, strat->tailRing);
6914 Ln.sev = p_GetShortExpVector(hn, strat->tailRing);
6915 if (strat->kAllAxis)
6916 With = kFindDivisibleByInS_T(strat, end_pos, &Ln, &With_s);
6917 else
6918 With = kFindDivisibleByInS_T(strat, end_pos, &Ln, &With_s, e);
6919 if (With == NULL) break;
6920 With->length=0;
6921 With->pLength=0;
6922 strat->redTailChange=TRUE;
6923 if (ksReducePolyTail(L, With, h, strat->kNoetherTail()))
6924 {
6925 // reducing the tail would violate the exp bound
6926 if (kStratChangeTailRing(strat, L))
6927 {
6928 strat->kAllAxis = save_HE;
6929 return redtail(L, end_pos, strat);
6930 }
6931 else
6932 return NULL;
6933 }
6934 hn = pNext(h);
6935 if (hn == NULL) goto all_done;
6936 op = strat->tailRing->pFDeg(hn, strat->tailRing);
6937 if ((Kstd1_deg>0)&&(op>Kstd1_deg)) goto all_done;
6938 e = strat->tailRing->pLDeg(hn, &l, strat->tailRing) - op;
6939 }
6940 h = hn;
6941 hn = pNext(h);
6942 }
6943
6944 all_done:
6945 if (strat->redTailChange)
6946 {
6947 L->pLength = 0;
6948 }
6949 strat->kAllAxis = save_HE;
6950 return p;
6951}
kFindDivisibleByInS_T
TObject * kFindDivisibleByInS_T(kStrategy strat, int end_pos, LObject *L, TObject *T, long ecart)
Definition: kutil.cc:6740
TEST_OPT_INFREDTAIL
#define TEST_OPT_INFREDTAIL
Definition: options.h:119

◆ redtail() [2/2]

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

Definition at line 6953 of file kutil.cc.

6954{
6955 LObject L(p, currRing);
6956 return redtail(&L, end_pos, strat);
6957}

◆ redtailBba() [1/3]

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

Definition at line 6959 of file kutil.cc.

6960{
6961 strat->redTailChange=FALSE;
6962 if (strat->noTailReduction) return L->GetLmCurrRing();
6963 poly h, p;
6964 p = h = L->GetLmTailRing();
6965 if ((h==NULL) || (pNext(h)==NULL))
6966 return L->GetLmCurrRing();
6967
6968 TObject* With;
6969 // placeholder in case strat->tl < 0
6970 TObject With_s(strat->tailRing);
6971
6972 LObject Ln(pNext(h), strat->tailRing);
6973 Ln.GetpLength();
6974
6975 pNext(h) = NULL;
6976 if (L->p != NULL)
6977 {
6978 pNext(L->p) = NULL;
6979 if (L->t_p != NULL) pNext(L->t_p) = NULL;
6980 }
6981 L->pLength = 1;
6982
6983 Ln.PrepareRed(strat->use_buckets);
6984
6985 int cnt=REDTAIL_CANONICALIZE;
6986 while(!Ln.IsNull())
6987 {
6988 loop
6989 {
6990 if (TEST_OPT_IDLIFT)
6991 {
6992 if (Ln.p!=NULL)
6993 {
6994 if (__p_GetComp(Ln.p,currRing)> strat->syzComp) break;
6995 }
6996 else
6997 {
6998 if (__p_GetComp(Ln.t_p,strat->tailRing)> strat->syzComp) break;
6999 }
7000 }
7001 Ln.SetShortExpVector();
7002 if (withT)
7003 {
7004 int j;
7005 j = kFindDivisibleByInT(strat, &Ln);
7006 if (j < 0) break;
7007 With = &(strat->T[j]);
7008 assume(With->GetpLength()==pLength(With->p != __null ? With->p : With->t_p));
7009 }
7010 else
7011 {
7012 With = kFindDivisibleByInS_T(strat, end_pos, &Ln, &With_s);
7013 if (With == NULL) break;
7014 assume(With->GetpLength()==pLength(With->p != __null ? With->p : With->t_p));
7015 }
7016 cnt--;
7017 if (cnt==0)
7018 {
7019 cnt=REDTAIL_CANONICALIZE;
7020 /*poly tmp=*/Ln.CanonicalizeP();
7021 if (normalize)
7022 {
7023 Ln.Normalize();
7024 //pNormalize(tmp);
7025 //if (TEST_OPT_PROT) { PrintS("n"); mflush(); }
7026 }
7027 }
7028 if (normalize && (!TEST_OPT_INTSTRATEGY) && (!nIsOne(pGetCoeff(With->p))))
7029 {
7030 With->pNorm();
7031 }
7032 strat->redTailChange=TRUE;
7033 if (ksReducePolyTail(L, With, &Ln))
7034 {
7035 // reducing the tail would violate the exp bound
7036 // set a flag and hope for a retry (in bba)
7037 strat->completeReduce_retry=TRUE;
7038 if ((Ln.p != NULL) && (Ln.t_p != NULL)) Ln.p=NULL;
7039 do
7040 {
7041 pNext(h) = Ln.LmExtractAndIter();
7042 pIter(h);
7043 L->pLength++;
7044 } while (!Ln.IsNull());
7045 goto all_done;
7046 }
7047 if (Ln.IsNull()) goto all_done;
7048 if (! withT) With_s.Init(currRing);
7049 }
7050 pNext(h) = Ln.LmExtractAndIter();
7051 pIter(h);
7052 pNormalize(h);
7053 L->pLength++;
7054 }
7055
7056 all_done:
7057 Ln.Delete();
7058 if (L->p != NULL) pNext(L->p) = pNext(p);
7059
7060 if (strat->redTailChange)
7061 {
7062 L->length = 0;
7063 L->pLength = 0;
7064 }
7065
7066 //if (TEST_OPT_PROT) { PrintS("N"); mflush(); }
7067 //L->Normalize(); // HANNES: should have a test
7068 kTest_L(L,strat);
7069 return L->GetLmCurrRing();
7070}
REDTAIL_CANONICALIZE
#define REDTAIL_CANONICALIZE
Definition: kutil.h:38
normalize
static poly normalize(poly next_p, ideal add_generators, syStrategy syzstr, int *g_l, int *p_l, int crit_comp)
Definition: syz3.cc:1027

◆ redtailBba() [2/3]

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

Definition at line 1214 of file kInline.h.

1215{
1216 LObject L(p);
1217 return redtailBba(&L, pos, strat,FALSE, normalize);
1218}

◆ redtailBba() [3/3]

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

◆ redtailBba_NF()

poly redtailBba_NF ( poly  p,
kStrategy  strat 
)

Definition at line 7398 of file kutil.cc.

7399{
7400 strat->redTailChange=FALSE;
7401 if (strat->noTailReduction) return p;
7402 if ((p==NULL) || (pNext(p)==NULL))
7403 return p;
7404
7405 int max_ind;
7406 poly h=p;
7407 p=pNext(p);
7408 pNext(h)=NULL;
7409 while(p!=NULL)
7410 {
7411 p=redNF(p,max_ind,1,strat);
7412 if (p!=NULL)
7413 {
7414 poly hh=p;
7415 p=pNext(p);
7416 pNext(hh)=NULL;
7417 h=p_Add_q(h,hh,currRing);
7418 }
7419 }
7420 return h;
7421}

◆ redtailBba_Ring() [1/2]

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

Definition at line 7423 of file kutil.cc.

7425{
7426 strat->redTailChange=FALSE;
7427 if (strat->noTailReduction) return L->GetLmCurrRing();
7428 poly h, p;
7429 p = h = L->GetLmTailRing();
7430 if ((h==NULL) || (pNext(h)==NULL))
7431 return L->GetLmCurrRing();
7432
7433 TObject* With;
7434 // placeholder in case strat->tl < 0
7435 TObject With_s(strat->tailRing);
7436
7437 LObject Ln(pNext(h), strat->tailRing);
7438 Ln.pLength = L->GetpLength() - 1;
7439
7440 pNext(h) = NULL;
7441 if (L->p != NULL) pNext(L->p) = NULL;
7442 L->pLength = 1;
7443
7444 Ln.PrepareRed(strat->use_buckets);
7445
7446 int cnt=REDTAIL_CANONICALIZE;
7447 while(!Ln.IsNull())
7448 {
7449 loop
7450 {
7451 Ln.SetShortExpVector();
7452 With_s.Init(currRing);
7453 With = kFindDivisibleByInS_T(strat, end_pos, &Ln, &With_s);
7454 if (With == NULL) break;
7455 cnt--;
7456 if (cnt==0)
7457 {
7458 cnt=REDTAIL_CANONICALIZE;
7459 /*poly tmp=*/Ln.CanonicalizeP();
7460 }
7461 // we are in a ring, do not call pNorm
7462 // test divisibility of coefs:
7463 poly p_Ln=Ln.GetLmCurrRing();
7464 poly p_With=With->GetLmCurrRing();
7465 if (n_DivBy(pGetCoeff(p_Ln),pGetCoeff(p_With), currRing->cf))
7466 {
7467 strat->redTailChange=TRUE;
7468
7469 if (ksReducePolyTail_Z(L, With, &Ln))
7470 {
7471 // reducing the tail would violate the exp bound
7472 // set a flag and hope for a retry (in bba)
7473 strat->completeReduce_retry=TRUE;
7474 if ((Ln.p != NULL) && (Ln.t_p != NULL)) Ln.p=NULL;
7475 do
7476 {
7477 pNext(h) = Ln.LmExtractAndIter();
7478 pIter(h);
7479 L->pLength++;
7480 } while (!Ln.IsNull());
7481 goto all_done;
7482 }
7483 }
7484 else break; /*proceed to next monomial*/
7485 if (Ln.IsNull()) goto all_done;
7486 }
7487 pNext(h) = Ln.LmExtractAndIter();
7488 pIter(h);
7489 pNormalize(h);
7490 L->pLength++;
7491 }
7492
7493 all_done:
7494 Ln.Delete();
7495 if (L->p != NULL) pNext(L->p) = pNext(p);
7496
7497 if (strat->redTailChange)
7498 {
7499 L->length = 0;
7500 }
7501
7502 //if (TEST_OPT_PROT) { PrintS("N"); mflush(); }
7503 //L->Normalize(); // HANNES: should have a test
7504 kTest_L(L,strat);
7505 return L->GetLmCurrRing();
7506}
ksReducePolyTail_Z
KINLINE int ksReducePolyTail_Z(LObject *PR, TObject *PW, LObject *Red)
Definition: kInline.h:1127

◆ redtailBba_Ring() [2/2]

KINLINE poly redtailBba_Ring ( poly  p,
int  end_pos,
kStrategy  strat 
)

Definition at line 1227 of file kInline.h.

1228{
1229 LObject L(p, currRing, strat->tailRing);
1230 return redtailBba_Ring(&L, pos, strat);
1231}

◆ redtailBba_Z() [1/2]

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

Definition at line 7317 of file kutil.cc.

7319{
7320 strat->redTailChange=FALSE;
7321 if (strat->noTailReduction) return L->GetLmCurrRing();
7322 poly h, p;
7323 p = h = L->GetLmTailRing();
7324 if ((h==NULL) || (pNext(h)==NULL))
7325 return L->GetLmCurrRing();
7326
7327 TObject* With;
7328 // placeholder in case strat->tl < 0
7329 TObject With_s(strat->tailRing);
7330
7331 LObject Ln(pNext(h), strat->tailRing);
7332 Ln.pLength = L->GetpLength() - 1;
7333
7334 pNext(h) = NULL;
7335 if (L->p != NULL) pNext(L->p) = NULL;
7336 L->pLength = 1;
7337
7338 Ln.PrepareRed(strat->use_buckets);
7339
7340 int cnt=REDTAIL_CANONICALIZE;
7341 while(!Ln.IsNull())
7342 {
7343 loop
7344 {
7345 Ln.SetShortExpVector();
7346 With = kFindDivisibleByInS_T(strat, end_pos, &Ln, &With_s);
7347 if (With == NULL) break;
7348 cnt--;
7349 if (cnt==0)
7350 {
7351 cnt=REDTAIL_CANONICALIZE;
7352 /*poly tmp=*/Ln.CanonicalizeP();
7353 }
7354 // we are in Z, do not call pNorm
7355 strat->redTailChange=TRUE;
7356 // test divisibility of coefs:
7357 poly p_Ln=Ln.GetLmCurrRing();
7358 poly p_With=With->GetLmCurrRing();
7359
7360 if (ksReducePolyTail_Z(L, With, &Ln))
7361 {
7362 // reducing the tail would violate the exp bound
7363 // set a flag and hope for a retry (in bba)
7364 strat->completeReduce_retry=TRUE;
7365 if ((Ln.p != NULL) && (Ln.t_p != NULL)) Ln.p=NULL;
7366 do
7367 {
7368 pNext(h) = Ln.LmExtractAndIter();
7369 pIter(h);
7370 L->pLength++;
7371 } while (!Ln.IsNull());
7372 goto all_done;
7373 }
7374 if (Ln.IsNull()) goto all_done;
7375 With_s.Init(currRing);
7376 }
7377 pNext(h) = Ln.LmExtractAndIter();
7378 pIter(h);
7379 pNormalize(h);
7380 L->pLength++;
7381 }
7382
7383 all_done:
7384 Ln.Delete();
7385 if (L->p != NULL) pNext(L->p) = pNext(p);
7386
7387 if (strat->redTailChange)
7388 {
7389 L->length = 0;
7390 }
7391
7392 //if (TEST_OPT_PROT) { PrintS("N"); mflush(); }
7393 //L->Normalize(); // HANNES: should have a test
7394 kTest_L(L,strat);
7395 return L->GetLmCurrRing();
7396}

◆ redtailBba_Z() [2/2]

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

Definition at line 1232 of file kInline.h.

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

◆ redtailBbaAlsoLC_Z()

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

Definition at line 7188 of file kutil.cc.

7190{
7191 strat->redTailChange=FALSE;
7192
7193 poly h, p;
7194 p = h = L->GetLmTailRing();
7195 if ((h==NULL) || (pNext(h)==NULL))
7196 return;
7197
7198 TObject* With;
7199 LObject Ln(pNext(h), strat->tailRing);
7200 Ln.GetpLength();
7201
7202 pNext(h) = NULL;
7203 if (L->p != NULL)
7204 {
7205 pNext(L->p) = NULL;
7206 if (L->t_p != NULL) pNext(L->t_p) = NULL;
7207 }
7208 L->pLength = 1;
7209
7210 Ln.PrepareRed(strat->use_buckets);
7211
7212 int cnt=REDTAIL_CANONICALIZE;
7213
7214 while(!Ln.IsNull())
7215 {
7216 loop
7217 {
7218 if (TEST_OPT_IDLIFT)
7219 {
7220 if (Ln.p!=NULL)
7221 {
7222 if (__p_GetComp(Ln.p,currRing)> strat->syzComp) break;
7223 }
7224 else
7225 {
7226 if (__p_GetComp(Ln.t_p,strat->tailRing)> strat->syzComp) break;
7227 }
7228 }
7229 Ln.SetShortExpVector();
7230 int j;
7231 j = kFindDivisibleByInT(strat, &Ln);
7232 if (j < 0)
7233 {
7234 j = kFindDivisibleByInT_Z(strat, &Ln);
7235 if (j < 0)
7236 {
7237 break;
7238 }
7239 else
7240 {
7241 /* reduction not cancelling a tail term, but reducing its coefficient */
7242 With = &(strat->T[j]);
7243 assume(With->GetpLength()==pLength(With->p != __null ? With->p : With->t_p));
7244 cnt--;
7245 if (cnt==0)
7246 {
7247 cnt=REDTAIL_CANONICALIZE;
7248 /*poly tmp=*/Ln.CanonicalizeP();
7249 }
7250 strat->redTailChange=TRUE;
7251 /* reduction cancelling a tail term */
7252 if (ksReducePolyTailLC_Z(L, With, &Ln))
7253 {
7254 // reducing the tail would violate the exp bound
7255 // set a flag and hope for a retry (in bba)
7256 strat->completeReduce_retry=TRUE;
7257 if ((Ln.p != NULL) && (Ln.t_p != NULL)) Ln.p=NULL;
7258 do
7259 {
7260 pNext(h) = Ln.LmExtractAndIter();
7261 pIter(h);
7262 L->pLength++;
7263 } while (!Ln.IsNull());
7264 goto all_done;
7265 }
7266 /* we have to break since we did not cancel the term, but only decreased
7267 * its coefficient. */
7268 break;
7269 }
7270 } else {
7271 With = &(strat->T[j]);
7272 assume(With->GetpLength()==pLength(With->p != __null ? With->p : With->t_p));
7273 cnt--;
7274 if (cnt==0)
7275 {
7276 cnt=REDTAIL_CANONICALIZE;
7277 /*poly tmp=*/Ln.CanonicalizeP();
7278 }
7279 strat->redTailChange=TRUE;
7280 /* reduction cancelling a tail term */
7281 if (ksReducePolyTail_Z(L, With, &Ln))
7282 {
7283 // reducing the tail would violate the exp bound
7284 // set a flag and hope for a retry (in bba)
7285 strat->completeReduce_retry=TRUE;
7286 if ((Ln.p != NULL) && (Ln.t_p != NULL)) Ln.p=NULL;
7287 do
7288 {
7289 pNext(h) = Ln.LmExtractAndIter();
7290 pIter(h);
7291 L->pLength++;
7292 } while (!Ln.IsNull());
7293 goto all_done;
7294 }
7295 }
7296 if (Ln.IsNull()) goto all_done;
7297 }
7298 pNext(h) = Ln.LmExtractAndIter();
7299 pIter(h);
7300 L->pLength++;
7301 }
7302
7303 all_done:
7304 Ln.Delete();
7305 if (L->p != NULL) pNext(L->p) = pNext(p);
7306
7307 if (strat->redTailChange)
7308 {
7309 L->length = 0;
7310 L->pLength = 0;
7311 }
7312
7313 kTest_L(L, strat);
7314 return;
7315}
ksReducePolyTailLC_Z
KINLINE int ksReducePolyTailLC_Z(LObject *PR, TObject *PW, LObject *Red)
Definition: kInline.h:1109

◆ redtailBbaBound() [1/2]

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

Definition at line 7072 of file kutil.cc.

7073{
7074 strat->redTailChange=FALSE;
7075 if (strat->noTailReduction) return L->GetLmCurrRing();
7076 poly h, p;
7077 p = h = L->GetLmTailRing();
7078 if ((h==NULL) || (pNext(h)==NULL))
7079 return L->GetLmCurrRing();
7080
7081 TObject* With;
7082 // placeholder in case strat->tl < 0
7083 TObject With_s(strat->tailRing);
7084
7085 LObject Ln(pNext(h), strat->tailRing);
7086 Ln.pLength = L->GetpLength() - 1;
7087
7088 pNext(h) = NULL;
7089 if (L->p != NULL) pNext(L->p) = NULL;
7090 L->pLength = 1;
7091
7092 Ln.PrepareRed(strat->use_buckets);
7093
7094 int cnt=REDTAIL_CANONICALIZE;
7095 while(!Ln.IsNull())
7096 {
7097 loop
7098 {
7099 if (TEST_OPT_IDLIFT)
7100 {
7101 if (Ln.p!=NULL)
7102 {
7103 if (__p_GetComp(Ln.p,currRing)> strat->syzComp) break;
7104 }
7105 else
7106 {
7107 if (__p_GetComp(Ln.t_p,strat->tailRing)> strat->syzComp) break;
7108 }
7109 }
7110 Ln.SetShortExpVector();
7111 if (withT)
7112 {
7113 int j;
7114 j = kFindDivisibleByInT(strat, &Ln);
7115 if (j < 0) break;
7116 With = &(strat->T[j]);
7117 }
7118 else
7119 {
7120 With = kFindDivisibleByInS_T(strat, end_pos, &Ln, &With_s);
7121 if (With == NULL) break;
7122 }
7123 cnt--;
7124 if (cnt==0)
7125 {
7126 cnt=REDTAIL_CANONICALIZE;
7127 /*poly tmp=*/Ln.CanonicalizeP();
7128 if (normalize)
7129 {
7130 Ln.Normalize();
7131 //pNormalize(tmp);
7132 //if (TEST_OPT_PROT) { PrintS("n"); mflush(); }
7133 }
7134 }
7135 if (normalize && (!TEST_OPT_INTSTRATEGY) && (!nIsOne(pGetCoeff(With->p))))
7136 {
7137 With->pNorm();
7138 }
7139 strat->redTailChange=TRUE;
7140 if (ksReducePolyTail(L, With, &Ln))
7141 {
7142 // reducing the tail would violate the exp bound
7143 // set a flag and hope for a retry (in bba)
7144 strat->completeReduce_retry=TRUE;
7145 if ((Ln.p != NULL) && (Ln.t_p != NULL)) Ln.p=NULL;
7146 do
7147 {
7148 pNext(h) = Ln.LmExtractAndIter();
7149 pIter(h);
7150 L->pLength++;
7151 } while (!Ln.IsNull());
7152 goto all_done;
7153 }
7154 if(!Ln.IsNull())
7155 {
7156 Ln.GetP();
7157 Ln.p = pJet(Ln.p,bound);
7158 }
7159 if (Ln.IsNull())
7160 {
7161 goto all_done;
7162 }
7163 if (! withT) With_s.Init(currRing);
7164 }
7165 pNext(h) = Ln.LmExtractAndIter();
7166 pIter(h);
7167 pNormalize(h);
7168 L->pLength++;
7169 }
7170
7171 all_done:
7172 Ln.Delete();
7173 if (L->p != NULL) pNext(L->p) = pNext(p);
7174
7175 if (strat->redTailChange)
7176 {
7177 L->length = 0;
7178 L->pLength = 0;
7179 }
7180
7181 //if (TEST_OPT_PROT) { PrintS("N"); mflush(); }
7182 //L->Normalize(); // HANNES: should have a test
7183 kTest_L(L,strat);
7184 return L->GetLmCurrRing();
7185}
pJet
#define pJet(p, m)
Definition: polys.h:367

◆ redtailBbaBound() [2/2]

KINLINE poly redtailBbaBound ( poly  p,
int  end_pos,
kStrategy  strat,
int  bound,
BOOLEAN  normalize = FALSE 
)

Definition at line 1220 of file kInline.h.

1221{
1222 LObject L(p, currRing, strat->tailRing); // ? L(p); ??
1223 return redtailBbaBound(&L, pos, strat,bound, FALSE, normalize);
1224}

◆ redtailBbaShift()

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

Definition at line 13081 of file kutil.cc.

13082{
13083 /* for the shift case need to run it with withT = TRUE */
13084 strat->redTailChange=FALSE;
13085 if (strat->noTailReduction) return L->GetLmCurrRing();
13086 poly h, p;
13087 p = h = L->GetLmTailRing();
13088 if ((h==NULL) || (pNext(h)==NULL))
13089 return L->GetLmCurrRing();
13090
13091 TObject* With;
13092 // placeholder in case strat->tl < 0
13093 TObject With_s(strat->tailRing);
13094
13095 LObject Ln(pNext(h), strat->tailRing);
13096 Ln.pLength = L->GetpLength() - 1;
13097
13098 pNext(h) = NULL;
13099 if (L->p != NULL) pNext(L->p) = NULL;
13100 L->pLength = 1;
13101
13102 Ln.PrepareRed(strat->use_buckets);
13103
13104 while(!Ln.IsNull())
13105 {
13106 loop
13107 {
13108 Ln.SetShortExpVector();
13109 if (withT)
13110 {
13111 int j;
13112 j = kFindDivisibleByInT(strat, &Ln);
13113 if (j < 0) break;
13114 With = &(strat->T[j]);
13115 }
13116 else
13117 {
13118 With = kFindDivisibleByInS_T(strat, pos, &Ln, &With_s);
13119 if (With == NULL) break;
13120 }
13121 if (normalize && (!TEST_OPT_INTSTRATEGY) && (!nIsOne(pGetCoeff(With->p))))
13122 {
13123 With->pNorm();
13124 //if (TEST_OPT_PROT) { PrintS("n"); mflush(); }
13125 }
13126 strat->redTailChange=TRUE;
13127 if (ksReducePolyTail(L, With, &Ln))
13128 {
13129 // reducing the tail would violate the exp bound
13130 // set a flag and hope for a retry (in bba)
13131 strat->completeReduce_retry=TRUE;
13132 if ((Ln.p != NULL) && (Ln.t_p != NULL)) Ln.p=NULL;
13133 do
13134 {
13135 pNext(h) = Ln.LmExtractAndIter();
13136 pIter(h);
13137 L->pLength++;
13138 } while (!Ln.IsNull());
13139 goto all_done;
13140 }
13141 if (Ln.IsNull()) goto all_done;
13142 if (! withT) With_s.Init(currRing);
13143 }
13144 pNext(h) = Ln.LmExtractAndIter();
13145 pIter(h);
13146 L->pLength++;
13147 }
13148
13149 all_done:
13150 Ln.Delete();
13151 if (L->p != NULL) pNext(L->p) = pNext(p);
13152
13153 if (strat->redTailChange)
13154 {
13155 L->length = 0;
13156 }
13157 L->Normalize(); // HANNES: should have a test
13158 kTest_L(L,strat);
13159 return L->GetLmCurrRing();
13160}

◆ redtailSba()

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

Definition at line 1761 of file kstd2.cc.

1762{
1763 strat->redTailChange=FALSE;
1764 if (strat->noTailReduction) return L->GetLmCurrRing();
1765 poly h, p;
1766 p = h = L->GetLmTailRing();
1767 if ((h==NULL) || (pNext(h)==NULL))
1768 return L->GetLmCurrRing();
1769
1770 TObject* With;
1771 // placeholder in case strat->tl < 0
1772 TObject With_s(strat->tailRing);
1773
1774 LObject Ln(pNext(h), strat->tailRing);
1775 Ln.sig = L->sig;
1776 Ln.sevSig = L->sevSig;
1777 Ln.pLength = L->GetpLength() - 1;
1778
1779 pNext(h) = NULL;
1780 if (L->p != NULL) pNext(L->p) = NULL;
1781 L->pLength = 1;
1782
1783 Ln.PrepareRed(strat->use_buckets);
1784
1785 int cnt=REDTAIL_CANONICALIZE;
1786 while(!Ln.IsNull())
1787 {
1788 loop
1789 {
1790 if(rField_is_Ring(currRing) && strat->sigdrop)
1791 break;
1792 Ln.SetShortExpVector();
1793 if (withT)
1794 {
1795 int j;
1796 j = kFindDivisibleByInT(strat, &Ln);
1797 if (j < 0) break;
1798 With = &(strat->T[j]);
1799 }
1800 else
1801 {
1802 With = kFindDivisibleByInS_T(strat, pos, &Ln, &With_s);
1803 if (With == NULL) break;
1804 }
1805 cnt--;
1806 if (cnt==0)
1807 {
1808 cnt=REDTAIL_CANONICALIZE;
1809 /*poly tmp=*/Ln.CanonicalizeP();
1810 if (normalize && !rField_is_Ring(currRing))
1811 {
1812 Ln.Normalize();
1813 //pNormalize(tmp);
1814 //if (TEST_OPT_PROT) { PrintS("n"); mflush(); }
1815 }
1816 }
1817 if (normalize && (!TEST_OPT_INTSTRATEGY) && !rField_is_Ring(currRing) && (!nIsOne(pGetCoeff(With->p))))
1818 {
1819 With->pNorm();
1820 }
1821 strat->redTailChange=TRUE;
1822 int ret = ksReducePolyTailSig(L, With, &Ln, strat);
1823 if(rField_is_Ring(currRing))
1824 L->sig = Ln.sig;
1825 //Because Ln.sig is set to L->sig, but in ksReducePolyTailSig -> ksReducePolySig
1826 // I delete it an then set Ln.sig. Hence L->sig is lost
1827#if SBA_PRINT_REDUCTION_STEPS
1828 if (ret != 3)
1829 sba_reduction_steps++;
1830#endif
1831#if SBA_PRINT_OPERATIONS
1832 if (ret != 3)
1833 sba_operations += pLength(With->p);
1834#endif
1835 if (ret)
1836 {
1837 // reducing the tail would violate the exp bound
1838 // set a flag and hope for a retry (in bba)
1839 strat->completeReduce_retry=TRUE;
1840 if ((Ln.p != NULL) && (Ln.t_p != NULL)) Ln.p=NULL;
1841 do
1842 {
1843 pNext(h) = Ln.LmExtractAndIter();
1844 pIter(h);
1845 L->pLength++;
1846 } while (!Ln.IsNull());
1847 goto all_done;
1848 }
1849 if (Ln.IsNull()) goto all_done;
1850 if (! withT) With_s.Init(currRing);
1851 if(rField_is_Ring(currRing) && strat->sigdrop)
1852 {
1853 //Cannot break the loop here so easily
1854 break;
1855 }
1856 }
1857 pNext(h) = Ln.LmExtractAndIter();
1858 pIter(h);
1859 if(!rField_is_Ring(currRing))
1860 pNormalize(h);
1861 L->pLength++;
1862 }
1863 all_done:
1864 Ln.Delete();
1865 if (L->p != NULL) pNext(L->p) = pNext(p);
1866
1867 if (strat->redTailChange)
1868 {
1869 L->length = 0;
1870 }
1871 //if (TEST_OPT_PROT) { PrintS("N"); mflush(); }
1872 //L->Normalize(); // HANNES: should have a test
1873 kTest_L(L,strat);
1874 return L->GetLmCurrRing();
1875}
ksReducePolyTailSig
KINLINE int ksReducePolyTailSig(LObject *PR, TObject *PW, LObject *Red, kStrategy strat)
Definition: kstd2.cc:1305

◆ reorderS()

void reorderS ( int *  suc,
kStrategy  strat 
)

Definition at line 4632 of file kutil.cc.

4633{
4634 int i,j,at,ecart, s2r;
4635 int fq=0;
4636 unsigned long sev;
4637 poly p;
4638 int new_suc=strat->sl+1;
4639 i= *suc;
4640 if (i<0) i=0;
4641
4642 for (; i<=strat->sl; i++)
4643 {
4644 at = posInS(strat,i-1,strat->S[i],strat->ecartS[i]);
4645 if (at != i)
4646 {
4647 if (new_suc > at) new_suc = at;
4648 p = strat->S[i];
4649 ecart = strat->ecartS[i];
4650 sev = strat->sevS[i];
4651 s2r = strat->S_2_R[i];
4652 if (strat->fromQ!=NULL) fq=strat->fromQ[i];
4653 for (j=i; j>=at+1; j--)
4654 {
4655 strat->S[j] = strat->S[j-1];
4656 strat->ecartS[j] = strat->ecartS[j-1];
4657 strat->sevS[j] = strat->sevS[j-1];
4658 strat->S_2_R[j] = strat->S_2_R[j-1];
4659 }
4660 strat->S[at] = p;
4661 strat->ecartS[at] = ecart;
4662 strat->sevS[at] = sev;
4663 strat->S_2_R[at] = s2r;
4664 if (strat->fromQ!=NULL)
4665 {
4666 for (j=i; j>=at+1; j--)
4667 {
4668 strat->fromQ[j] = strat->fromQ[j-1];
4669 }
4670 strat->fromQ[at]=fq;
4671 }
4672 }
4673 }
4674 if (new_suc <= strat->sl) *suc=new_suc;
4675 else *suc=-1;
4676}

◆ replaceInLAndSAndT()

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

Definition at line 9087 of file kutil.cc.

9088{
9089 p.GetP(strat->lmBin);
9090 if (strat->homog) strat->initEcart(&p);
9091 strat->redTailChange=FALSE;
9092 if (TEST_OPT_INTSTRATEGY)
9093 {
9094 p.pCleardenom();
9095 if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
9096 {
9097#ifdef HAVE_SHIFTBBA
9098 if (rIsLPRing(currRing))
9099 p.p = redtailBba(&p,strat->tl,strat, TRUE,!TEST_OPT_CONTENTSB);
9100 else
9101#endif
9102 {
9103 p.p = redtailBba(&p,strat->sl,strat, FALSE,!TEST_OPT_CONTENTSB);
9104 }
9105 p.pCleardenom();
9106 if (strat->redTailChange)
9107 p.t_p=NULL;
9108 if (strat->P.p!=NULL) strat->P.sev=p_GetShortExpVector(strat->P.p,currRing);
9109 else strat->P.sev=0;
9110 }
9111 }
9112
9113 assume(strat->tailRing == p.tailRing);
9114 assume(p.pLength == 0 || pLength(p.p) == p.pLength || rIsSyzIndexRing(currRing)); // modulo syzring
9115
9116 int i, j, pos;
9117 poly tp = strat->T[tj].p;
9118
9119 /* enter p to T set */
9120 enterT(p, strat);
9121
9122 for (j = 0; j <= strat->sl; ++j)
9123 {
9124 if (pLtCmp(tp, strat->S[j]) == 0)
9125 {
9126 break;
9127 }
9128 }
9129 /* it may be that the exchanged element
9130 * is until now only in T and not in S */
9131 if (j <= strat->sl)
9132 {
9133 deleteInS(j, strat);
9134 }
9135
9136 pos = posInS(strat, strat->sl, p.p, p.ecart);
9137
9138 pp_Test(p.p, currRing, p.tailRing);
9139 assume(p.FDeg == p.pFDeg());
9140
9141 /* remove useless pairs from L set */
9142 for (i = 0; i <= strat->Ll; ++i)
9143 {
9144 if (strat->L[i].p1 != NULL && pLtCmp(tp, strat->L[i].p1) == 0)
9145 {
9146 deleteInL(strat->L, &(strat->Ll), i, strat);
9147 i--;
9148 continue;
9149 }
9150 if (strat->L[i].p2 != NULL && pLtCmp(tp, strat->L[i].p2) == 0)
9151 {
9152 deleteInL(strat->L, &(strat->Ll), i, strat);
9153 i--;
9154 }
9155 }
9156#ifdef HAVE_SHIFTBBA
9157 if (rIsLPRing(currRing))
9158 enterpairsShift(p.p, strat->sl, p.ecart, pos, strat, strat->tl); // TODO LP
9159 else
9160#endif
9161 {
9162 /* generate new pairs with p, probably removing older, now useless pairs */
9163 superenterpairs(p.p, strat->sl, p.ecart, pos, strat, strat->tl);
9164 }
9165 /* enter p to S set */
9166 strat->enterS(p, pos, strat, strat->tl);
9167
9168#ifdef HAVE_SHIFTBBA
9169 /* do this after enterS so that the index in R (which is strat->tl) is correct */
9170 if (rIsLPRing(currRing) && !strat->rightGB)
9171 enterTShift(p,strat);
9172#endif
9173}

◆ sba()

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

Definition at line 3001 of file kstd2.cc.

3002{
3003 // ring order stuff:
3004 // in sba we have (until now) two possibilities:
3005 // 1. an incremental computation w.r.t. (C,monomial order)
3006 // 2. a (possibly non-incremental) computation w.r.t. the
3007 // induced Schreyer order.
3008 // The corresponding orders are computed in sbaRing(), depending
3009 // on the flag strat->sbaOrder
3010#if SBA_PRINT_ZERO_REDUCTIONS
3011 long zeroreductions = 0;
3012#endif
3013#if SBA_PRINT_PRODUCT_CRITERION
3014 long product_criterion = 0;
3015#endif
3016#if SBA_PRINT_SIZE_G
3017 int size_g = 0;
3018 int size_g_non_red = 0;
3019#endif
3020#if SBA_PRINT_SIZE_SYZ
3021 long size_syz = 0;
3022#endif
3023 // global variable
3024#if SBA_PRINT_REDUCTION_STEPS
3025 sba_reduction_steps = 0;
3026 sba_interreduction_steps = 0;
3027#endif
3028#if SBA_PRINT_OPERATIONS
3029 sba_operations = 0;
3030 sba_interreduction_operations = 0;
3031#endif
3032
3033 ideal F1 = F0;
3034 ring sRing, currRingOld;
3035 currRingOld = currRing;
3036 if (strat->sbaOrder == 1 || strat->sbaOrder == 3)
3037 {
3038 sRing = sbaRing(strat);
3039 if (sRing!=currRingOld)
3040 {
3041 rChangeCurrRing (sRing);
3042 F1 = idrMoveR (F0, currRingOld, currRing);
3043 }
3044 }
3045 ideal F;
3046 // sort ideal F
3047 //Put the SigDrop element on the correct position (think of sbaEnterS)
3048 //We also sort them
3049 if(rField_is_Ring(currRing) && strat->sigdrop)
3050 {
3051 #if 1
3052 F = idInit(IDELEMS(F1),F1->rank);
3053 for (int i=0; i<IDELEMS(F1);++i)
3054 F->m[i] = F1->m[i];
3055 if(strat->sbaEnterS >= 0)
3056 {
3057 poly dummy;
3058 dummy = pCopy(F->m[0]); //the sigdrop element
3059 for(int i = 0;i<strat->sbaEnterS;i++)
3060 F->m[i] = F->m[i+1];
3061 F->m[strat->sbaEnterS] = dummy;
3062 }
3063 #else
3064 F = idInit(1,F1->rank);
3065 //printf("\nBefore the initial block sorting:\n");idPrint(F1);
3066 F->m[0] = F1->m[0];
3067 int pos;
3068 if(strat->sbaEnterS >= 0)
3069 {
3070 for(int i=1;i<=strat->sbaEnterS;i++)
3071 {
3072 pos = posInIdealMonFirst(F,F1->m[i],1,strat->sbaEnterS);
3073 idInsertPolyOnPos(F,F1->m[i],pos);
3074 }
3075 for(int i=strat->sbaEnterS+1;i<IDELEMS(F1);i++)
3076 {
3077 pos = posInIdealMonFirst(F,F1->m[i],strat->sbaEnterS+1,IDELEMS(F));
3078 idInsertPolyOnPos(F,F1->m[i],pos);
3079 }
3080 poly dummy;
3081 dummy = pCopy(F->m[0]); //the sigdrop element
3082 for(int i = 0;i<strat->sbaEnterS;i++)
3083 F->m[i] = F->m[i+1];
3084 F->m[strat->sbaEnterS] = dummy;
3085 }
3086 else
3087 {
3088 for(int i=1;i<IDELEMS(F1);i++)
3089 {
3090 pos = posInIdealMonFirst(F,F1->m[i],1,IDELEMS(F));
3091 idInsertPolyOnPos(F,F1->m[i],pos);
3092 }
3093 }
3094 #endif
3095 //printf("\nAfter the initial block sorting:\n");idPrint(F);getchar();
3096 }
3097 else
3098 {
3099 F = idInit(IDELEMS(F1),F1->rank);
3100 intvec *sort = idSort(F1);
3101 for (int i=0; i<sort->length();++i)
3102 F->m[i] = F1->m[(*sort)[i]-1];
3103 if(rField_is_Ring(currRing))
3104 {
3105 // put the monomials after the sbaEnterS polynomials
3106 //printf("\nThis is the ideal before sorting (sbaEnterS = %i)\n",strat->sbaEnterS);idPrint(F);
3107 int nrmon = 0;
3108 for(int i = IDELEMS(F)-1,j;i>strat->sbaEnterS+nrmon+1 ;i--)
3109 {
3110 //pWrite(F->m[i]);
3111 if(F->m[i] != NULL && pNext(F->m[i]) == NULL)
3112 {
3113 poly mon = F->m[i];
3114 for(j = i;j>strat->sbaEnterS+nrmon+1;j--)
3115 {
3116 F->m[j] = F->m[j-1];
3117 }
3118 F->m[j] = mon;
3119 nrmon++;
3120 }
3121 //idPrint(F);
3122 }
3123 }
3124 }
3125 //printf("\nThis is the ideal after sorting\n");idPrint(F);getchar();
3126 if(rField_is_Ring(currRing))
3127 strat->sigdrop = FALSE;
3128 strat->nrsyzcrit = 0;
3129 strat->nrrewcrit = 0;
3130#if SBA_INTERRED_START
3131 F = kInterRed(F,NULL);
3132#endif
3133#if F5DEBUG
3134 printf("SBA COMPUTATIONS DONE IN THE FOLLOWING RING:\n");
3135 rWrite (currRing);
3136 printf("ordSgn = %d\n",currRing->OrdSgn);
3137 printf("\n");
3138#endif
3139 int srmax,lrmax, red_result = 1;
3140 int olddeg,reduc;
3141 int hilbeledeg=1,hilbcount=0,minimcnt=0;
3142 LObject L;
3143 BOOLEAN withT = TRUE;
3144 strat->max_lower_index = 0;
3145 //initBuchMoraCrit(strat); /*set Gebauer, honey, sugarCrit*/
3146 initSbaCrit(strat); /*set Gebauer, honey, sugarCrit*/
3147 initSbaPos(strat);
3148 initHilbCrit(F,Q,&hilb,strat);
3149 initSba(F,strat);
3150 /*set enterS, spSpolyShort, reduce, red, initEcart, initEcartPair*/
3151 /*Shdl=*/initSbaBuchMora(F, Q,strat);
3152 idTest(strat->Shdl);
3153 if (strat->minim>0) strat->M=idInit(IDELEMS(F),F->rank);
3154 srmax = strat->sl;
3155 reduc = olddeg = lrmax = 0;
3156#ifndef NO_BUCKETS
3157 if (!TEST_OPT_NOT_BUCKETS)
3158 strat->use_buckets = 1;
3159#endif
3160
3161 // redtailBBa against T for inhomogeneous input
3162 // if (!TEST_OPT_OLDSTD)
3163 // withT = ! strat->homog;
3164
3165 // strat->posInT = posInT_pLength;
3166 kTest_TS(strat);
3167
3168#ifdef HAVE_TAIL_RING
3169 if(!idIs0(F) &&(!rField_is_Ring(currRing))) // create strong gcd poly computes with tailring and S[i] ->to be fixed
3170 kStratInitChangeTailRing(strat);
3171#endif
3172 if (BVERBOSE(23))
3173 {
3174 if (test_PosInT!=NULL) strat->posInT=test_PosInT;
3175 if (test_PosInL!=NULL) strat->posInL=test_PosInL;
3176 kDebugPrint(strat);
3177 }
3178 // We add the elements directly in S from the previous loop
3179 if(rField_is_Ring(currRing) && strat->sbaEnterS >= 0)
3180 {
3181 for(int i = 0;i<strat->sbaEnterS;i++)
3182 {
3183 //Update: now the element is at the correct place
3184 //i+1 because on the 0 position is the sigdrop element
3185 enterT(strat->L[strat->Ll-(i)],strat);
3186 strat->enterS(strat->L[strat->Ll-(i)], strat->sl+1, strat, strat->tl);
3187 }
3188 strat->Ll = strat->Ll - strat->sbaEnterS;
3189 strat->sbaEnterS = -1;
3190 }
3191 kTest_TS(strat);
3192#ifdef KDEBUG
3193 //kDebugPrint(strat);
3194#endif
3195 /* compute------------------------------------------------------- */
3196 while (strat->Ll >= 0)
3197 {
3198 if (strat->Ll > lrmax) lrmax =strat->Ll;/*stat.*/
3199 #ifdef KDEBUG
3200 if (TEST_OPT_DEBUG) messageSets(strat);
3201 #endif
3202 if (strat->Ll== 0) strat->interpt=TRUE;
3203 /*
3204 if (TEST_OPT_DEGBOUND
3205 && ((strat->honey && (strat->L[strat->Ll].ecart+currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg))
3206 || ((!strat->honey) && (currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg))))
3207 {
3208
3209 //stops computation if
3210 // 24 IN test and the degree +ecart of L[strat->Ll] is bigger then
3211 //a predefined number Kstd1_deg
3212 while ((strat->Ll >= 0)
3213 && (strat->L[strat->Ll].p1!=NULL) && (strat->L[strat->Ll].p2!=NULL)
3214 && ((strat->honey && (strat->L[strat->Ll].ecart+currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg))
3215 || ((!strat->honey) && (currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg)))
3216 )
3217 deleteInL(strat->L,&strat->Ll,strat->Ll,strat);
3218 if (strat->Ll<0) break;
3219 else strat->noClearS=TRUE;
3220 }
3221 */
3222 if (strat->sbaOrder == 1 && pGetComp(strat->L[strat->Ll].sig) != strat->currIdx)
3223 {
3224 strat->currIdx = pGetComp(strat->L[strat->Ll].sig);
3225#if F5C
3226 // 1. interreduction of the current standard basis
3227 // 2. generation of new principal syzygy rules for syzCriterion
3228 f5c ( strat, olddeg, minimcnt, hilbeledeg, hilbcount, srmax,
3229 lrmax, reduc, Q, w, hilb );
3230#endif
3231 // initialize new syzygy rules for the next iteration step
3232 initSyzRules(strat);
3233 }
3234 /*********************************************************************
3235 * interrreduction step is done, we can go on with the next iteration
3236 * step of the signature-based algorithm
3237 ********************************************************************/
3238 /* picks the last element from the lazyset L */
3239 strat->P = strat->L[strat->Ll];
3240 strat->Ll--;
3241
3242 if(rField_is_Ring(currRing))
3243 strat->sbaEnterS = pGetComp(strat->P.sig) - 1;
3244 /* reduction of the element chosen from L */
3245 if (!strat->rewCrit2(strat->P.sig, ~strat->P.sevSig, strat->P.GetLmCurrRing(), strat, strat->P.checked+1))
3246 {
3247 //#if 1
3248#ifdef DEBUGF5
3249 PrintS("SIG OF NEXT PAIR TO HANDLE IN SIG-BASED ALGORITHM\n");
3250 PrintS("-------------------------------------------------\n");
3251 pWrite(strat->P.sig);
3252 pWrite(pHead(strat->P.p));
3253 pWrite(pHead(strat->P.p1));
3254 pWrite(pHead(strat->P.p2));
3255 PrintS("-------------------------------------------------\n");
3256#endif
3257 if (pNext(strat->P.p) == strat->tail)
3258 {
3259 // deletes the short spoly
3260 /*
3261 if (rField_is_Ring(currRing))
3262 pLmDelete(strat->P.p);
3263 else
3264 pLmFree(strat->P.p);
3265*/
3266 // TODO: needs some masking
3267 // TODO: masking needs to vanish once the signature
3268 // sutff is completely implemented
3269 strat->P.p = NULL;
3270 poly m1 = NULL, m2 = NULL;
3271
3272 // check that spoly creation is ok
3273 while (strat->tailRing != currRing &&
3274 !kCheckSpolyCreation(&(strat->P), strat, m1, m2))
3275 {
3276 assume(m1 == NULL && m2 == NULL);
3277 // if not, change to a ring where exponents are at least
3278 // large enough
3279 if (!kStratChangeTailRing(strat))
3280 {
3281 WerrorS("OVERFLOW...");
3282 break;
3283 }
3284 }
3285 // create the real one
3286 ksCreateSpoly(&(strat->P), NULL, strat->use_buckets,
3287 strat->tailRing, m1, m2, strat->R);
3288
3289 }
3290 else if (strat->P.p1 == NULL)
3291 {
3292 if (strat->minim > 0)
3293 strat->P.p2=p_Copy(strat->P.p, currRing, strat->tailRing);
3294 // for input polys, prepare reduction
3295 if(!rField_is_Ring(currRing))
3296 strat->P.PrepareRed(strat->use_buckets);
3297 }
3298 if (strat->P.p == NULL && strat->P.t_p == NULL)
3299 {
3300 red_result = 0;
3301 }
3302 else
3303 {
3304 //#if 1
3305#ifdef DEBUGF5
3306 PrintS("Poly before red: ");
3307 pWrite(pHead(strat->P.p));
3308 pWrite(strat->P.sig);
3309#endif
3310#if SBA_PRODUCT_CRITERION
3311 if (strat->P.prod_crit)
3312 {
3313#if SBA_PRINT_PRODUCT_CRITERION
3314 product_criterion++;
3315#endif
3316 int pos = posInSyz(strat, strat->P.sig);
3317 enterSyz(strat->P, strat, pos);
3318 kDeleteLcm(&strat->P);
3319 red_result = 2;
3320 }
3321 else
3322 {
3323 red_result = strat->red(&strat->P,strat);
3324 }
3325#else
3326 red_result = strat->red(&strat->P,strat);
3327#endif
3328 }
3329 }
3330 else
3331 {
3332 /*
3333 if (strat->P.lcm != NULL)
3334 pLmFree(strat->P.lcm);
3335 */
3336 red_result = 2;
3337 }
3338 if(rField_is_Ring(currRing))
3339 {
3340 if(strat->P.sig!= NULL && !nGreaterZero(pGetCoeff(strat->P.sig)))
3341 {
3342 strat->P.p = pNeg(strat->P.p);
3343 strat->P.sig = pNeg(strat->P.sig);
3344 }
3345 strat->P.pLength = pLength(strat->P.p);
3346 if(strat->P.sig != NULL)
3347 strat->P.sevSig = pGetShortExpVector(strat->P.sig);
3348 if(strat->P.p != NULL)
3349 strat->P.sev = pGetShortExpVector(strat->P.p);
3350 }
3351 //sigdrop case
3352 if(rField_is_Ring(currRing) && strat->sigdrop)
3353 {
3354 //First reduce it as much as one can
3355 red_result = redRing(&strat->P,strat);
3356 if(red_result == 0)
3357 {
3358 strat->sigdrop = FALSE;
3359 pDelete(&strat->P.sig);
3360 strat->P.sig = NULL;
3361 }
3362 else
3363 {
3364 strat->enterS(strat->P, 0, strat, strat->tl);
3365 if (TEST_OPT_PROT)
3366 PrintS("-");
3367 break;
3368 }
3369 }
3370 if(rField_is_Ring(currRing) && strat->blockred > strat->blockredmax)
3371 {
3372 strat->sigdrop = TRUE;
3373 break;
3374 }
3375
3376 if (errorreported) break;
3377
3378//#if 1
3379#ifdef DEBUGF5
3380 if (red_result != 0)
3381 {
3382 PrintS("Poly after red: ");
3383 pWrite(pHead(strat->P.p));
3384 pWrite(strat->P.GetLmCurrRing());
3385 pWrite(strat->P.sig);
3386 printf("%d\n",red_result);
3387 }
3388#endif
3389 if (TEST_OPT_PROT)
3390 {
3391 if(strat->P.p != NULL)
3392 message((strat->honey ? strat->P.ecart : 0) + strat->P.pFDeg(),
3393 &olddeg,&reduc,strat, red_result);
3394 else
3395 message((strat->honey ? strat->P.ecart : 0),
3396 &olddeg,&reduc,strat, red_result);
3397 }
3398
3399 if (strat->overflow)
3400 {
3401 if (!kStratChangeTailRing(strat)) { WerrorS("OVERFLOW.."); break;}
3402 }
3403 // reduction to non-zero new poly
3404 if (red_result == 1)
3405 {
3406 // get the polynomial (canonicalize bucket, make sure P.p is set)
3407 strat->P.GetP(strat->lmBin);
3408
3409 // sig-safe computations may lead to wrong FDeg computation, thus we need
3410 // to recompute it to make sure everything is alright
3411 (strat->P).FDeg = (strat->P).pFDeg();
3412 // in the homogeneous case FDeg >= pFDeg (sugar/honey)
3413 // but now, for entering S, T, we reset it
3414 // in the inhomogeneous case: FDeg == pFDeg
3415 if (strat->homog) strat->initEcart(&(strat->P));
3416
3417 /* statistic */
3418 if (TEST_OPT_PROT) PrintS("s");
3419
3420 //int pos=posInS(strat,strat->sl,strat->P.p,strat->P.ecart);
3421 // in F5E we know that the last reduced element is already the
3422 // the one with highest signature
3423 int pos = strat->sl+1;
3424
3425 // reduce the tail and normalize poly
3426 // in the ring case we cannot expect LC(f) = 1,
3427 #ifdef HAVE_RINGS
3428 poly beforetailred;
3429 if(rField_is_Ring(currRing))
3430 beforetailred = pCopy(strat->P.sig);
3431 #endif
3432#if SBA_TAIL_RED
3433 if(rField_is_Ring(currRing))
3434 {
3435 if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
3436 strat->P.p = redtailSba(&(strat->P),pos-1,strat, withT);
3437 }
3438 else
3439 {
3440 if (strat->sbaOrder != 2)
3441 {
3442 if (TEST_OPT_INTSTRATEGY)
3443 {
3444 strat->P.pCleardenom();
3445 if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
3446 {
3447 strat->P.p = redtailSba(&(strat->P),pos-1,strat, withT);
3448 strat->P.pCleardenom();
3449 }
3450 }
3451 else
3452 {
3453 strat->P.pNorm();
3454 if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
3455 strat->P.p = redtailSba(&(strat->P),pos-1,strat, withT);
3456 }
3457 }
3458 }
3459 // It may happen that we have lost the sig in redtailsba
3460 // It cannot reduce to 0 since here we are doing just tail reduction.
3461 // Best case scenerio: remains the leading term
3462 if(rField_is_Ring(currRing) && strat->sigdrop)
3463 {
3464 strat->enterS(strat->P, 0, strat, strat->tl);
3465 break;
3466 }
3467#endif
3468 if(rField_is_Ring(currRing))
3469 {
3470 if(strat->P.sig == NULL || pLtCmp(beforetailred,strat->P.sig) == 1)
3471 {
3472 strat->sigdrop = TRUE;
3473 //Reduce it as much as you can
3474 red_result = redRing(&strat->P,strat);
3475 if(red_result == 0)
3476 {
3477 //It reduced to 0, cancel the sigdrop
3478 strat->sigdrop = FALSE;
3479 p_Delete(&strat->P.sig,currRing);strat->P.sig = NULL;
3480 }
3481 else
3482 {
3483 strat->enterS(strat->P, 0, strat, strat->tl);
3484 break;
3485 }
3486 }
3487 p_Delete(&beforetailred,currRing);
3488 // strat->P.p = NULL may appear if we had a sigdrop above and reduced to 0 via redRing
3489 if(strat->P.p == NULL)
3490 goto case_when_red_result_changed;
3491 }
3492 // remove sigsafe label since it is no longer valid for the next element to
3493 // be reduced
3494 if (strat->sbaOrder == 1)
3495 {
3496 for (int jj = 0; jj<strat->tl+1; jj++)
3497 {
3498 if (pGetComp(strat->T[jj].sig) == strat->currIdx)
3499 {
3500 strat->T[jj].is_sigsafe = FALSE;
3501 }
3502 }
3503 }
3504 else
3505 {
3506 for (int jj = 0; jj<strat->tl+1; jj++)
3507 {
3508 strat->T[jj].is_sigsafe = FALSE;
3509 }
3510 }
3511#ifdef KDEBUG
3512 if (TEST_OPT_DEBUG){PrintS("new s:");strat->P.wrp();PrintLn();}
3513#endif /* KDEBUG */
3514
3515 // min_std stuff
3516 if ((strat->P.p1==NULL) && (strat->minim>0))
3517 {
3518 if (strat->minim==1)
3519 {
3520 strat->M->m[minimcnt]=p_Copy(strat->P.p,currRing,strat->tailRing);
3521 p_Delete(&strat->P.p2, currRing, strat->tailRing);
3522 }
3523 else
3524 {
3525 strat->M->m[minimcnt]=strat->P.p2;
3526 strat->P.p2=NULL;
3527 }
3528 if (strat->tailRing!=currRing && pNext(strat->M->m[minimcnt])!=NULL)
3529 pNext(strat->M->m[minimcnt])
3530 = strat->p_shallow_copy_delete(pNext(strat->M->m[minimcnt]),
3531 strat->tailRing, currRing,
3532 currRing->PolyBin);
3533 minimcnt++;
3534 }
3535
3536 // enter into S, L, and T
3537 //if ((!TEST_OPT_IDLIFT) || (pGetComp(strat->P.p) <= strat->syzComp))
3538 enterT(strat->P, strat);
3539 strat->T[strat->tl].is_sigsafe = FALSE;
3540 /*
3541 printf("hier\n");
3542 pWrite(strat->P.GetLmCurrRing());
3543 pWrite(strat->P.sig);
3544 */
3545 if (rField_is_Ring(currRing))
3546 superenterpairsSig(strat->P.p,strat->P.sig,strat->sl+1,strat->sl,strat->P.ecart,pos,strat, strat->tl);
3547 else
3548 enterpairsSig(strat->P.p,strat->P.sig,strat->sl+1,strat->sl,strat->P.ecart,pos,strat, strat->tl);
3549 if(rField_is_Ring(currRing) && strat->sigdrop)
3550 break;
3551 if(rField_is_Ring(currRing))
3552 strat->P.sevSig = p_GetShortExpVector(strat->P.sig,currRing);
3553 strat->enterS(strat->P, pos, strat, strat->tl);
3554 if(strat->sbaOrder != 1)
3555 {
3556 BOOLEAN overwrite = FALSE;
3557 for (int tk=0; tk<strat->sl+1; tk++)
3558 {
3559 if (pGetComp(strat->sig[tk]) == pGetComp(strat->P.sig))
3560 {
3561 //printf("TK %d / %d\n",tk,strat->sl);
3562 overwrite = FALSE;
3563 break;
3564 }
3565 }
3566 //printf("OVERWRITE %d\n",overwrite);
3567 if (overwrite)
3568 {
3569 int cmp = pGetComp(strat->P.sig);
3570 int* vv = (int*)omAlloc((currRing->N+1)*sizeof(int));
3571 p_GetExpV (strat->P.p,vv,currRing);
3572 p_SetExpV (strat->P.sig, vv,currRing);
3573 p_SetComp (strat->P.sig,cmp,currRing);
3574
3575 strat->P.sevSig = pGetShortExpVector (strat->P.sig);
3576 int i;
3577 LObject Q;
3578 for(int ps=0;ps<strat->sl+1;ps++)
3579 {
3580
3581 strat->newt = TRUE;
3582 if (strat->syzl == strat->syzmax)
3583 {
3584 pEnlargeSet(&strat->syz,strat->syzmax,setmaxTinc);
3585 strat->sevSyz = (unsigned long*) omRealloc0Size(strat->sevSyz,
3586 (strat->syzmax)*sizeof(unsigned long),
3587 ((strat->syzmax)+setmaxTinc)
3588 *sizeof(unsigned long));
3589 strat->syzmax += setmaxTinc;
3590 }
3591 Q.sig = pCopy(strat->P.sig);
3592 // add LM(F->m[i]) to the signature to get a Schreyer order
3593 // without changing the underlying polynomial ring at all
3594 if (strat->sbaOrder == 0)
3595 p_ExpVectorAdd (Q.sig,strat->S[ps],currRing);
3596 // since p_Add_q() destroys all input
3597 // data we need to recreate help
3598 // each time
3599 // ----------------------------------------------------------
3600 // in the Schreyer order we always know that the multiplied
3601 // module monomial strat->P.sig gives the leading monomial of
3602 // the corresponding principal syzygy
3603 // => we do not need to compute the "real" syzygy completely
3604 poly help = p_Copy(strat->sig[ps],currRing);
3605 p_ExpVectorAdd (help,strat->P.p,currRing);
3606 Q.sig = p_Add_q(Q.sig,help,currRing);
3607 //printf("%d. SYZ ",i+1);
3608 //pWrite(strat->syz[i]);
3609 Q.sevSig = p_GetShortExpVector(Q.sig,currRing);
3610 i = posInSyz(strat, Q.sig);
3611 enterSyz(Q, strat, i);
3612 }
3613 }
3614 }
3615 // deg - idx - lp/rp
3616 // => we need to add syzygies with indices > pGetComp(strat->P.sig)
3617 if(strat->sbaOrder == 0 || strat->sbaOrder == 3)
3618 {
3619 int cmp = pGetComp(strat->P.sig);
3620 unsigned max_cmp = IDELEMS(F);
3621 int* vv = (int*)omAlloc((currRing->N+1)*sizeof(int));
3622 p_GetExpV (strat->P.p,vv,currRing);
3623 LObject Q;
3624 int pos;
3625 int idx = __p_GetComp(strat->P.sig,currRing);
3626 //printf("++ -- adding syzygies -- ++\n");
3627 // if new element is the first one in this index
3628 if (strat->currIdx < idx)
3629 {
3630 for (int i=0; i<strat->sl; ++i)
3631 {
3632 Q.sig = p_Copy(strat->P.sig,currRing);
3633 p_ExpVectorAdd(Q.sig,strat->S[i],currRing);
3634 poly help = p_Copy(strat->sig[i],currRing);
3635 p_ExpVectorAdd(help,strat->P.p,currRing);
3636 Q.sig = p_Add_q(Q.sig,help,currRing);
3637 //pWrite(Q.sig);
3638 pos = posInSyz(strat, Q.sig);
3639 enterSyz(Q, strat, pos);
3640 }
3641 strat->currIdx = idx;
3642 }
3643 else
3644 {
3645 // if the element is not the first one in the given index we build all
3646 // possible syzygies with elements of higher index
3647 for (unsigned i=cmp+1; i<=max_cmp; ++i)
3648 {
3649 pos = -1;
3650 for (int j=0; j<strat->sl; ++j)
3651 {
3652 if (__p_GetComp(strat->sig[j],currRing) == i)
3653 {
3654 pos = j;
3655 break;
3656 }
3657 }
3658 if (pos != -1)
3659 {
3660 Q.sig = p_One(currRing);
3661 p_SetExpV(Q.sig, vv, currRing);
3662 // F->m[i-1] corresponds to index i
3663 p_ExpVectorAdd(Q.sig,F->m[i-1],currRing);
3664 p_SetComp(Q.sig, i, currRing);
3665 poly help = p_Copy(strat->P.sig,currRing);
3666 p_ExpVectorAdd(help,strat->S[pos],currRing);
3667 Q.sig = p_Add_q(Q.sig,help,currRing);
3668 if (strat->sbaOrder == 0)
3669 {
3670 if (p_LmCmp(Q.sig,strat->syz[strat->syzl-1],currRing) == -currRing->OrdSgn)
3671 {
3672 pos = posInSyz(strat, Q.sig);
3673 enterSyz(Q, strat, pos);
3674 }
3675 }
3676 else
3677 {
3678 pos = posInSyz(strat, Q.sig);
3679 enterSyz(Q, strat, pos);
3680 }
3681 }
3682 }
3683 //printf("++ -- done adding syzygies -- ++\n");
3684 }
3685 }
3686//#if 1
3687#if DEBUGF50
3688 printf("---------------------------\n");
3689 Print(" %d. ELEMENT ADDED TO GCURR:\n",strat->sl+1);
3690 PrintS("LEAD POLY: "); pWrite(pHead(strat->S[strat->sl]));
3691 PrintS("SIGNATURE: "); pWrite(strat->sig[strat->sl]);
3692#endif
3693 /*
3694 if (newrules)
3695 {
3696 newrules = FALSE;
3697 }
3698 */
3699#if 0
3700 int pl=pLength(strat->P.p);
3701 if (pl==1)
3702 {
3703 //if (TEST_OPT_PROT)
3704 //PrintS("<1>");
3705 }
3706 else if (pl==2)
3707 {
3708 //if (TEST_OPT_PROT)
3709 //PrintS("<2>");
3710 }
3711#endif
3712 if (hilb!=NULL) khCheck(Q,w,hilb,hilbeledeg,hilbcount,strat);
3713// Print("[%d]",hilbeledeg);
3714 kDeleteLcm(&strat->P);
3715 if (strat->sl>srmax) srmax = strat->sl;
3716 }
3717 else
3718 {
3719 case_when_red_result_changed:
3720 // adds signature of the zero reduction to
3721 // strat->syz. This is the leading term of
3722 // syzygy and can be used in syzCriterion()
3723 // the signature is added if and only if the
3724 // pair was not detected by the rewritten criterion in strat->red = redSig
3725 if (red_result!=2)
3726 {
3727#if SBA_PRINT_ZERO_REDUCTIONS
3728 zeroreductions++;
3729#endif
3730 if(rField_is_Ring(currRing) && strat->P.p == NULL && strat->P.sig == NULL)
3731 {
3732 //Catch the case when p = 0, sig = 0
3733 }
3734 else
3735 {
3736 int pos = posInSyz(strat, strat->P.sig);
3737 enterSyz(strat->P, strat, pos);
3738 //#if 1
3739 #ifdef DEBUGF5
3740 Print("ADDING STUFF TO SYZ : ");
3741 //pWrite(strat->P.p);
3742 pWrite(strat->P.sig);
3743 #endif
3744 }
3745 }
3746 if (strat->P.p1 == NULL && strat->minim > 0)
3747 {
3748 p_Delete(&strat->P.p2, currRing, strat->tailRing);
3749 }
3750 }
3751
3752#ifdef KDEBUG
3753 memset(&(strat->P), 0, sizeof(strat->P));
3754#endif /* KDEBUG */
3755 kTest_TS(strat);
3756 }
3757 #if 0
3758 if(strat->sigdrop)
3759 printf("\nSigDrop!\n");
3760 else
3761 printf("\nEnded with no SigDrop\n");
3762 #endif
3763// Clean strat->P for the next sba call
3764 if(rField_is_Ring(currRing) && strat->sigdrop)
3765 {
3766 //This is used to know how many elements can we directly add to S in the next run
3767 if(strat->P.sig != NULL)
3768 strat->sbaEnterS = pGetComp(strat->P.sig)-1;
3769 //else we already set it at the beginning of the loop
3770 #ifdef KDEBUG
3771 memset(&(strat->P), 0, sizeof(strat->P));
3772 #endif /* KDEBUG */
3773 }
3774#ifdef KDEBUG
3775 if (TEST_OPT_DEBUG) messageSets(strat);
3776#endif /* KDEBUG */
3777
3778 if (TEST_OPT_SB_1)
3779 {
3780 if(!rField_is_Ring(currRing))
3781 {
3782 int k=1;
3783 int j;
3784 while(k<=strat->sl)
3785 {
3786 j=0;
3787 loop
3788 {
3789 if (j>=k) break;
3790 clearS(strat->S[j],strat->sevS[j],&k,&j,strat);
3791 j++;
3792 }
3793 k++;
3794 }
3795 }
3796 }
3797 /* complete reduction of the standard basis--------- */
3798 if (TEST_OPT_REDSB)
3799 {
3800 completeReduce(strat);
3801 if (strat->completeReduce_retry)
3802 {
3803 // completeReduce needed larger exponents, retry
3804 // to reduce with S (instead of T)
3805 // and in currRing (instead of strat->tailRing)
3806#ifdef HAVE_TAIL_RING
3807 if(currRing->bitmask>strat->tailRing->bitmask)
3808 {
3809 strat->completeReduce_retry=FALSE;
3810 cleanT(strat);strat->tailRing=currRing;
3811 int i;
3812 for(i=strat->sl;i>=0;i--) strat->S_2_R[i]=-1;
3813 completeReduce(strat);
3814 }
3815 if (strat->completeReduce_retry)
3816#endif
3817 Werror("exponent bound is %ld",currRing->bitmask);
3818 }
3819 }
3820 else if (TEST_OPT_PROT) PrintLn();
3821
3822#if SBA_PRINT_SIZE_SYZ
3823 // that is correct, syzl is counting one too far
3824 size_syz = strat->syzl;
3825#endif
3826// if (TEST_OPT_WEIGHTM)
3827// {
3828// pRestoreDegProcs(pFDegOld, pLDegOld);
3829// if (ecartWeights)
3830// {
3831// omFreeSize((ADDRESS)ecartWeights,(pVariables+1)*sizeof(short));
3832// ecartWeights=NULL;
3833// }
3834// }
3835 if (TEST_OPT_PROT) messageStatSBA(hilbcount,strat);
3836 if (Q!=NULL) updateResult(strat->Shdl,Q,strat);
3837#if SBA_PRINT_SIZE_G
3838 size_g_non_red = IDELEMS(strat->Shdl);
3839#endif
3840 if(!rField_is_Ring(currRing))
3841 exitSba(strat);
3842 // I have to add the initial input polynomials which where not used (p1 and p2 = NULL)
3843 #ifdef HAVE_RINGS
3844 int k;
3845 if(rField_is_Ring(currRing))
3846 {
3847 //for(k = strat->sl;k>=0;k--)
3848 // {printf("\nS[%i] = %p\n",k,strat->Shdl->m[k]);pWrite(strat->Shdl->m[k]);}
3849 k = strat->Ll;
3850 #if 1
3851 // 1 - adds just the unused ones, 0 - adds everything
3852 for(;k>=0 && (strat->L[k].p1 != NULL || strat->L[k].p2 != NULL);k--)
3853 {
3854 //printf("\nDeleted k = %i, %p\n",k,strat->L[k].p);pWrite(strat->L[k].p);pWrite(strat->L[k].p1);pWrite(strat->L[k].p2);
3855 deleteInL(strat->L,&strat->Ll,k,strat);
3856 }
3857 #endif
3858 //for(int kk = strat->sl;kk>=0;kk--)
3859 // {printf("\nS[%i] = %p\n",kk,strat->Shdl->m[kk]);pWrite(strat->Shdl->m[kk]);}
3860 //idPrint(strat->Shdl);
3861 //printf("\nk = %i\n",k);
3862 for(;k>=0 && strat->L[k].p1 == NULL && strat->L[k].p2 == NULL;k--)
3863 {
3864 //printf("\nAdded k = %i\n",k);
3865 strat->enterS(strat->L[k], strat->sl+1, strat, strat->tl);
3866 //printf("\nThis elements was added from L on pos %i\n",strat->sl);pWrite(strat->S[strat->sl]);pWrite(strat->sig[strat->sl]);
3867 }
3868 }
3869 // Find the "sigdrop element" and put the same signature as the previous one - do we really need this?? - now i put it on the 0 position - no more comparing needed
3870 #if 0
3871 if(strat->sigdrop && rField_is_Ring(currRing))
3872 {
3873 for(k=strat->sl;k>=0;k--)
3874 {
3875 printf("\nsig[%i] = ",i);pWrite(strat->sig[k]);
3876 if(strat->sig[k] == NULL)
3877 strat->sig[k] = pCopy(strat->sig[k-1]);
3878 }
3879 }
3880 #endif
3881 #endif
3882 //Never do this - you will damage S
3883 //idSkipZeroes(strat->Shdl);
3884 //idPrint(strat->Shdl);
3885
3886 if ((strat->sbaOrder == 1 || strat->sbaOrder == 3) && sRing!=currRingOld)
3887 {
3888 rChangeCurrRing (currRingOld);
3889 F0 = idrMoveR (F1, sRing, currRing);
3890 strat->Shdl = idrMoveR_NoSort (strat->Shdl, sRing, currRing);
3891 rChangeCurrRing (sRing);
3892 if(rField_is_Ring(currRing))
3893 exitSba(strat);
3894 rChangeCurrRing (currRingOld);
3895 if(strat->tailRing == sRing)
3896 strat->tailRing = currRing;
3897 rDelete (sRing);
3898 }
3899 if(rField_is_Ring(currRing) && !strat->sigdrop)
3900 id_DelDiv(strat->Shdl, currRing);
3901 if(!rField_is_Ring(currRing))
3902 id_DelDiv(strat->Shdl, currRing);
3903 idSkipZeroes(strat->Shdl);
3904 idTest(strat->Shdl);
3905
3906#if SBA_PRINT_SIZE_G
3907 size_g = IDELEMS(strat->Shdl);
3908#endif
3909#ifdef DEBUGF5
3910 printf("SIZE OF SHDL: %d\n",IDELEMS(strat->Shdl));
3911 int oo = 0;
3912 while (oo<IDELEMS(strat->Shdl))
3913 {
3914 printf(" %d. ",oo+1);
3915 pWrite(pHead(strat->Shdl->m[oo]));
3916 oo++;
3917 }
3918#endif
3919#if SBA_PRINT_ZERO_REDUCTIONS
3920 printf("----------------------------------------------------------\n");
3921 printf("ZERO REDUCTIONS: %ld\n",zeroreductions);
3922 zeroreductions = 0;
3923#endif
3924#if SBA_PRINT_REDUCTION_STEPS
3925 printf("----------------------------------------------------------\n");
3926 printf("S-REDUCTIONS: %ld\n",sba_reduction_steps);
3927#endif
3928#if SBA_PRINT_OPERATIONS
3929 printf("OPERATIONS: %ld\n",sba_operations);
3930#endif
3931#if SBA_PRINT_REDUCTION_STEPS
3932 printf("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - \n");
3933 printf("INTERREDUCTIONS: %ld\n",sba_interreduction_steps);
3934#endif
3935#if SBA_PRINT_OPERATIONS
3936 printf("INTERREDUCTION OPERATIONS: %ld\n",sba_interreduction_operations);
3937#endif
3938#if SBA_PRINT_REDUCTION_STEPS
3939 printf("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - \n");
3940 printf("ALL REDUCTIONS: %ld\n",sba_reduction_steps+sba_interreduction_steps);
3941 sba_interreduction_steps = 0;
3942 sba_reduction_steps = 0;
3943#endif
3944#if SBA_PRINT_OPERATIONS
3945 printf("ALL OPERATIONS: %ld\n",sba_operations+sba_interreduction_operations);
3946 sba_interreduction_operations = 0;
3947 sba_operations = 0;
3948#endif
3949#if SBA_PRINT_SIZE_G
3950 printf("----------------------------------------------------------\n");
3951 printf("SIZE OF G: %d / %d\n",size_g,size_g_non_red);
3952 size_g = 0;
3953 size_g_non_red = 0;
3954#endif
3955#if SBA_PRINT_SIZE_SYZ
3956 printf("SIZE OF SYZ: %ld\n",size_syz);
3957 printf("----------------------------------------------------------\n");
3958 size_syz = 0;
3959#endif
3960#if SBA_PRINT_PRODUCT_CRITERION
3961 printf("PRODUCT CRITERIA: %ld\n",product_criterion);
3962 product_criterion = 0;
3963#endif
3964 return (strat->Shdl);
3965}
intvec
Definition: intvec.h:23
skStrategy::blockredmax
int blockredmax
Definition: kutil.h:365
skStrategy::rewCrit2
BOOLEAN(* rewCrit2)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.h:294
skStrategy::sbaEnterS
int sbaEnterS
Definition: kutil.h:362
sort
void sort(CFArray &A, int l=0)
quick sort A
Definition: facSparseHensel.h:114
idInsertPolyOnPos
BOOLEAN idInsertPolyOnPos(ideal I, poly p, int pos)
insert p into I on position pos
Definition: simpleideals.cc:808
idSort
static intvec * idSort(ideal id, BOOLEAN nolex=TRUE)
Definition: ideals.h:184
kInterRed
ideal kInterRed(ideal F, ideal Q)
Definition: kstd1.cc:3761
initSba
void initSba(ideal F, kStrategy strat)
Definition: kstd1.cc:1747
redtailSba
poly redtailSba(LObject *L, int pos, kStrategy strat, BOOLEAN withT, BOOLEAN normalize)
Definition: kstd2.cc:1761
f5c
void f5c(kStrategy strat, int &olddeg, int &minimcnt, int &hilbeledeg, int &hilbcount, int &srmax, int &lrmax, int &reduc, ideal Q, intvec *w, intvec *hilb)
Definition: kstd2.cc:4296
initSbaPos
void initSbaPos(kStrategy strat)
Definition: kutil.cc:9911
enterpairsSig
void enterpairsSig(poly h, poly hSig, int hFrom, int k, int ecart, int pos, kStrategy strat, int atR)
Definition: kutil.cc:4535
superenterpairsSig
void superenterpairsSig(poly h, poly hSig, int hFrom, int k, int ecart, int pos, kStrategy strat, int atR)
Definition: kutil.cc:4491
sbaRing
ring sbaRing(kStrategy strat, const ring r, BOOLEAN, int)
Definition: kutil.cc:11142
messageStatSBA
void messageStatSBA(int hilbcount, kStrategy strat)
Definition: kutil.cc:7566
initSyzRules
void initSyzRules(kStrategy strat)
Definition: kutil.cc:7976
initSbaBuchMora
void initSbaBuchMora(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:10013
exitSba
void exitSba(kStrategy strat)
Definition: kutil.cc:10088
posInIdealMonFirst
int posInIdealMonFirst(const ideal F, const poly p, int start, int end)
Definition: kutil.cc:4863
initSbaCrit
void initSbaCrit(kStrategy strat)
Definition: kutil.cc:9541
help
#define help
Definition: libparse.cc:1230
p_SetExpV
static void p_SetExpV(poly p, int *ev, const ring r)
Definition: p_polys.h:1542
p_GetExpV
static void p_GetExpV(poly p, int *ev, const ring r)
Definition: p_polys.h:1518
idrMoveR
ideal idrMoveR(ideal &id, ring src_r, ring dest_r)
Definition: prCopy.cc:248
idrMoveR_NoSort
ideal idrMoveR_NoSort(ideal &id, ring src_r, ring dest_r)
Definition: prCopy.cc:261
rWrite
void rWrite(ring r, BOOLEAN details)
Definition: ring.cc:226
id_DelDiv
void id_DelDiv(ideal id, const ring r)
delete id[j], if LT(j) == coeff*mon*LT(i) and vice versa, i.e., delete id[i], if LT(i) == coeff*mon*L...
Definition: simpleideals.cc:420

◆ sbaCheckGcdPair()

BOOLEAN sbaCheckGcdPair ( LObject *  h,
kStrategy  strat 
)

Definition at line 1700 of file kutil.cc.

1701{
1702 if(strat->sl < 0) return FALSE;
1703 int i;
1704 for(i=0;i<strat->sl;i++)
1705 {
1706 //Construct the gcd pair between h and S[i]
1707 number d, s, t;
1708 poly m1, m2, gcd;
1709 d = n_ExtGcd(pGetCoeff(h->p), pGetCoeff(strat->S[i]), &s, &t, currRing->cf);
1710 if (nIsZero(s) || nIsZero(t)) // evtl. durch divBy tests ersetzen
1711 {
1712 nDelete(&d);
1713 nDelete(&s);
1714 nDelete(&t);
1715 }
1716 else
1717 {
1718 k_GetStrongLeadTerms(h->p, strat->S[i], currRing, m1, m2, gcd, strat->tailRing);
1719 pSetCoeff0(m1, s);
1720 pSetCoeff0(m2, t);
1721 pSetCoeff0(gcd, d);
1722 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);
1723 poly pSigMult = p_Copy(h->sig,currRing);
1724 poly sSigMult = p_Copy(strat->sig[i],currRing);
1725 pSigMult = p_Mult_mm(pSigMult,m1,currRing);
1726 sSigMult = p_Mult_mm(sSigMult,m2,currRing);
1727 p_LmDelete(m1, strat->tailRing);
1728 p_LmDelete(m2, strat->tailRing);
1729 poly pairsig = p_Add_q(pSigMult,sSigMult,currRing);
1730 if(pairsig!= NULL && pLtCmp(pairsig,h->sig) == 0)
1731 {
1732 pDelete(&h->p);
1733 h->p = gcd;
1734 pDelete(&h->sig);
1735 h->sig = pairsig;
1736 pNext(h->sig) = NULL;
1737 strat->initEcart(h);
1738 h->sev = pGetShortExpVector(h->p);
1739 h->sevSig = pGetShortExpVector(h->sig);
1740 h->i_r1 = -1;h->i_r2 = -1;
1741 if(h->lcm != NULL)
1742 {
1743 pLmDelete(h->lcm);
1744 h->lcm = NULL;
1745 }
1746 if (currRing!=strat->tailRing)
1747 h->t_p = k_LmInit_currRing_2_tailRing(h->p, strat->tailRing);
1748 return TRUE;
1749 }
1750 //Delete what you didn't use
1751 pDelete(&gcd);
1752 pDelete(&pairsig);
1753 }
1754 }
1755 return FALSE;
1756}
n_ExtGcd
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:668
k_GetStrongLeadTerms
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:1061
pp_Mult_mm
static poly pp_Mult_mm(poly p, poly m, const ring r)
Definition: p_polys.h:1029

◆ sbaRing()

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

Definition at line 11142 of file kutil.cc.

11143{
11144 int n = rBlocks(r); // Including trailing zero!
11145 // if sbaOrder == 1 => use (C,monomial order from r)
11146 if (strat->sbaOrder == 1)
11147 {
11148 if (r->order[0] == ringorder_C || r->order[0] == ringorder_c)
11149 {
11150 return r;
11151 }
11152 ring res = rCopy0(r, TRUE, FALSE);
11153 res->order = (rRingOrder_t *)omAlloc0((n+1)*sizeof(rRingOrder_t));
11154 res->block0 = (int *)omAlloc0((n+1)*sizeof(int));
11155 res->block1 = (int *)omAlloc0((n+1)*sizeof(int));
11156 int **wvhdl = (int **)omAlloc0((n+1)*sizeof(int*));
11157 res->wvhdl = wvhdl;
11158 for (int i=1; i<n; i++)
11159 {
11160 res->order[i] = r->order[i-1];
11161 res->block0[i] = r->block0[i-1];
11162 res->block1[i] = r->block1[i-1];
11163 res->wvhdl[i] = r->wvhdl[i-1];
11164 }
11165
11166 // new 1st block
11167 res->order[0] = ringorder_C; // Prefix
11168 // removes useless secondary component order if defined in old ring
11169 for (int i=rBlocks(res); i>0; --i)
11170 {
11171 if (res->order[i] == ringorder_C || res->order[i] == ringorder_c)
11172 {
11173 res->order[i] = (rRingOrder_t)0;
11174 }
11175 }
11176 rComplete(res, 1);
11177#ifdef HAVE_PLURAL
11178 if (rIsPluralRing(r))
11179 {
11180 if ( nc_rComplete(r, res, false) ) // no qideal!
11181 {
11182#ifndef SING_NDEBUG
11183 WarnS("error in nc_rComplete");
11184#endif
11185 // cleanup?
11186
11187 // rDelete(res);
11188 // return r;
11189
11190 // just go on..
11191 }
11192 }
11193#endif
11194 strat->tailRing = res;
11195 return (res);
11196 }
11197 // if sbaOrder == 3 => degree - position - ring order
11198 if (strat->sbaOrder == 3)
11199 {
11200 ring res = rCopy0(r, TRUE, FALSE);
11201 res->order = (rRingOrder_t*)omAlloc0((n+2)*sizeof(rRingOrder_t));
11202 res->block0 = (int *)omAlloc0((n+2)*sizeof(int));
11203 res->block1 = (int *)omAlloc0((n+2)*sizeof(int));
11204 int **wvhdl = (int **)omAlloc0((n+2)*sizeof(int*));
11205 res->wvhdl = wvhdl;
11206 for (int i=2; i<n+2; i++)
11207 {
11208 res->order[i] = r->order[i-2];
11209 res->block0[i] = r->block0[i-2];
11210 res->block1[i] = r->block1[i-2];
11211 res->wvhdl[i] = r->wvhdl[i-2];
11212 }
11213
11214 // new 1st block
11215 res->order[0] = ringorder_a; // Prefix
11216 res->block0[0] = 1;
11217 res->wvhdl[0] = (int *)omAlloc(res->N*sizeof(int));
11218 for (int i=0; i<res->N; ++i)
11219 res->wvhdl[0][i] = 1;
11220 res->block1[0] = si_min(res->N, rVar(res));
11221 // new 2nd block
11222 res->order[1] = ringorder_C; // Prefix
11223 res->wvhdl[1] = NULL;
11224 // removes useless secondary component order if defined in old ring
11225 for (int i=rBlocks(res); i>1; --i)
11226 {
11227 if (res->order[i] == ringorder_C || res->order[i] == ringorder_c)
11228 {
11229 res->order[i] = (rRingOrder_t)0;
11230 }
11231 }
11232 rComplete(res, 1);
11233#ifdef HAVE_PLURAL
11234 if (rIsPluralRing(r))
11235 {
11236 if ( nc_rComplete(r, res, false) ) // no qideal!
11237 {
11238#ifndef SING_NDEBUG
11239 WarnS("error in nc_rComplete");
11240#endif
11241 // cleanup?
11242
11243 // rDelete(res);
11244 // return r;
11245
11246 // just go on..
11247 }
11248 }
11249#endif
11250 strat->tailRing = res;
11251 return (res);
11252 }
11253
11254 // not sbaOrder == 1 => use Schreyer order
11255 // this is done by a trick when initializing the signatures
11256 // in initSLSba():
11257 // Instead of using the signature 1e_i for F->m[i], we start
11258 // with the signature LM(F->m[i])e_i for F->m[i]. Doing this we get a
11259 // Schreyer order w.r.t. the underlying monomial order.
11260 // => we do not need to change the underlying polynomial ring at all!
11261
11262 // UPDATE/NOTE/TODO: use induced Schreyer ordering 'IS'!!!!????
11263
11264 /*
11265 else
11266 {
11267 ring res = rCopy0(r, FALSE, FALSE);
11268 // Create 2 more blocks for prefix/suffix:
11269 res->order=(int *)omAlloc0((n+2)*sizeof(int)); // 0 .. n+1
11270 res->block0=(int *)omAlloc0((n+2)*sizeof(int));
11271 res->block1=(int *)omAlloc0((n+2)*sizeof(int));
11272 int ** wvhdl =(int **)omAlloc0((n+2)*sizeof(int**));
11273
11274 // Encapsulate all existing blocks between induced Schreyer ordering markers: prefix and suffix!
11275 // Note that prefix and suffix have the same ringorder marker and only differ in block[] parameters!
11276
11277 // new 1st block
11278 int j = 0;
11279 res->order[j] = ringorder_IS; // Prefix
11280 res->block0[j] = res->block1[j] = 0;
11281 // wvhdl[j] = NULL;
11282 j++;
11283
11284 for(int i = 0; (i < n) && (r->order[i] != 0); i++, j++) // i = [0 .. n-1] <- non-zero old blocks
11285 {
11286 res->order [j] = r->order [i];
11287 res->block0[j] = r->block0[i];
11288 res->block1[j] = r->block1[i];
11289
11290 if (r->wvhdl[i] != NULL)
11291 {
11292 wvhdl[j] = (int*) omMemDup(r->wvhdl[i]);
11293 } // else wvhdl[j] = NULL;
11294 }
11295
11296 // new last block
11297 res->order [j] = ringorder_IS; // Suffix
11298 res->block0[j] = res->block1[j] = sgn; // Sign of v[o]: 1 for C, -1 for c
11299 // wvhdl[j] = NULL;
11300 j++;
11301
11302 // res->order [j] = 0; // The End!
11303 res->wvhdl = wvhdl;
11304
11305 // j == the last zero block now!
11306 assume(j == (n+1));
11307 assume(res->order[0]==ringorder_IS);
11308 assume(res->order[j-1]==ringorder_IS);
11309 assume(res->order[j]==0);
11310
11311 if (complete)
11312 {
11313 rComplete(res, 1);
11314
11315#ifdef HAVE_PLURAL
11316 if (rIsPluralRing(r))
11317 {
11318 if ( nc_rComplete(r, res, false) ) // no qideal!
11319 {
11320 }
11321 }
11322 assume(rIsPluralRing(r) == rIsPluralRing(res));
11323#endif
11324
11325
11326#ifdef HAVE_PLURAL
11327 ring old_ring = r;
11328
11329#endif
11330
11331 if (r->qideal!=NULL)
11332 {
11333 res->qideal= idrCopyR_NoSort(r->qideal, r, res);
11334
11335 assume(idRankFreeModule(res->qideal, res) == 0);
11336
11337#ifdef HAVE_PLURAL
11338 if( rIsPluralRing(res) )
11339 if( nc_SetupQuotient(res, r, true) )
11340 {
11341 // WarnS("error in nc_SetupQuotient"); // cleanup? rDelete(res); return r; // just go on...?
11342 }
11343
11344#endif
11345 assume(idRankFreeModule(res->qideal, res) == 0);
11346 }
11347
11348#ifdef HAVE_PLURAL
11349 assume((res->qideal==NULL) == (old_ring->qideal==NULL));
11350 assume(rIsPluralRing(res) == rIsPluralRing(old_ring));
11351 assume(rIsSCA(res) == rIsSCA(old_ring));
11352 assume(ncRingType(res) == ncRingType(old_ring));
11353#endif
11354 }
11355 strat->tailRing = res;
11356 return res;
11357 }
11358 */
11359
11360 assume(FALSE);
11361 return(NULL);
11362}
si_min
static int si_min(const int a, const int b)
Definition: auxiliary.h:125
nc_rComplete
BOOLEAN nc_rComplete(const ring src, ring dest, bool bSetupQuotient)
Definition: ring.cc:5685
rBlocks
static int rBlocks(const ring r)
Definition: ring.h:568
rRingOrder_t
rRingOrder_t
order stuff
Definition: ring.h:68
ringorder_a
@ ringorder_a
Definition: ring.h:70

◆ superenterpairs()

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

Definition at line 4478 of file kutil.cc.

4479{
4480 assume (rField_is_Ring(currRing));
4481#if HAVE_SHIFTBBA
4482 assume(!rIsLPRing(currRing)); /* LP should use enterpairsShift */
4483#endif
4484 // enter also zero divisor * poly, if this is non zero and of smaller degree
4485 if (!(rField_is_Domain(currRing))) enterExtendedSpoly(h, strat);
4486 initenterstrongPairs(h, k, ecart, 0, strat, atR);
4487 initenterpairs(h, k, ecart, 0, strat, atR);
4488 clearSbatch(h, k, pos, strat);
4489}
clearSbatch
void clearSbatch(poly h, int k, int pos, kStrategy strat)
Definition: kutil.cc:4452
initenterstrongPairs
void initenterstrongPairs(poly h, int k, int ecart, int isFromQ, kStrategy strat, int atR=-1)
Definition: kutil.cc:4167
enterExtendedSpoly
void enterExtendedSpoly(poly h, kStrategy strat)
Definition: kutil.cc:4249

◆ superenterpairsShift()

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

◆ superenterpairsSig()

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

Definition at line 4491 of file kutil.cc.

4492{
4493 assume (rField_is_Ring(currRing));
4494 // enter also zero divisor * poly, if this is non zero and of smaller degree
4495 if (!(rField_is_Domain(currRing))) enterExtendedSpolySig(h, hSig, strat);
4496 if(strat->sigdrop) return;
4497 initenterpairsSigRing(h, hSig, hFrom, k, ecart, 0, strat, atR);
4498 if(strat->sigdrop) return;
4499 initenterstrongPairsSig(h, hSig, k, ecart, 0, strat, atR);
4500 if(strat->sigdrop) return;
4501 clearSbatch(h, k, pos, strat);
4502}
initenterpairsSigRing
void initenterpairsSigRing(poly h, poly hSig, int hFrom, int k, int ecart, int isFromQ, kStrategy strat, int atR=-1)
Definition: kutil.cc:3947
initenterstrongPairsSig
static void initenterstrongPairsSig(poly h, poly hSig, int k, int ecart, int isFromQ, kStrategy strat, int atR=-1)
Definition: kutil.cc:4222
enterExtendedSpolySig
void enterExtendedSpolySig(poly h, poly hSig, kStrategy strat)
Definition: kutil.cc:4333

◆ syzCriterion()

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

Definition at line 6521 of file kutil.cc.

6522{
6523//#if 1
6524#ifdef DEBUGF5
6525 PrintS("syzygy criterion checks: ");
6526 pWrite(sig);
6527#endif
6528 for (int k=0; k<strat->syzl; k++)
6529 {
6530 //printf("-%d",k);
6531//#if 1
6532#ifdef DEBUGF5
6533 Print("checking with: %d / %d -- \n",k,strat->syzl);
6534 pWrite(pHead(strat->syz[k]));
6535#endif
6536 if (p_LmShortDivisibleBy(strat->syz[k], strat->sevSyz[k], sig, not_sevSig, currRing)
6537 && (!rField_is_Ring(currRing) ||
6538 (n_DivBy(pGetCoeff(sig), pGetCoeff(strat->syz[k]),currRing->cf) && pLtCmp(sig,strat->syz[k]) == 1)))
6539 {
6540//#if 1
6541#ifdef DEBUGF5
6542 PrintS("DELETE!\n");
6543#endif
6544 strat->nrsyzcrit++;
6545 //printf("- T -\n\n");
6546 return TRUE;
6547 }
6548 }
6549 //printf("- F -\n\n");
6550 return FALSE;
6551}

◆ syzCriterionInc()

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

Definition at line 6556 of file kutil.cc.

6557{
6558//#if 1
6559 if(sig == NULL)
6560 return FALSE;
6561#ifdef DEBUGF5
6562 PrintS("--- syzygy criterion checks: ");
6563 pWrite(sig);
6564#endif
6565 int comp = __p_GetComp(sig, currRing);
6566 int min, max;
6567 if (comp<=1)
6568 return FALSE;
6569 else
6570 {
6571 min = strat->syzIdx[comp-2];
6572 //printf("SYZIDX %d/%d\n",strat->syzIdx[comp-2],comp-2);
6573 //printf("SYZIDX %d/%d\n",strat->syzIdx[comp-1],comp-1);
6574 //printf("SYZIDX %d/%d\n",strat->syzIdx[comp],comp);
6575 if (comp == strat->currIdx)
6576 {
6577 max = strat->syzl;
6578 }
6579 else
6580 {
6581 max = strat->syzIdx[comp-1];
6582 }
6583 for (int k=min; k<max; k++)
6584 {
6585#ifdef F5DEBUG
6586 Print("COMP %d/%d - MIN %d - MAX %d - SYZL %ld\n",comp,strat->currIdx,min,max,strat->syzl);
6587 Print("checking with: %d -- ",k);
6588 pWrite(pHead(strat->syz[k]));
6589#endif
6590 if (p_LmShortDivisibleBy(strat->syz[k], strat->sevSyz[k], sig, not_sevSig, currRing)
6591 && (!rField_is_Ring(currRing) ||
6592 (n_DivBy(pGetCoeff(sig), pGetCoeff(strat->syz[k]),currRing->cf) && pLtCmp(sig,strat->syz[k]) == 1)))
6593 {
6594 strat->nrsyzcrit++;
6595 return TRUE;
6596 }
6597 }
6598 return FALSE;
6599 }
6600}
min
static int min(int a, int b)
Definition: fast_mult.cc:268
max
static int max(int a, int b)
Definition: fast_mult.cc:264

◆ updateResult()

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

Definition at line 10128 of file kutil.cc.

10129{
10130 int l;
10131 if (strat->ak>0)
10132 {
10133 for (l=IDELEMS(r)-1;l>=0;l--)
10134 {
10135 if ((r->m[l]!=NULL) && (pGetComp(r->m[l])==0))
10136 {
10137 pDelete(&r->m[l]); // and set it to NULL
10138 }
10139 }
10140 int q;
10141 poly p;
10142 if(!rField_is_Ring(currRing))
10143 {
10144 for (l=IDELEMS(r)-1;l>=0;l--)
10145 {
10146 if ((r->m[l]!=NULL)
10147 //&& (strat->syzComp>0)
10148 //&& (pGetComp(r->m[l])<=strat->syzComp)
10149 )
10150 {
10151 for(q=IDELEMS(Q)-1; q>=0;q--)
10152 {
10153 if ((Q->m[q]!=NULL)
10154 &&(pLmDivisibleBy(Q->m[q],r->m[l])))
10155 {
10156 if (TEST_OPT_REDSB)
10157 {
10158 p=r->m[l];
10159 r->m[l]=kNF(Q,NULL,p);
10160 pDelete(&p);
10161 }
10162 else
10163 {
10164 pDelete(&r->m[l]); // and set it to NULL
10165 }
10166 break;
10167 }
10168 }
10169 }
10170 }
10171 }
10172 #ifdef HAVE_RINGS
10173 else
10174 {
10175 for (l=IDELEMS(r)-1;l>=0;l--)
10176 {
10177 if ((r->m[l]!=NULL)
10178 //&& (strat->syzComp>0)
10179 //&& (pGetComp(r->m[l])<=strat->syzComp)
10180 )
10181 {
10182 for(q=IDELEMS(Q)-1; q>=0;q--)
10183 {
10184 if ((Q->m[q]!=NULL)
10185 &&(pLmDivisibleBy(Q->m[q],r->m[l])))
10186 {
10187 if(n_DivBy(r->m[l]->coef, Q->m[q]->coef, currRing->cf))
10188 {
10189 if (TEST_OPT_REDSB)
10190 {
10191 p=r->m[l];
10192 r->m[l]=kNF(Q,NULL,p);
10193 pDelete(&p);
10194 }
10195 else
10196 {
10197 pDelete(&r->m[l]); // and set it to NULL
10198 }
10199 break;
10200 }
10201 }
10202 }
10203 }
10204 }
10205 }
10206 #endif
10207 }
10208 else
10209 {
10210 int q;
10211 poly p;
10212 BOOLEAN reduction_found=FALSE;
10213 if (!rField_is_Ring(currRing))
10214 {
10215 for (l=IDELEMS(r)-1;l>=0;l--)
10216 {
10217 if (r->m[l]!=NULL)
10218 {
10219 for(q=IDELEMS(Q)-1; q>=0;q--)
10220 {
10221 if ((Q->m[q]!=NULL)&&(pLmEqual(Q->m[q],r->m[l])))
10222 {
10223 if (TEST_OPT_REDSB)
10224 {
10225 p=r->m[l];
10226 r->m[l]=kNF(Q,NULL,p);
10227 pDelete(&p);
10228 reduction_found=TRUE;
10229 }
10230 else
10231 {
10232 pDelete(&r->m[l]); // and set it to NULL
10233 }
10234 break;
10235 }
10236 }
10237 }
10238 }
10239 }
10240 #ifdef HAVE_RINGS
10241 //Also need divisibility of the leading coefficients
10242 else
10243 {
10244 for (l=IDELEMS(r)-1;l>=0;l--)
10245 {
10246 if (r->m[l]!=NULL)
10247 {
10248 for(q=IDELEMS(Q)-1; q>=0;q--)
10249 {
10250 if(n_DivBy(r->m[l]->coef, Q->m[q]->coef, currRing->cf))
10251 {
10252 if ((Q->m[q]!=NULL)&&(pLmEqual(Q->m[q],r->m[l])) && pDivisibleBy(Q->m[q],r->m[l]))
10253 {
10254 if (TEST_OPT_REDSB)
10255 {
10256 p=r->m[l];
10257 r->m[l]=kNF(Q,NULL,p);
10258 pDelete(&p);
10259 reduction_found=TRUE;
10260 }
10261 else
10262 {
10263 pDelete(&r->m[l]); // and set it to NULL
10264 }
10265 break;
10266 }
10267 }
10268 }
10269 }
10270 }
10271 }
10272 #endif
10273 if (/*TEST_OPT_REDSB &&*/ reduction_found)
10274 {
10275 #ifdef HAVE_RINGS
10276 if(rField_is_Ring(currRing))
10277 {
10278 for (l=IDELEMS(r)-1;l>=0;l--)
10279 {
10280 if (r->m[l]!=NULL)
10281 {
10282 for(q=IDELEMS(r)-1;q>=0;q--)
10283 {
10284 if ((l!=q)
10285 && (r->m[q]!=NULL)
10286 &&(pLmDivisibleBy(r->m[l],r->m[q]))
10287 &&(n_DivBy(r->m[q]->coef, r->m[l]->coef, currRing->cf))
10288 )
10289 {
10290 //If they are equal then take the one with the smallest length
10291 if(pLmDivisibleBy(r->m[q],r->m[l])
10292 && n_DivBy(r->m[q]->coef, r->m[l]->coef, currRing->cf)
10293 && (pLength(r->m[q]) < pLength(r->m[l]) ||
10294 (pLength(r->m[q]) == pLength(r->m[l]) && nGreaterZero(r->m[q]->coef))))
10295 {
10296 pDelete(&r->m[l]);
10297 break;
10298 }
10299 else
10300 pDelete(&r->m[q]);
10301 }
10302 }
10303 }
10304 }
10305 }
10306 else
10307 #endif
10308 {
10309 for (l=IDELEMS(r)-1;l>=0;l--)
10310 {
10311 if (r->m[l]!=NULL)
10312 {
10313 for(q=IDELEMS(r)-1;q>=0;q--)
10314 {
10315 if ((l!=q)
10316 && (r->m[q]!=NULL)
10317 &&(pLmDivisibleBy(r->m[l],r->m[q]))
10318 )
10319 {
10320 //If they are equal then take the one with the smallest length
10321 if(pLmDivisibleBy(r->m[q],r->m[l])
10322 &&(pLength(r->m[q]) < pLength(r->m[l]) ||
10323 (pLength(r->m[q]) == pLength(r->m[l]) && nGreaterZero(r->m[q]->coef))))
10324 {
10325 pDelete(&r->m[l]);
10326 break;
10327 }
10328 else
10329 pDelete(&r->m[q]);
10330 }
10331 }
10332 }
10333 }
10334 }
10335 }
10336 }
10337 idSkipZeroes(r);
10338}
kNF
poly kNF(ideal F, ideal Q, poly p, int syzComp, int lazyReduce)
Definition: kstd1.cc:3182

◆ updateS()

void updateS ( BOOLEAN  toT,
kStrategy  strat 
)

Definition at line 8594 of file kutil.cc.

8595{
8596 LObject h;
8597 int i, suc=0;
8598 poly redSi=NULL;
8599 BOOLEAN change,any_change;
8600// Print("nach initS: updateS start mit sl=%d\n",(strat->sl));
8601// for (i=0; i<=(strat->sl); i++)
8602// {
8603// Print("s%d:",i);
8604// if (strat->fromQ!=NULL) Print("(Q:%d) ",strat->fromQ[i]);
8605// pWrite(strat->S[i]);
8606// }
8607// Print("currRing->OrdSgn=%d\n", currRing->OrdSgn);
8608 any_change=FALSE;
8609 if (rHasGlobalOrdering(currRing))
8610 {
8611 while (suc != -1)
8612 {
8613 i=suc+1;
8614 while (i<=strat->sl)
8615 {
8616 change=FALSE;
8617 if(rField_is_Ring(currRing))
8618 any_change = FALSE;
8619 if (((strat->fromQ==NULL) || (strat->fromQ[i]==0)) && (i>0))
8620 {
8621 redSi = pHead(strat->S[i]);
8622 strat->S[i] = redBba(strat->S[i],i-1,strat);
8623 //if ((strat->ak!=0)&&(strat->S[i]!=NULL))
8624 // strat->S[i]=redQ(strat->S[i],i+1,strat); /*reduce S[i] mod Q*/
8625 if (pCmp(redSi,strat->S[i])!=0)
8626 {
8627 change=TRUE;
8628 any_change=TRUE;
8629 #ifdef KDEBUG
8630 if (TEST_OPT_DEBUG)
8631 {
8632 PrintS("reduce:");
8633 wrp(redSi);PrintS(" to ");p_wrp(strat->S[i], currRing, strat->tailRing);PrintLn();
8634 }
8635 #endif
8636 if (TEST_OPT_PROT)
8637 {
8638 if (strat->S[i]==NULL)
8639 PrintS("V");
8640 else
8641 PrintS("v");
8642 mflush();
8643 }
8644 }
8645 pLmDelete(&redSi);
8646 if (strat->S[i]==NULL)
8647 {
8648 deleteInS(i,strat);
8649 i--;
8650 }
8651 else if (change)
8652 {
8653 if (TEST_OPT_INTSTRATEGY)
8654 {
8655 if (TEST_OPT_CONTENTSB)
8656 {
8657 number n;
8658 p_Cleardenom_n(strat->S[i], currRing, n);// also does remove Content
8659 if (!nIsOne(n))
8660 {
8661 denominator_list denom=(denominator_list)omAlloc(sizeof(denominator_list_s));
8662 denom->n=nInvers(n);
8663 denom->next=DENOMINATOR_LIST;
8664 DENOMINATOR_LIST=denom;
8665 }
8666 nDelete(&n);
8667 }
8668 else
8669 {
8670 strat->S[i]=p_Cleardenom(strat->S[i], currRing);// also does remove Content
8671 }
8672 }
8673 else
8674 {
8675 pNorm(strat->S[i]);
8676 }
8677 strat->sevS[i] = pGetShortExpVector(strat->S[i]);
8678 }
8679 }
8680 i++;
8681 }
8682 if (any_change) reorderS(&suc,strat);
8683 else break;
8684 }
8685 if (toT)
8686 {
8687 for (i=0; i<=strat->sl; i++)
8688 {
8689 if ((strat->fromQ==NULL) || (strat->fromQ[i]==0))
8690 {
8691 h.p = redtailBba(strat->S[i],i-1,strat);
8692 if (TEST_OPT_INTSTRATEGY)
8693 {
8694 h.pCleardenom();// also does remove Content
8695 }
8696 }
8697 else
8698 {
8699 h.p = strat->S[i];
8700 }
8701 strat->initEcart(&h);
8702 if (strat->honey)
8703 {
8704 strat->ecartS[i] = h.ecart;
8705 }
8706 if (strat->sevS[i] == 0) {strat->sevS[i] = pGetShortExpVector(h.p);}
8707 else assume(strat->sevS[i] == pGetShortExpVector(h.p));
8708 h.sev = strat->sevS[i];
8709 /*puts the elements of S also to T*/
8710 strat->initEcart(&h);
8711 /*if (toT) - already checked*/ enterT(h,strat);
8712 strat->S_2_R[i] = strat->tl;
8713#ifdef HAVE_SHIFTBBA
8714 if (/*(toT) && */(currRing->isLPring))
8715 enterTShift(h, strat);
8716#endif
8717 }
8718 }
8719 }
8720 else
8721 {
8722 while (suc != -1)
8723 {
8724 i=suc;
8725 while (i<=strat->sl)
8726 {
8727 change=FALSE;
8728 if (((strat->fromQ==NULL) || (strat->fromQ[i]==0)) && (i>0))
8729 {
8730 redSi=pHead((strat->S)[i]);
8731 (strat->S)[i] = redMora((strat->S)[i],i-1,strat);
8732 if ((strat->S)[i]==NULL)
8733 {
8734 deleteInS(i,strat);
8735 i--;
8736 }
8737 else if (pCmp((strat->S)[i],redSi)!=0)
8738 {
8739 any_change=TRUE;
8740 h.p = strat->S[i];
8741 strat->initEcart(&h);
8742 strat->ecartS[i] = h.ecart;
8743 if (TEST_OPT_INTSTRATEGY)
8744 {
8745 if (TEST_OPT_CONTENTSB)
8746 {
8747 number n;
8748 p_Cleardenom_n(strat->S[i], currRing, n);// also does remove Content
8749 if (!nIsOne(n))
8750 {
8751 denominator_list denom=(denominator_list)omAlloc(sizeof(denominator_list_s));
8752 denom->n=nInvers(n);
8753 denom->next=DENOMINATOR_LIST;
8754 DENOMINATOR_LIST=denom;
8755 }
8756 nDelete(&n);
8757 }
8758 else
8759 {
8760 strat->S[i]=p_Cleardenom(strat->S[i], currRing);// also does remove Content
8761 }
8762 }
8763 else
8764 {
8765 pNorm(strat->S[i]); // == h.p
8766 }
8767 h.sev = pGetShortExpVector(h.p);
8768 strat->sevS[i] = h.sev;
8769 }
8770 pLmDelete(&redSi);
8771 kTest(strat);
8772 }
8773 i++;
8774 }
8775#ifdef KDEBUG
8776 kTest(strat);
8777#endif
8778 if (any_change) reorderS(&suc,strat);
8779 else { suc=-1; break; }
8780 if (h.p!=NULL)
8781 {
8782 if (!strat->kAllAxis)
8783 {
8784 /*strat->kAllAxis =*/ HEckeTest(h.p,strat);
8785 }
8786 if (strat->kAllAxis)
8787 newHEdge(strat);
8788 }
8789 }
8790 for (i=0; i<=strat->sl; i++)
8791 {
8792 if ((strat->fromQ==NULL) || (strat->fromQ[i]==0))
8793 {
8794 strat->S[i] = h.p = redtail(strat->S[i],strat->sl,strat);
8795 strat->initEcart(&h);
8796 strat->ecartS[i] = h.ecart;
8797 h.sev = pGetShortExpVector(h.p);
8798 strat->sevS[i] = h.sev;
8799 }
8800 else
8801 {
8802 h.p = strat->S[i];
8803 h.ecart=strat->ecartS[i];
8804 h.sev = strat->sevS[i];
8805 h.length = h.pLength = pLength(h.p);
8806 }
8807 if ((strat->fromQ==NULL) || (strat->fromQ[i]==0))
8808 cancelunit1(&h,&suc,strat->sl,strat);
8809 h.SetpFDeg();
8810 /*puts the elements of S also to T*/
8811 enterT(h,strat);
8812 strat->S_2_R[i] = strat->tl;
8813#ifdef HAVE_SHIFTBBA
8814 if (currRing->isLPring)
8815 enterTShift(h, strat);
8816#endif
8817 }
8818 if (suc!= -1) updateS(toT,strat);
8819 }
8820#ifdef KDEBUG
8821 kTest(strat);
8822#endif
8823}
redMora
static poly redMora(poly h, int maxIndex, kStrategy strat)
Definition: kutil.cc:8549
redBba
static poly redBba(poly h, int maxIndex, kStrategy strat)
Definition: kutil.cc:8525
cancelunit1
void cancelunit1(LObject *p, int *suc, int index, kStrategy strat)
Definition: kutil.cc:8437
HEckeTest
void HEckeTest(poly pp, kStrategy strat)
Definition: kutil.cc:501
reorderS
void reorderS(int *suc, kStrategy strat)
Definition: kutil.cc:4632
newHEdge
BOOLEAN newHEdge(kStrategy strat)
Definition: kutil.cc:10462

Variable Documentation

◆ DENOMINATOR_LIST

EXTERN_VAR denominator_list DENOMINATOR_LIST

Definition at line 66 of file kutil.h.

◆ HCord

EXTERN_VAR int HCord

Definition at line 269 of file kutil.h.

◆ strat_nr

EXTERN_VAR int strat_nr

Definition at line 181 of file kutil.h.

◆ test_PosInL

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

Definition at line 877 of file kutil.h.

◆ test_PosInT

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

Definition at line 876 of file kutil.h.

Generated on Thu Apr 27 2023 08:16:02 for My Project by   doxygen 1.9.4 for Singular