My Project
Loading...
Searching...
No Matches
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 intintset
 
typedef int64 wlen_type
 
typedef wlen_typewlen_set
 
typedef class sTObject TObject
 
typedef class sLObject LObject
 
typedef TObjectTSet
 
typedef LObjectLSet
 
typedef denominator_list_sdenominator_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
 
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
 
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
 
int kFindDivisibleByInS (const kStrategy strat, int *max_ind, LObject *L)
 return -1 if no divisor is found number of first divisor in S, otherwise
 
int kFindNextDivisibleByInS (const kStrategy strat, int start, int max_ind, LObject *L)
 
TObjectkFindDivisibleByInS_T (kStrategy strat, int end_pos, LObject *L, TObject *T, long ecart=LONG_MAX)
 
KINLINE TSet initT ()
 
KINLINE TObject ** initR ()
 
KINLINE unsigned longinitsevT ()
 
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
 
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
 
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
 
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.
 
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

Definition at line 63 of file kutil.h.

◆ intset

Definition at line 53 of file kutil.h.

◆ LObject

Definition at line 58 of file kutil.h.

◆ LSet

Definition at line 60 of file kutil.h.

◆ TObject

Definition at line 57 of file kutil.h.

◆ TSet

Definition at line 59 of file kutil.h.

◆ wlen_set

Definition at line 55 of file kutil.h.

◆ 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{
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}
#define TRUE
Definition auxiliary.h:100
#define FALSE
Definition auxiliary.h:96
polyset S
Definition kutil.h:306
unsigned long * sevSig
Definition kutil.h:324
polyset sig
Definition kutil.h:308
LObject P
Definition kutil.h:302
int sl
Definition kutil.h:348
static void p_ExpVectorSum(poly pr, poly p1, poly p2, const ring r)
Definition p_polys.h:1425
static BOOLEAN p_LmShortDivisibleBy(poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, const ring r)
Definition p_polys.h:1910
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition polys.cc:13
#define pDelete(p_ptr)
Definition polys.h:186
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
Definition polys.h:105
#define pOne()
Definition polys.h:315
#define rField_is_Ring(R)
Definition ring.h:490

◆ 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
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}
int i
Definition cfEzgcd.cc:132
int Bl
Definition kutil.h:352
LSet B
Definition kutil.h:328
bool found
void deleteInL(LSet set, int *length, int j, kStrategy strat)
Definition kutil.cc:1215
#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 1263 of file kInline.h.

1264{
1265 return FALSE;
1266}

◆ bba()

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

Definition at line 2626 of file kstd2.cc.

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

◆ bbaShift()

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

Definition at line 4595 of file kstd2.cc.

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

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

◆ 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}
int l
Definition cfEzgcd.cc:100
BOOLEAN * pairtest
Definition kutil.h:333
char sugarCrit
Definition kutil.h:377
char Gebauer
Definition kutil.h:378
char fromT
Definition kutil.h:379
int c3
Definition kutil.h:347
BOOLEAN pCompareChain(poly p, poly p1, poly p2, poly lcm, const ring R)
Returns TRUE if.
Definition kpolys.cc:17
void kMergeBintoL(kStrategy strat)
Definition kutil.cc:3174
static BOOLEAN sugarDivisibleBy(int ecart1, int ecart2)
Definition kutil.cc:1337
BOOLEAN isInPairsetL(int length, poly p1, poly p2, int *k, kStrategy strat)
Definition kutil.cc:702
#define omFreeSize(addr, size)
#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
static BOOLEAN rIsLPRing(const ring r)
Definition ring.h:416
#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}
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 ?
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);
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}
pShallowCopyDeleteProc pGetShallowCopyDeleteProc(ring, ring)
static void p_LmFree(poly p, ring)
Definition p_polys.h:683
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 1238 of file kInline.h.

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

◆ completeReduce()

void completeReduce ( kStrategy  strat,
BOOLEAN  withT = FALSE 
)

Definition at line 10357 of file kutil.cc.

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

◆ deleteHC() [1/2]

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

Definition at line 293 of file kutil.cc.

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

◆ deleteHC() [2/2]

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

Definition at line 358 of file kutil.cc.

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

◆ 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 set[*length].Init();
1273#endif
1274 (*length)--;
1275}
static BOOLEAN length(leftv result, leftv arg)
Definition interval.cc:257
int kFindInT(poly p, TSet T, int tlength)
returns index of p in TSet, or -1 if not found
Definition kutil.cc:718
static BOOLEAN is_shifted_p1(const poly p, const kStrategy strat)
Definition kutil.cc:1188
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}
intset lenS
Definition kutil.h:319
intset ecartS
Definition kutil.h:309
wlen_set lenSw
Definition kutil.h:320
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();
4290 for (int i = 1; i <= rVar(currRing); i++)
4291 {
4292 pSetExp(tmp, i, p_GetExp(p, i, strat->tailRing));
4293 }
4295 {
4297 }
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}
int Lmax
Definition kutil.h:351
static FORCE_INLINE number n_Gcd(number a, number b, const coeffs r)
in Z: return the gcd of 'a' and 'b' in Z/nZ, Z/2^kZ: computed as in the case Z in Z/pZ,...
Definition coeffs.h:668
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:683
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:542
KINLINE poly k_LmInit_currRing_2_tailRing(poly p, ring tailRing, omBin tailBin)
Definition kInline.h:958
void enterL(LSet *set, int *length, int *LSetmax, LObject p, int at)
Definition kutil.cc:1280
#define __p_GetComp(p, r)
Definition monomials.h:63
#define rRing_has_Comp(r)
Definition monomials.h:266
#define __pp_Mult_nn(p, n, r)
Definition p_polys.h:1002
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition p_polys.h:247
static void p_Setm(poly p, const ring r)
Definition p_polys.h:233
static poly p_LmFreeAndNext(poly p, ring)
Definition p_polys.h:711
#define p_Test(p, r)
Definition p_polys.h:161
#define pInit()
allocates a new monomial and initializes everything to 0
Definition polys.h:61
#define pSetExp(p, i, v)
Definition polys.h:42
int gcd(int a, int b)

◆ 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();
4374 for (int i = 1; i <= rVar(currRing); i++)
4375 {
4376 pSetExp(tmp, i, p_GetExp(p, i, strat->tailRing));
4377 }
4379 {
4381 }
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
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}
bool sigdrop
Definition kutil.h:359
int(* posInLSba)(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition kutil.h:282
int redRing(LObject *h, kStrategy strat)
Definition kstd2.cc:951
#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}
static void enlargeL(LSet *L, int *length, const int incr)
Definition kutil.cc:683
#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 {
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 (
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
2202 {
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}
static int si_max(const int a, const int b)
Definition auxiliary.h:124
int cp
Definition kutil.h:347
void(* initEcartPair)(LObject *h, poly f, poly g, int ecartF, int ecartG)
Definition kutil.h:287
int Bmax
Definition kutil.h:352
poly ksCreateShortSpoly(poly p1, poly p2, ring tailRing)
Definition kspoly.cc:1453
void initPairtest(kStrategy strat)
Definition kutil.cc:693
static int pDivComp(poly p, poly q)
Definition kutil.cc:183
#define ALLOW_PROD_CRIT(A)
Definition kutil.h:395
poly nc_CreateShortSpoly(poly p1, poly p2, const ring r)
@ nc_lie
Definition nc.h:18
static nc_type & ncRingType(nc_struct *p)
Definition nc.h:159
poly nc_p_Bracket_qq(poly p, const poly q, const ring r)
returns [p,q], destroys p
#define pSetm(p)
Definition polys.h:271
#define pHasNotCF(p1, p2)
Definition polys.h:263
void pNorm(poly p)
Definition polys.h:362
#define pCopy(p)
return a copy of the poly
Definition polys.h:185
#define pLcm(a, b, m)
Definition polys.h:295
void pLcmRat(poly a, poly b, poly m, int rat_shift)
Definition ratgring.cc:30
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition ring.h:405
static BOOLEAN rIsRatGRing(const ring r)
Definition ring.h:432

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

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

13046{
13047 /* h is strat->P.p, that is LObject with LM in currRing and Tail in tailRing */
13048 /* Q: what is exactly the strat->fromT ? A: a local case trick; don't need it yet*/
13049 int j=pos;
13050
13051 /* if (!(rField_is_Domain(currRing))) enterExtendedSpoly(h, strat); */ // TODO: enterExtendedSpoly not for LP yet
13052 initenterpairsShift(h,k,ecart,0,strat, atR);
13053 if ( (!strat->fromT)
13054 && ((strat->syzComp==0)
13055 ||(pGetComp(h)<=strat->syzComp)))
13056 {
13057 unsigned long h_sev = pGetShortExpVector(h);
13058 loop
13059 {
13060 if (j > k) break;
13061 // TODO this currently doesn't clear all possible elements because of commutative division
13062 if (!(strat->rightGB && strat->fromQ != NULL && strat->fromQ[j]))
13063 clearS(h,h_sev, &j,&k,strat);
13064 j++;
13065 }
13066 }
13067}
void initenterpairsShift(poly h, int k, int ecart, int isFromQ, kStrategy strat, int atR)
Definition kutil.cc:12593

◆ 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;
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}
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 8846 of file kutil.cc.

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

◆ enterSBbaShift()

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

Definition at line 8946 of file kutil.cc.

8947{
8948 enterSBba(p, atS, strat, atR);
8949
8951 for (int i = maxPossibleShift; i > 0; i--)
8952 {
8953 // NOTE: don't use "shared tails" here. In rare cases it can cause problems
8954 // in `kNF2` because of lazy poly normalizations.
8955 LObject qq(p_Copy(p.p, strat->tailRing));
8956 p_mLPshift(qq.p, i, strat->tailRing);
8957 qq.shift = i;
8958 strat->initEcart(&qq); // initEcartBBA sets length, pLength, FDeg and ecart
8959 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
8960 enterSBba(qq, atS, strat, -1);
8961 }
8962}
void enterSBba(LObject &p, int atS, kStrategy strat, int atR)
Definition kutil.cc:8846
int p_mLPmaxPossibleShift(poly p, const ring r)
Definition shiftgb.cc:45
void p_mLPshift(poly m, int sh, const ring ri)
Definition shiftop.cc:362

◆ entersets()

void entersets ( LObject  h)

◆ enterSSba()

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

Definition at line 8969 of file kutil.cc.

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

◆ enterSyz()

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

Definition at line 9397 of file kutil.cc.

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

◆ enterT()

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

Definition at line 9195 of file kutil.cc.

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

◆ enterT_strong()

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

Definition at line 9295 of file kutil.cc.

9296{
9298 int i;
9299
9300 pp_Test(p.p, currRing, p.tailRing);
9301 assume(strat->tailRing == p.tailRing);
9302 // redMoraNF complains about this -- but, we don't really
9303 // need this so far
9304 assume(p.pLength == 0 || (int)pLength(p.p) == p.pLength || rIsSyzIndexRing(currRing)); // modulo syzring
9305 assume(p.FDeg == p.pFDeg());
9306 assume(!p.is_normalized || nIsOne(pGetCoeff(p.p)));
9307
9308#ifdef KDEBUG
9309 // do not put an LObject twice into T:
9310 for(i=strat->tl;i>=0;i--)
9311 {
9312 if (p.p==strat->T[i].p)
9313 {
9314 printf("already in T at pos %d of %d, atT=%d\n",i,strat->tl,atT);
9315 return;
9316 }
9317 }
9318#endif
9319
9320#ifdef HAVE_TAIL_RING
9321 if (currRing!=strat->tailRing)
9322 {
9323 p.t_p=p.GetLmTailRing();
9324 }
9325#endif
9326 strat->newt = TRUE;
9327 if (atT < 0)
9328 atT = strat->posInT(strat->T, strat->tl, p);
9329 if (strat->tl == strat->tmax-1)
9330 enlargeT(strat->T,strat->R,strat->sevT,strat->tmax,setmaxTinc);
9331 if (atT <= strat->tl)
9332 {
9333#ifdef ENTER_USE_MEMMOVE
9334 memmove(&(strat->T[atT+1]), &(strat->T[atT]),
9335 (strat->tl-atT+1)*sizeof(TObject));
9336 memmove(&(strat->sevT[atT+1]), &(strat->sevT[atT]),
9337 (strat->tl-atT+1)*sizeof(unsigned long));
9338#endif
9339 for (i=strat->tl+1; i>=atT+1; i--)
9340 {
9341#ifndef ENTER_USE_MEMMOVE
9342 strat->T[i] = strat->T[i-1];
9343 strat->sevT[i] = strat->sevT[i-1];
9344#endif
9345 strat->R[strat->T[i].i_r] = &(strat->T[i]);
9346 }
9347 }
9348
9349 if ((strat->tailBin != NULL) && (pNext(p.p) != NULL))
9350 {
9352 (strat->tailRing != NULL ?
9353 strat->tailRing : currRing),
9354 strat->tailBin);
9355 if (p.t_p != NULL) pNext(p.t_p) = pNext(p.p);
9356 }
9357 strat->T[atT] = (TObject) p;
9358 //printf("\nenterT_strong: add new: length = %i, ecart = %i\n",p.length,p.ecart);
9359
9360 if (pNext(p.p) != NULL)
9361 strat->T[atT].max_exp = p_GetMaxExpP(pNext(p.p), strat->tailRing);
9362 else
9363 strat->T[atT].max_exp = NULL;
9364
9365 strat->tl++;
9366 strat->R[strat->tl] = &(strat->T[atT]);
9367 strat->T[atT].i_r = strat->tl;
9368 assume(p.sev == 0 || pGetShortExpVector(p.p) == p.sev);
9369 strat->sevT[atT] = (p.sev == 0 ? pGetShortExpVector(p.p) : p.sev);
9370 #if 1
9372 && !n_IsUnit(p.p->coef, currRing->cf))
9373 {
9374 for(i=strat->tl;i>=0;i--)
9375 {
9376 if(strat->T[i].ecart <= p.ecart && pLmDivisibleBy(strat->T[i].p,p.p))
9377 {
9378 enterOneStrongPoly(i,p.p,p.ecart,0,strat,0 , TRUE);
9379 }
9380 }
9381 }
9382 /*
9383 printf("\nThis is T:\n");
9384 for(i=strat->tl;i>=0;i--)
9385 {
9386 pWrite(strat->T[i].p);
9387 }
9388 //getchar();*/
9389 #endif
9390 kTest_T(&(strat->T[atT]),strat);
9391}
static FORCE_INLINE BOOLEAN n_IsUnit(number n, const coeffs r)
TRUE iff n has a multiplicative inverse in the given coeff field/ring r.
Definition coeffs.h:519
static BOOLEAN enterOneStrongPoly(int i, poly p, int, int, kStrategy strat, int atR, bool enterTstrong)
Definition kutil.cc:1550
#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 13075 of file kutil.cc.

13076{
13077 /* determine how many elements we have to insert */
13078 /* x(0)y(1)z(2) : lastVblock-1=2, to add until lastVblock=uptodeg-1 */
13079 /* hence, a total number of elt's to add is: */
13080 /* int toInsert = 1 + (uptodeg-1) - (pLastVblock(p.p, lV) -1); */
13081 pAssume(p.p != NULL);
13082
13084
13085 for (int i = 1; i <= maxPossibleShift; i++)
13086 {
13087 LObject qq;
13088 qq.p = pLPCopyAndShiftLM(p.p, i); // don't use Set() because it'll test the poly order
13089 qq.shift = i;
13090 strat->initEcart(&qq); // initEcartBBA sets length, pLength, FDeg and ecart
13091
13092 enterT(qq, strat, atT); // enterT is modified, so it doesn't copy and delete the tail of shifted polys
13093 }
13094}
#define pAssume(cond)
Definition monomials.h:90
#define pLPCopyAndShiftLM(p, sh)
Definition shiftgb.h:15

◆ exitBuchMora()

void exitBuchMora ( kStrategy  strat)

Definition at line 9902 of file kutil.cc.

9903{
9904 /*- release temp data -*/
9905 cleanT(strat);
9906 omFreeSize(strat->T,(strat->tmax)*sizeof(TObject));
9907 omFreeSize(strat->R,(strat->tmax)*sizeof(TObject*));
9908 omFreeSize(strat->sevT, (strat->tmax)*sizeof(unsigned long));
9909 omFreeSize(strat->ecartS,IDELEMS(strat->Shdl)*sizeof(int));
9910 omFreeSize((ADDRESS)strat->sevS,IDELEMS(strat->Shdl)*sizeof(unsigned long));
9911 omFreeSize(strat->S_2_R,IDELEMS(strat->Shdl)*sizeof(int));
9912 /*- set L: should be empty -*/
9913 omFreeSize(strat->L,(strat->Lmax)*sizeof(LObject));
9914 /*- set B: should be empty -*/
9915 omFreeSize(strat->B,(strat->Bmax)*sizeof(LObject));
9916 pLmFree(&strat->tail);
9917 strat->syzComp=0;
9918
9919#ifdef HAVE_SHIFTBBA
9920 if (rIsLPRing(currRing) && strat->rightGB)
9921 {
9922 if (strat->fromQ!=NULL) omFreeSize(strat->fromQ,IDELEMS(strat->Shdl)*sizeof(int));
9923 strat->fromQ=NULL;
9924 }
9925#endif
9926}

◆ exitSba()

void exitSba ( kStrategy  strat)

Definition at line 10105 of file kutil.cc.

10106{
10107 /*- release temp data -*/
10109 cleanTSbaRing(strat);
10110 else
10111 cleanT(strat);
10112 omFreeSize(strat->T,(strat->tmax)*sizeof(TObject));
10113 omFreeSize(strat->R,(strat->tmax)*sizeof(TObject*));
10114 omFreeSize(strat->sevT, (strat->tmax)*sizeof(unsigned long));
10115 omFreeSize(strat->ecartS,IDELEMS(strat->Shdl)*sizeof(int));
10116 omFreeSize((ADDRESS)strat->sevS,IDELEMS(strat->Shdl)*sizeof(unsigned long));
10117 omFreeSize((ADDRESS)strat->sevSig,IDELEMS(strat->Shdl)*sizeof(unsigned long));
10118 if(strat->syzmax>0)
10119 {
10120 omFreeSize((ADDRESS)strat->syz,(strat->syzmax)*sizeof(poly));
10121 omFreeSize((ADDRESS)strat->sevSyz,(strat->syzmax)*sizeof(unsigned long));
10122 if (strat->sbaOrder == 1)
10123 {
10124 omFreeSize(strat->syzIdx,(strat->syzidxmax)*sizeof(int));
10125 }
10126 }
10127 omFreeSize(strat->S_2_R,IDELEMS(strat->Shdl)*sizeof(int));
10128 /*- set L: should be empty -*/
10129 omFreeSize(strat->L,(strat->Lmax)*sizeof(LObject));
10130 /*- set B: should be empty -*/
10131 omFreeSize(strat->B,(strat->Bmax)*sizeof(LObject));
10132 /*- set sig: no need for the signatures anymore -*/
10133 omFreeSize(strat->sig,IDELEMS(strat->Shdl)*sizeof(poly));
10134 pLmDelete(&strat->tail);
10135 strat->syzComp=0;
10136}
int syzidxmax
Definition kutil.h:349
intset syzIdx
Definition kutil.h:313
unsigned sbaOrder
Definition kutil.h:316
void cleanTSbaRing(kStrategy strat)
Definition kutil.cc: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 4283 of file kstd2.cc.

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

◆ 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");
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}
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 10945 of file kutil.cc.

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

◆ findMinLMPair()

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

◆ HEckeTest()

void HEckeTest ( poly  pp,
kStrategy  strat 
)

Definition at line 500 of file kutil.cc.

501{
502 int j,p;
503
504 if (currRing->pLexOrder
506 || (strat->ak >1)
508 {
509 return;
510 }
512 if (p!=0)
513 strat->NotUsedAxis[p] = FALSE;
514 else return; /*nothing new*/
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}
BOOLEAN * NotUsedAxis
Definition kutil.h:332
char kAllAxis
Definition kutil.h:376
#define pIsPurePower(p)
Definition polys.h:248
BOOLEAN rHasMixedOrdering(const ring r)
Definition ring.h:768

◆ 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 }
1704 {
1705 if (rField_is_Z(currRing))
1706 strat->red = redRing_Z;
1707 else
1708 strat->red = redRing;
1709 }
1710 if (TEST_OPT_IDLIFT
1711 && (!rIsNCRing(currRing))
1712 && (!rField_is_Ring(currRing)))
1713 strat->red=redLiftstd;
1714 if (currRing->pLexOrder && strat->honey)
1715 strat->initEcart = initEcartNormal;
1716 else
1717 strat->initEcart = initEcartBBA;
1718 if (strat->honey)
1720 else
1722// if ((TEST_OPT_WEIGHTM)&&(F!=NULL))
1723// {
1724// //interred machen Aenderung
1725// strat->pOrigFDeg=pFDeg;
1726// strat->pOrigLDeg=pLDeg;
1727// //h=ggetid("ecart");
1728// //if ((h!=NULL) /*&& (IDTYP(h)==INTVEC_CMD)*/)
1729// //{
1730// // ecartWeights=iv2array(IDINTVEC(h));
1731// //}
1732// //else
1733// {
1734// ecartWeights=(short *)omAlloc(((currRing->N)+1)*sizeof(short));
1735// /*uses automatic computation of the ecartWeights to set them*/
1736// kEcartWeights(F->m,IDELEMS(F)-1,ecartWeights);
1737// }
1738// pRestoreDegProcs(currRing,totaldegreeWecart, maxdegreeWecart);
1739// if (TEST_OPT_PROT)
1740// {
1741// for(i=1; i<=(currRing->N); i++)
1742// Print(" %d",ecartWeights[i]);
1743// PrintLn();
1744// mflush();
1745// }
1746// }
1747}
int LazyPass
Definition kutil.h:353
int redLiftstd(LObject *h, kStrategy strat)
Definition kLiftstd.cc:167
int redRing_Z(LObject *h, kStrategy strat)
Definition kstd2.cc:683
int redHoney(LObject *h, kStrategy strat)
Definition kstd2.cc:2074
int redHomog(LObject *h, kStrategy strat)
Definition kstd2.cc:1114
int redLazy(LObject *h, kStrategy strat)
Definition kstd2.cc:1869
void initEcartPairMora(LObject *Lp, poly, poly, int ecartF, int ecartG)
Definition kutil.cc:1326
void initEcartNormal(TObject *h)
Definition kutil.cc:1304
void initEcartBBA(TObject *h)
Definition kutil.cc:1312
void initEcartPairBba(LObject *Lp, poly, poly, int, int)
Definition kutil.cc:1319
static BOOLEAN rIsNCRing(const ring r)
Definition ring.h:426

◆ initBuchMora()

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

Definition at line 9817 of file kutil.cc.

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

◆ initBuchMoraCrit()

void initBuchMoraCrit ( kStrategy  strat)

Definition at line 9493 of file kutil.cc.

9494{
9497 if (TEST_OPT_SB_1)
9499#ifdef HAVE_RINGS
9501 {
9503 strat->chainCrit=chainCritRing;
9504 }
9505#endif
9506#ifdef HAVE_RATGRING
9507 if (rIsRatGRing(currRing))
9508 {
9509 strat->chainCrit=chainCritPart;
9510 /* enterOnePairNormal get rational part in it */
9511 }
9512#endif
9513 if (TEST_OPT_IDLIFT
9514 && (strat->syzComp==1)
9515 && (!rIsPluralRing(currRing)))
9517
9519 strat->Gebauer = strat->homog || strat->sugarCrit;
9520 strat->honey = !strat->homog || strat->sugarCrit || TEST_OPT_WEIGHTM;
9521 if (TEST_OPT_NOT_SUGAR) strat->honey = FALSE;
9522 strat->pairtest = NULL;
9523 /* always use tailreduction, except:
9524 * - in local rings, - in lex order case, -in ring over extensions */
9526 //if(rHasMixedOrdering(currRing)==2)
9527 //{
9528 // strat->noTailReduction =TRUE;
9529 //}
9530
9531#ifdef HAVE_PLURAL
9532 // and r is plural_ring
9533 // hence this holds for r a rational_plural_ring
9534 if( rIsPluralRing(currRing) || (rIsSCA(currRing) && !strat->z2homog) )
9535 { //or it has non-quasi-comm type... later
9536 strat->sugarCrit = FALSE;
9537 strat->Gebauer = FALSE;
9538 strat->honey = FALSE;
9539 }
9540#endif
9541
9542 // Coefficient ring?
9544 {
9545 strat->sugarCrit = FALSE;
9546 strat->Gebauer = FALSE;
9547 strat->honey = FALSE;
9548 }
9549 #ifdef KDEBUG
9550 if (TEST_OPT_DEBUG)
9551 {
9552 if (strat->homog) PrintS("ideal/module is homogeneous\n");
9553 else PrintS("ideal/module is not homogeneous\n");
9554 }
9555 #endif
9556}
void(* chainCrit)(poly p, int ecart, kStrategy strat)
Definition kutil.h:291
char z2homog
Definition kutil.h:374
void(* enterOnePair)(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR)
Definition kutil.h:290
void enterOnePairNormal(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR=-1)
Definition kutil.cc:1952
void chainCritOpt_1(poly, int, kStrategy strat)
Definition kutil.cc:3458
static void enterOnePairRing(int i, poly p, int, int isFromQ, kStrategy strat, int atR)
Definition kutil.cc:1346
static void enterOnePairLift(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR=-1)
Definition kutil.cc:2234
void chainCritPart(poly p, int ecart, kStrategy strat)
Definition kutil.cc:3533
void chainCritNormal(poly p, int ecart, kStrategy strat)
Definition kutil.cc:3217
void chainCritRing(poly p, int, kStrategy strat)
Definition kutil.cc:4009
static bool rIsSCA(const ring r)
Definition nc.h:190
#define TEST_OPT_WEIGHTM
Definition options.h:121
#define TEST_OPT_SUGARCRIT
Definition options.h:107
#define TEST_OPT_NOT_SUGAR
Definition options.h:106

◆ initBuchMoraPos()

void initBuchMoraPos ( kStrategy  strat)

Definition at line 9644 of file kutil.cc.

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

◆ initBuchMoraPosRing()

void initBuchMoraPosRing ( kStrategy  strat)

Definition at line 9730 of file kutil.cc.

9731{
9733 {
9734 if (strat->honey)
9735 {
9736 strat->posInL = posInL15Ring;
9737 // ok -- here is the deal: from my experiments for Singular-2-0
9738 // I conclude that that posInT_EcartpLength is the best of
9739 // posInT15, posInT_EcartFDegpLength, posInT_FDegLength, posInT_pLength
9740 // see the table at the end of this file
9741 if (TEST_OPT_OLDSTD)
9742 strat->posInT = posInT15Ring;
9743 else
9744 strat->posInT = posInT_EcartpLength;
9745 }
9746 else if (currRing->pLexOrder && !TEST_OPT_INTSTRATEGY)
9747 {
9748 strat->posInL = posInL11Ring;
9749 strat->posInT = posInT11;
9750 }
9751 else if (TEST_OPT_INTSTRATEGY)
9752 {
9753 strat->posInL = posInL11Ring;
9754 strat->posInT = posInT11;
9755 }
9756 else
9757 {
9758 strat->posInL = posInL0Ring;
9759 strat->posInT = posInT0;
9760 }
9761 //if (strat->minim>0) strat->posInL =posInLSpecial;
9762 if (strat->homog)
9763 {
9764 strat->posInL = posInL110Ring;
9765 strat->posInT = posInT110Ring;
9766 }
9767 }
9768 else
9769 {
9770 if (strat->homog)
9771 {
9772 //printf("\nHere 3\n");
9773 strat->posInL = posInL11Ring;
9774 strat->posInT = posInT11Ring;
9775 }
9776 else
9777 {
9778 if ((currRing->order[0]==ringorder_c)
9779 ||(currRing->order[0]==ringorder_C))
9780 {
9781 strat->posInL = posInL17_cRing;
9782 strat->posInT = posInT17_cRing;
9783 }
9784 else
9785 {
9786 strat->posInL = posInL11Ringls;
9787 strat->posInT = posInT17Ring;
9788 }
9789 }
9790 }
9791 if (strat->minim>0) strat->posInL =posInLSpecial;
9792 // for further tests only
9793 if ((BTEST1(11)) || (BTEST1(12)))
9794 strat->posInL = posInL11Ring;
9795 else if ((BTEST1(13)) || (BTEST1(14)))
9796 strat->posInL = posInL13;
9797 else if ((BTEST1(15)) || (BTEST1(16)))
9798 strat->posInL = posInL15Ring;
9799 else if ((BTEST1(17)) || (BTEST1(18)))
9800 strat->posInL = posInL17Ring;
9801 if (BTEST1(11))
9802 strat->posInT = posInT11Ring;
9803 else if (BTEST1(13))
9804 strat->posInT = posInT13;
9805 else if (BTEST1(15))
9806 strat->posInT = posInT15Ring;
9807 else if ((BTEST1(17)))
9808 strat->posInT = posInT17Ring;
9809 else if ((BTEST1(19)))
9810 strat->posInT = posInT19;
9811 else if (BTEST1(12) || BTEST1(14) || BTEST1(16) || BTEST1(18))
9812 strat->posInT = posInT1;
9814}
int posInL17Ring(const LSet set, const int length, LObject *p, const kStrategy)
Definition kutil.cc:6339
int posInL17_cRing(const LSet set, const int length, LObject *p, const kStrategy)
Definition kutil.cc:6454
int posInL11Ring(const LSet set, const int length, LObject *p, const kStrategy)
Definition kutil.cc:5876
int posInT110Ring(const TSet set, const int length, LObject &p)
Definition kutil.cc:5096
int posInL110Ring(const LSet set, const int length, LObject *p, const kStrategy)
Definition kutil.cc:6135
int posInL0Ring(const LSet set, const int length, LObject *p, const kStrategy)
Definition kutil.cc:5671
int posInT11Ring(const TSet set, const int length, LObject &p)
Definition kutil.cc:5012
int posInL11Ringls(const LSet set, const int length, LObject *p, const kStrategy)
Definition kutil.cc:5946
int posInL15Ring(const LSet set, const int length, LObject *p, const kStrategy)
Definition kutil.cc:6253
int posInT15Ring(const TSet set, const int length, LObject &p)
Definition kutil.cc:5265
int posInT17Ring(const TSet set, const int length, LObject &p)
Definition kutil.cc:5368
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}
static long p_FDeg(const poly p, const ring r)
Definition p_polys.h:380

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

9476{
9477
9478 //if the ordering is local, then hilb criterion
9479 //can be used also if the ideal is not homogeneous
9481 {
9483 *hilb=NULL;
9484 else
9485 return;
9486 }
9487 if (strat->homog!=isHomog)
9488 {
9489 *hilb=NULL;
9490 }
9491}
@ 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)); }
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}
#define omAlloc0(size)

◆ initS()

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

Definition at line 7635 of file kutil.cc.

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

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

◆ initSbaBuchMora()

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

Definition at line 10030 of file kutil.cc.

10031{
10032 strat->interpt = BTEST1(OPT_INTERRUPT);
10033 //strat->kNoether=NULL; // done by skStrategy
10034 /*- creating temp data structures------------------- -*/
10035 //strat->cp = 0; // done by skStrategy
10036 //strat->c3 = 0; // done by skStrategy
10037 strat->tail = pInit();
10038 /*- set s -*/
10039 strat->sl = -1;
10040 /*- set ps -*/
10041 strat->syzl = -1;
10042 /*- set L -*/
10043 strat->Lmax = ((IDELEMS(F)+setmaxLinc-1)/setmaxLinc)*setmaxLinc;
10044 strat->Ll = -1;
10045 strat->L = initL(strat->Lmax);
10046 /*- set B -*/
10047 strat->Bmax = setmaxL;
10048 strat->Bl = -1;
10049 strat->B = initL();
10050 /*- set T -*/
10051 strat->tl = -1;
10052 strat->tmax = setmaxT;
10053 strat->T = initT();
10054 strat->R = initR();
10055 strat->sevT = initsevT();
10056 /*- init local data struct.---------------------------------------- -*/
10057 //strat->P.ecart=0; // done by skStrategy
10058 //strat->P.length=0; // done by skStrategy
10060 {
10061 if (strat->kNoether!=NULL)
10062 {
10063 pSetComp(strat->kNoether, strat->ak);
10064 pSetComp(strat->kNoetherTail(), strat->ak);
10065 }
10066 }
10068 {
10069 /*Shdl=*/initSLSba(F, Q,strat); /*sets also S, ecartS, fromQ */
10070 }
10071 else
10072 {
10073 if(TEST_OPT_SB_1)
10074 {
10075 int i;
10076 ideal P=idInit(IDELEMS(F)-strat->newIdeal,F->rank);
10077 for (i=strat->newIdeal;i<IDELEMS(F);i++)
10078 {
10079 P->m[i-strat->newIdeal] = F->m[i];
10080 F->m[i] = NULL;
10081 }
10082 initSSpecialSba(F,Q,P,strat);
10083 for (i=strat->newIdeal;i<IDELEMS(F);i++)
10084 {
10085 F->m[i] = P->m[i-strat->newIdeal];
10086 P->m[i-strat->newIdeal] = NULL;
10087 }
10088 idDelete(&P);
10089 }
10090 else
10091 {
10092 initSLSba(F, Q,strat); /*sets also S, ecartS, fromQ */
10093 }
10094 }
10095 //strat->fromT = FALSE; // done by skStrategy
10096 if (!TEST_OPT_SB_1)
10097 {
10098 if(!rField_is_Ring(currRing)) updateS(TRUE,strat);
10099 }
10100 //if (strat->fromQ!=NULL) omFreeSize(strat->fromQ,IDELEMS(strat->Shdl)*sizeof(int));
10101 //strat->fromQ=NULL;
10102 assume(kTest_TS(strat));
10103}
void initSLSba(ideal F, ideal Q, kStrategy strat)
Definition kutil.cc:7831
void initSSpecialSba(ideal F, ideal Q, ideal P, kStrategy strat)
Definition kutil.cc:8288

◆ initSbaCrit()

void initSbaCrit ( kStrategy  strat)

Definition at line 9558 of file kutil.cc.

9559{
9560 //strat->enterOnePair=enterOnePairNormal;
9562 //strat->chainCrit=chainCritNormal;
9563 strat->chainCrit = chainCritSig;
9564 /******************************************
9565 * rewCrit1 and rewCrit2 are already set in
9566 * kSba() in kstd1.cc
9567 *****************************************/
9568 //strat->rewCrit1 = faugereRewCriterion;
9569 if (strat->sbaOrder == 1)
9570 {
9571 strat->syzCrit = syzCriterionInc;
9572 }
9573 else
9574 {
9575 strat->syzCrit = syzCriterion;
9576 }
9577#ifdef HAVE_RINGS
9579 {
9581 strat->chainCrit=chainCritRing;
9582 }
9583#endif
9584#ifdef HAVE_RATGRING
9585 if (rIsRatGRing(currRing))
9586 {
9587 strat->chainCrit=chainCritPart;
9588 /* enterOnePairNormal get rational part in it */
9589 }
9590#endif
9591
9593 strat->Gebauer = strat->homog || strat->sugarCrit;
9594 strat->honey = !strat->homog || strat->sugarCrit || TEST_OPT_WEIGHTM;
9595 if (TEST_OPT_NOT_SUGAR) strat->honey = FALSE;
9596 strat->pairtest = NULL;
9597 /* always use tailreduction, except:
9598 * - in local rings, - in lex order case, -in ring over extensions */
9601
9602#ifdef HAVE_PLURAL
9603 // and r is plural_ring
9604 // hence this holds for r a rational_plural_ring
9605 if( rIsPluralRing(currRing) || (rIsSCA(currRing) && !strat->z2homog) )
9606 { //or it has non-quasi-comm type... later
9607 strat->sugarCrit = FALSE;
9608 strat->Gebauer = FALSE;
9609 strat->honey = FALSE;
9610 }
9611#endif
9612
9613 // Coefficient ring?
9615 {
9616 strat->sugarCrit = FALSE;
9617 strat->Gebauer = FALSE ;
9618 strat->honey = FALSE;
9619 }
9620 #ifdef KDEBUG
9621 if (TEST_OPT_DEBUG)
9622 {
9623 if (strat->homog) PrintS("ideal/module is homogeneous\n");
9624 else PrintS("ideal/module is not homogeneous\n");
9625 }
9626 #endif
9627}
BOOLEAN(* syzCrit)(poly sig, unsigned long not_sevSig, kStrategy strat)
Definition kutil.h:292
BOOLEAN syzCriterionInc(poly sig, unsigned long not_sevSig, kStrategy strat)
Definition kutil.cc:6556
void chainCritSig(poly p, int, kStrategy strat)
Definition kutil.cc:3474
BOOLEAN syzCriterion(poly sig, unsigned long not_sevSig, kStrategy strat)
Definition kutil.cc:6521

◆ initSbaPos()

void initSbaPos ( kStrategy  strat)

Definition at line 9928 of file kutil.cc.

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

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

◆ initSLSba()

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

Definition at line 7831 of file kutil.cc.

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

◆ initSyzRules()

void initSyzRules ( kStrategy  strat)

Definition at line 7985 of file kutil.cc.

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

◆ 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}
STATIC_VAR jList * T
Definition janet.cc:30
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 1017 of file kInline.h.

1019{
1022
1023 int i;
1024 long x;
1025 m1 = p_Init(m_r,m_r->PolyBin);
1026 m2 = p_Init(m_r,m_r->PolyBin);
1027
1028 for (i = p_r->N; i; i--)
1029 {
1030 x = p_GetExpDiff(p1, p2, i, p_r);
1031 if (x > 0)
1032 {
1033 if (x > (long) m_r->bitmask) goto false_return;
1034 p_SetExp(m2,i,x, m_r);
1035 p_SetExp(m1,i,0, m_r);
1036 }
1037 else
1038 {
1039 if (-x > (long) m_r->bitmask) goto false_return;
1040 p_SetExp(m1,i,-x, m_r);
1041 p_SetExp(m2,i,0, m_r);
1042 }
1043 }
1044
1045 p_Setm(m1, m_r);
1046 p_Setm(m2, m_r);
1047 return TRUE;
1048
1050 p_LmFree(m1, m_r);
1051 p_LmFree(m2, m_r);
1052 m1 = m2 = NULL;
1053 return FALSE;
1054}
Variable x
Definition cfModGcd.cc:4090
static long p_GetExpDiff(poly p1, poly p2, int i, ring r)
Definition p_polys.h:635
BOOLEAN p_LmCheckPolyRing(poly p, ring r)
Definition pDebug.cc:123
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:488
static poly p_Init(const ring r, omBin bin)
Definition p_polys.h:1320

◆ 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 1060 of file kInline.h.

1062{
1065
1066 int i;
1067 int x;
1068 int e1;
1069 int e2;
1070 int s;
1071 m1 = p_Init(tailRing,tailRing->PolyBin);
1072 m2 = p_Init(tailRing,tailRing->PolyBin);
1073 lcm = p_Init(leadRing,leadRing->PolyBin);
1074
1075 for (i = leadRing->N; i>=0; i--)
1076 {
1077 e1 = p_GetExp(p1,i,leadRing);
1078 e2 = p_GetExp(p2,i,leadRing);
1079 x = e1 - e2;
1080 if (x > 0)
1081 {
1082 p_SetExp(m2,i,x, tailRing);
1083 //p_SetExp(m1,i,0, tailRing); // done by p_Init
1084 s = e1;
1085 }
1086 else if (x<0)
1087 {
1088 p_SetExp(m1,i,-x, tailRing);
1089 //p_SetExp(m2,i,0, tailRing); // done by p_Init
1090 s = e2;
1091 }
1092 else
1093 s = e1; // e1==e2
1095 }
1096
1097 p_Setm(m1, tailRing);
1098 p_Setm(m2, tailRing);
1100}
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 990 of file kInline.h.

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

◆ k_LmInit_currRing_2_tailRing() [2/2]

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

Definition at line 958 of file kInline.h.

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

◆ k_LmInit_tailRing_2_currRing() [1/2]

KINLINE poly k_LmInit_tailRing_2_currRing ( poly  p,
ring  tailRing 
)

Definition at line 995 of file kInline.h.

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

◆ k_LmInit_tailRing_2_currRing() [2/2]

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

Definition at line 967 of file kInline.h.

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

◆ k_LmShallowCopyDelete_currRing_2_tailRing() [1/2]

KINLINE poly k_LmShallowCopyDelete_currRing_2_tailRing ( poly  p,
ring  tailRing 
)

Definition at line 1000 of file kInline.h.

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

◆ k_LmShallowCopyDelete_currRing_2_tailRing() [2/2]

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

Definition at line 976 of file kInline.h.

977{
978 poly np = k_LmInit_currRing_2_tailRing(p, tailRing, tailBin);
980 return np;
981}

◆ k_LmShallowCopyDelete_tailRing_2_currRing() [1/2]

KINLINE poly k_LmShallowCopyDelete_tailRing_2_currRing ( poly  p,
ring  tailRing 
)

Definition at line 1005 of file kInline.h.

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

◆ k_LmShallowCopyDelete_tailRing_2_currRing() [2/2]

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

Definition at line 983 of file kInline.h.

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

◆ kCheckSpolyCreation()

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

Definition at line 10551 of file kutil.cc.

10552{
10553 if (strat->overflow) return FALSE;
10554 assume(L->p1 != NULL && L->p2 != NULL);
10555 // shift changes: from 0 to -1
10556 assume(L->i_r1 >= -1 && L->i_r1 <= strat->tl);
10557 assume(L->i_r2 >= -1 && L->i_r2 <= strat->tl);
10558
10559 if (! k_GetLeadTerms(L->p1, L->p2, currRing, m1, m2, strat->tailRing))
10560 return FALSE;
10561 // shift changes: extra case inserted
10562 if ((L->i_r1 == -1) || (L->i_r2 == -1) )
10563 {
10564 return TRUE;
10565 }
10566 poly p1_max=NULL;
10567 if ((L->i_r1>=0)&&(strat->R[L->i_r1]!=NULL)) p1_max = (strat->R[L->i_r1])->max_exp;
10568 poly p2_max=NULL;
10569 if ((L->i_r2>=0)&&(strat->R[L->i_r2]!=NULL)) p2_max = (strat->R[L->i_r2])->max_exp;
10570
10571 if (((p1_max != NULL) && !p_LmExpVectorAddIsOk(m1, p1_max, strat->tailRing)) ||
10572 ((p2_max != NULL) && !p_LmExpVectorAddIsOk(m2, p2_max, strat->tailRing)))
10573 {
10574 p_LmFree(m1, strat->tailRing);
10575 p_LmFree(m2, strat->tailRing);
10576 m1 = NULL;
10577 m2 = NULL;
10578 return FALSE;
10579 }
10580 return TRUE;
10581}
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:1017
static BOOLEAN p_LmExpVectorAddIsOk(const poly p1, const poly p2, const ring r)
Definition p_polys.h:1999

◆ kCheckStrongCreation()

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

Definition at line 10590 of file kutil.cc.

10591{
10592 assume(strat->S_2_R[atS] >= -1 && strat->S_2_R[atS] <= strat->tl);
10593 //assume(strat->tailRing != currRing);
10594
10595 poly p1_max = (strat->R[atR])->max_exp;
10596 poly p2_max = (strat->R[strat->S_2_R[atS]])->max_exp;
10597
10598 if (((p1_max != NULL) && !p_LmExpVectorAddIsOk(m1, p1_max, strat->tailRing)) ||
10599 ((p2_max != NULL) && !p_LmExpVectorAddIsOk(m2, p2_max, strat->tailRing)))
10600 {
10601 return FALSE;
10602 }
10603 return TRUE;
10604}

◆ kDebugPrint()

void kDebugPrint ( kStrategy  strat)

Output some debug info about a given strategy.

Definition at line 11577 of file kutil.cc.

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

◆ 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
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
428
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}
static BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
Definition p_polys.h:1891

◆ 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
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}
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;
330 if (L->p!=NULL)
331 {
332 const poly p=L->p;
333
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;
222 if (L->p!=NULL)
223 {
224 const ring r=currRing;
225 const poly p=L->p;
226 orest = pGetCoeff(p);
227
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}
static FORCE_INLINE number n_EucNorm(number a, const coeffs r)
Definition coeffs.h:679
static FORCE_INLINE number n_QuotRem(number a, number b, number *q, const coeffs r)
Definition coeffs.h:685
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:515
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
Definition coeffs.h:468
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}
#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
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 {
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 {
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 {
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);
632 for (int i = 1; i <= leadRing->N; i++)
633 {
634 pSetExp(tmp2, i, p_GetExp(zeroPoly, i, tailRing));
635 }
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}
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition coeffs.h:448
CFList tmp1
Definition facFqBivar.cc:75
CFList tmp2
Definition facFqBivar.cc:75
static long ind_fact_2(long arg)
Definition kstd2.cc:554
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
Definition p_polys.cc:1300
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
Definition p_polys.cc:1476
static poly p_Mult_q(poly p, poly q, const ring r)
Definition p_polys.h:1114
static poly p_Mult_mm(poly p, poly m, const ring r)
Definition p_polys.h:1051
static poly p_LmDeleteAndNext(poly p, const ring r)
Definition p_polys.h:755
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 4108 of file kstd2.cc.

4109{
4110 assume(!idIs0(q));
4111 assume(!(idIs0(F)&&(Q==NULL)));
4112// lazy_reduce flags: can be combined by |
4113//#define KSTD_NF_LAZY 1
4114 // do only a reduction of the leading term
4115//#define KSTD_NF_NONORM 4
4116 // only global: avoid normalization, return a multiply of NF
4117 poly p;
4118 int i;
4119 ideal res;
4120 int max_ind;
4121
4122 //if (idIs0(q))
4123 // return idInit(IDELEMS(q),si_max(q->rank,F->rank));
4124 //if ((idIs0(F))&&(Q==NULL))
4125 // return idCopy(q); /*F=0*/
4126 //strat->ak = idRankFreeModule(F);
4127 /*- creating temp data structures------------------- -*/
4128 BITSET save1;
4131 initBuchMoraCrit(strat);
4132 strat->initEcart = initEcartBBA;
4133#ifdef HAVE_SHIFTBBA
4134 if (rIsLPRing(currRing))
4135 {
4136 strat->enterS = enterSBbaShift;
4137 }
4138 else
4139#endif
4140 {
4141 strat->enterS = enterSBba;
4142 }
4143 /*- set S -*/
4144 strat->sl = -1;
4145#ifndef NO_BUCKETS
4147#endif
4148 /*- init local data struct.---------------------------------------- -*/
4149 /*Shdl=*/initS(F,Q,strat);
4150 /*- compute------------------------------------------------------- -*/
4151 res=idInit(IDELEMS(q),si_max(q->rank,F->rank));
4152 for (i=IDELEMS(q)-1; i>=0; i--)
4153 {
4154 if (q->m[i]!=NULL)
4155 {
4156 if (TEST_OPT_PROT) { PrintS("r");mflush(); }
4157 p = redNF(pCopy(q->m[i]),max_ind,
4159 if ((p!=NULL)&&((lazyReduce & KSTD_NF_LAZY)==0))
4160 {
4161 if (TEST_OPT_PROT) { PrintS("t"); mflush(); }
4163 {
4164 p = redtailBba_NF(p,strat);
4165 }
4166 else
4167 {
4168 si_opt_1 &= ~Sy_bit(OPT_INTSTRATEGY);
4170 }
4171 }
4172 res->m[i]=p;
4173 }
4174 //else
4175 // res->m[i]=NULL;
4176 }
4177 /*- release temp data------------------------------- -*/
4178 assume(strat->L==NULL); /* strat->L unused */
4179 assume(strat->B==NULL); /* strat->B unused */
4180 omFree(strat->sevS);
4181 omFree(strat->ecartS);
4182 assume(strat->T==NULL);//omfree(strat->T);
4183 assume(strat->sevT==NULL);//omfree(strat->sevT);
4184 assume(strat->R==NULL);//omfree(strat->R);
4185 omfree(strat->S_2_R);
4186 omfree(strat->fromQ);
4187 strat->fromQ=NULL;
4188 idDelete(&strat->Shdl);
4190 if (TEST_OPT_PROT) PrintLn();
4191 return res;
4192}
CanonicalForm res
Definition facAbsFact.cc:60
#define KSTD_NF_LAZY
Definition kstd1.h:17
#define KSTD_NF_NONORM
Definition kstd1.h:21
poly redNF(poly h, int &max_ind, int nonorm, kStrategy strat)
Definition kstd2.cc:2309
void initS(ideal F, ideal Q, kStrategy strat)
Definition kutil.cc:7635
poly redtailBba_NF(poly p, kStrategy strat)
Definition kutil.cc:7398
void enterSBbaShift(LObject &p, int atS, kStrategy strat, int atR)
Definition kutil.cc:8946
#define omfree(addr)
#define omFree(addr)
VAR unsigned si_opt_1
Definition options.c:5
#define OPT_INTSTRATEGY
Definition options.h:92
#define OPT_REDTAIL
Definition options.h:91
#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 3950 of file kstd2.cc.

3951{
3952 assume(q!=NULL);
3953 assume(!(idIs0(F)&&(Q==NULL))); // NF(q, std(0) in polynomial ring?
3954
3955// lazy_reduce flags: can be combined by |
3956//#define KSTD_NF_LAZY 1
3957 // do only a reduction of the leading term
3958//#define KSTD_NF_NONORM 4
3959 // only global: avoid normalization, return a multiply of NF
3960 poly p;
3961
3962 //if ((idIs0(F))&&(Q==NULL))
3963 // return pCopy(q); /*F=0*/
3964 //strat->ak = idRankFreeModule(F);
3965 /*- creating temp data structures------------------- -*/
3966 BITSET save1;
3969 initBuchMoraCrit(strat);
3970 strat->initEcart = initEcartBBA;
3971#ifdef HAVE_SHIFTBBA
3972 if (rIsLPRing(currRing))
3973 {
3974 strat->enterS = enterSBbaShift;
3975 }
3976 else
3977#endif
3978 {
3979 strat->enterS = enterSBba;
3980 }
3981#ifndef NO_BUCKETS
3983#endif
3984 /*- set S -*/
3985 strat->sl = -1;
3986 /*- init local data struct.---------------------------------------- -*/
3987 /*Shdl=*/initS(F,Q,strat);
3988 /*- compute------------------------------------------------------- -*/
3989 //if ((TEST_OPT_INTSTRATEGY)&&(lazyReduce==0))
3990 //{
3991 // for (i=strat->sl;i>=0;i--)
3992 // pNorm(strat->S[i]);
3993 //}
3994 kTest(strat);
3995 if (TEST_OPT_PROT) { PrintS("r"); mflush(); }
3996 if (BVERBOSE(23)) kDebugPrint(strat);
3997 int max_ind;
3999 if ((p!=NULL)&&((lazyReduce & KSTD_NF_LAZY)==0))
4000 {
4001 if (TEST_OPT_PROT) { PrintS("t"); mflush(); }
4003 {
4004 p = redtailBba_NF(p,strat);
4005 }
4006 else if (rField_is_Ring(currRing))
4007 {
4008 p = redtailBba_Ring(p,max_ind,strat);
4009 }
4010 else
4011 {
4012 si_opt_1 &= ~Sy_bit(OPT_INTSTRATEGY);
4014 }
4015 }
4016 /*- release temp data------------------------------- -*/
4017 assume(strat->L==NULL); /* strat->L unused */
4018 assume(strat->B==NULL); /* strat->B unused */
4019 omFree(strat->sevS);
4020 omFree(strat->ecartS);
4021 assume(strat->T==NULL);//omfree(strat->T);
4022 assume(strat->sevT==NULL);//omfree(strat->sevT);
4023 assume(strat->R==NULL);//omfree(strat->R);
4024 omfree(strat->S_2_R);
4025 omfree(strat->fromQ);
4026 strat->fromQ=NULL;
4027 idDelete(&strat->Shdl);
4029 if (TEST_OPT_PROT) PrintLn();
4030 return p;
4031}
KINLINE poly redtailBba_Ring(poly p, int pos, kStrategy strat)
Definition kInline.h:1226
BOOLEAN kTest(kStrategy strat)
Definition kutil.cc:1012
static BOOLEAN rField_is_Zn(const ring r)
Definition ring.h:517

◆ kNF2Bound() [1/2]

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

Definition at line 4194 of file kstd2.cc.

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

◆ kNF2Bound() [2/2]

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

Definition at line 4033 of file kstd2.cc.

4034{
4035 assume(q!=NULL);
4036 assume(!(idIs0(F)&&(Q==NULL))); // NF(q, std(0) in polynomial ring?
4037
4038// lazy_reduce flags: can be combined by |
4039//#define KSTD_NF_LAZY 1
4040 // do only a reduction of the leading term
4041//#define KSTD_NF_NONORM 4
4042 // only global: avoid normalization, return a multiply of NF
4043 poly p;
4044
4045 //if ((idIs0(F))&&(Q==NULL))
4046 // return pCopy(q); /*F=0*/
4047 //strat->ak = idRankFreeModule(F);
4048 /*- creating temp data structures------------------- -*/
4049 BITSET save1;
4052 initBuchMoraCrit(strat);
4053 strat->initEcart = initEcartBBA;
4054 strat->enterS = enterSBba;
4055#ifndef NO_BUCKETS
4057#endif
4058 /*- set S -*/
4059 strat->sl = -1;
4060 /*- init local data struct.---------------------------------------- -*/
4061 /*Shdl=*/initS(F,Q,strat);
4062 /*- compute------------------------------------------------------- -*/
4063 //if ((TEST_OPT_INTSTRATEGY)&&(lazyReduce==0))
4064 //{
4065 // for (i=strat->sl;i>=0;i--)
4066 // pNorm(strat->S[i]);
4067 //}
4068 kTest(strat);
4069 if (TEST_OPT_PROT) { PrintS("r"); mflush(); }
4070 if (BVERBOSE(23)) kDebugPrint(strat);
4071 int max_ind;
4073 if ((p!=NULL)&&((lazyReduce & KSTD_NF_LAZY)==0))
4074 {
4075 if (TEST_OPT_PROT) { PrintS("t"); mflush(); }
4077 {
4078 p = redtailBba_Z(p,max_ind,strat);
4079 }
4080 else if (rField_is_Ring(currRing))
4081 {
4082 p = redtailBba_Ring(p,max_ind,strat);
4083 }
4084 else
4085 {
4086 si_opt_1 &= ~Sy_bit(OPT_INTSTRATEGY);
4088 //p = redtailBba(p,max_ind,strat,(lazyReduce & KSTD_NF_NONORM)==0);
4089 }
4090 }
4091 /*- release temp data------------------------------- -*/
4092 assume(strat->L==NULL); /* strat->L unused */
4093 assume(strat->B==NULL); /* strat->B unused */
4094 omFree(strat->sevS);
4095 omFree(strat->ecartS);
4096 assume(strat->T==NULL);//omfree(strat->T);
4097 assume(strat->sevT==NULL);//omfree(strat->sevT);
4098 assume(strat->R==NULL);//omfree(strat->R);
4099 omfree(strat->S_2_R);
4100 omfree(strat->fromQ);
4101 strat->fromQ=NULL;
4102 idDelete(&strat->Shdl);
4104 if (TEST_OPT_PROT) PrintLn();
4105 return p;
4106}

◆ 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
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}
bool equal
Definition cfModGcd.cc:4134
int ksCheckCoeff(number *a, number *b, const coeffs r)
Definition kbuckets.cc:1504
#define nSub(n1, n2)
Definition numbers.h:22
#define nMult(n1, n2)
Definition numbers.h:17
static void p_LmDelete(poly p, const ring r)
Definition p_polys.h:723
poly p_LPCopyAndShiftLM(poly p, int sh, const ring r)
Definition shiftgb.cc:35
int p_mFirstVblock(poly p, const ring ri)
Definition shiftop.cc:478
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 {
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}
VAR int create_count
Definition kspoly.cc:28
static BOOLEAN rField_is_Domain(const ring r)
Definition ring.h:492
void k_SplitFrame(poly &m1, poly &m2, int at, const ring r)
Definition shiftop.cc:600
#define R
Definition sirandom.c:27

◆ ksOldCreateSpoly()

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

Definition at line 1195 of file kInline.h.

1196{
1197 LObject L(r);
1198 L.p1 = p1;
1199 L.p2 = p2;
1200
1202 return L.GetLmCurrRing();
1203}

◆ ksOldSpolyRed()

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

Definition at line 1175 of file kInline.h.

1176{
1177 LObject L(p2);
1178 TObject T(p1);
1179
1180 ksReducePoly(&L, &T, spNoether);
1181
1182 return L.GetLmCurrRing();
1183}
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 1185 of file kInline.h.

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

◆ ksOldSpolyTail()

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

Definition at line 1205 of file kInline.h.

1206{
1207 LObject L(q, currRing, r);
1208 TObject T(p1, currRing, r);
1209
1211}
KINLINE int ksReducePolyTail(LObject *PR, TObject *PW, LObject *Red)
Definition kInline.h:1148

◆ 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
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 {
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");
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}
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
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:476
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:561
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition coeffs.h:459
static FORCE_INLINE void n_Write(number n, const coeffs r, const BOOLEAN bShortOut=TRUE)
Definition coeffs.h:595
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
Definition coeffs.h:472
VAR int red_count
Definition kspoly.cc:27
static void nc_kBucketPolyRed_Z(kBucket_pt b, poly p, number *c, BOOLEAN reduce)
Definition nc.h:284
void nc_PolyPolyRed(poly &b, poly p, number *c, const ring r)
#define pAssume1(cond)
Definition monomials.h:171
static void p_ExpVectorSub(poly p1, poly p2, const ring r)
Definition p_polys.h:1440
static BOOLEAN p_DivisibleBy(poly a, poly b, const ring r)
Definition p_polys.h:1900
static long p_MaxComp(poly p, ring lmRing, ring tailRing)
Definition p_polys.h:292
BOOLEAN p_CheckPolyRing(poly p, ring r)
Definition pDebug.cc:115
void StringSetS(const char *st)
Definition reporter.cc:128
void StringAppendS(const char *st)
Definition reporter.cc:107
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
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 {
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
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));
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));
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);
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
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 {
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}
static void p_ExpVectorAddSub(poly p1, poly p2, poly p3, const ring r)
Definition p_polys.h:1456

◆ 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)
1015 {
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;
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
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
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
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}
int blockred
Definition kutil.h:364
#define nDiv(a, b)
Definition numbers.h:32
#define pSub(a, b)
Definition polys.h:287

◆ ksReducePolyTail() [1/2]

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

Definition at line 1148 of file kInline.h.

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

◆ 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
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}
BOOLEAN pIsMonomOf(poly p, poly m)
Definition pDebug.cc:168
BOOLEAN pHaveCommonMonoms(poly p, poly q)
Definition pDebug.cc:178

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

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

◆ kStratInitChangeTailRing()

void kStratInitChangeTailRing ( kStrategy  strat)

Definition at line 11131 of file kutil.cc.

11132{
11133 unsigned long l = 0;
11134 int i;
11135 long e;
11136
11137 assume(strat->tailRing == currRing);
11138
11139 for (i=0; i<= strat->Ll; i++)
11140 {
11141 l = p_GetMaxExpL(strat->L[i].p, currRing, l);
11142 }
11143 for (i=0; i<=strat->tl; i++)
11144 {
11145 // Hmm ... this we could do in one Step
11146 l = p_GetMaxExpL(strat->T[i].p, currRing, l);
11147 }
11149 {
11150 l *= 2;
11151 }
11152 e = p_GetMaxExp(l, currRing);
11153 if (e <= 1) e = 2;
11154 if (rIsLPRing(currRing)) e = 1;
11155
11156 kStratChangeTailRing(strat, NULL, NULL, e);
11157}
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:1178
static unsigned long p_GetMaxExp(const unsigned long l, const ring r)
Definition p_polys.h:781

◆ 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}
#define kFalseReturn(x)
Definition kutil.cc:780
BOOLEAN kTest_S(kStrategy strat)
Definition kutil.cc:1055
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{
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}
BOOLEAN kbTest(kBucket_pt bucket)
Tests.
Definition kbuckets.cc:197
int kFindInTShift(poly p, TSet T, int tlength)
Definition kutil.cc:743
#define r_assume(x)
Definition mod2.h:388
#define pFalseReturn(cond)
Definition monomials.h:139
#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;
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
886 }
887 else
888#endif
889 {
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}
static const char * kTest_LmEqual(poly p, poly t_p, ring tailRing)
Definition kutil.cc:783
#define omCheckBinAddrSize(addr, size)
#define omSizeWOfBin(bin_ptr)
static BOOLEAN p_ExpVectorEqual(poly p1, poly p2, const ring r1, const ring r2)
Definition p_polys.cc:4576

◆ 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];
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
162
163#if defined(PDEBUG) || defined(PDIV_DEBUG)
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)
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}
number ndQuotRem(number a, number b, number *r, const coeffs R)
Definition numbers.cc:356

◆ 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}
int nrsyzcrit
Definition kutil.h:360

◆ newHEdge()

BOOLEAN newHEdge ( kStrategy  strat)

Definition at line 10479 of file kutil.cc.

10480{
10481 if (currRing->pLexOrder || rHasMixedOrdering(currRing))
10482 return FALSE;
10483 int i,j;
10484 poly newNoether;
10485
10486#if 0
10487 if (currRing->weight_all_1)
10488 scComputeHC(strat->Shdl,NULL,strat->ak,strat->kNoether);
10489 else
10490 scComputeHCw(strat->Shdl,NULL,strat->ak,strat->kNoether);
10491#else
10492 scComputeHC(strat->Shdl,NULL,strat->ak,strat->kNoether);
10493#endif
10494 if (strat->kNoether==NULL) return FALSE;
10495 if (strat->t_kNoether != NULL)
10496 {
10497 p_LmFree(strat->t_kNoether, strat->tailRing);
10498 strat->t_kNoether=NULL;
10499 }
10500 if (strat->tailRing != currRing)
10502 /* compare old and new noether*/
10503 newNoether = pLmInit(strat->kNoether);
10506 for (i=1; i<=(currRing->N); i++)
10507 {
10509 }
10511 if (j < HCord) /*- statistics -*/
10512 {
10513 if (TEST_OPT_PROT)
10514 {
10515 Print("H(%d)",j);
10516 mflush();
10517 }
10518 HCord=j;
10519 #ifdef KDEBUG
10520 if (TEST_OPT_DEBUG)
10521 {
10522 Print("H(%d):",j);
10523 wrp(strat->kNoether);
10524 PrintLn();
10525 }
10526 #endif
10527 }
10528 if (pCmp(strat->kNoether,newNoether)!=1)
10529 {
10530 if (strat->kNoether!=NULL) p_LmDelete0(strat->kNoether,currRing);
10531 strat->kNoether=newNoether;
10532 if (strat->t_kNoether != NULL)
10533 {
10534 p_LmFree(strat->t_kNoether, strat->tailRing);
10535 strat->t_kNoether=NULL;
10536 }
10537 if (strat->tailRing != currRing)
10539
10540 return TRUE;
10541 }
10543 return FALSE;
10544}
void scComputeHC(ideal S, ideal Q, int ak, poly &hEdge)
Definition hdegree.cc:1076
VAR int HCord
Definition kutil.cc:246
static void p_LmDelete0(poly p, const ring r)
Definition p_polys.h:733
#define pCmp(p1, p2)
pCmp: args may be NULL returns: (p2==NULL ? 1 : (p1 == NULL ? -1 : p_LmCmp(p1, p2)))
Definition polys.h:115
#define pLmInit(p)
like pInit, except that expvector is initialized to that of p, p must be != NULL
Definition polys.h:64
#define pGetExp(p, i)
Exponent.
Definition polys.h:41
#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{
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}
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}
int lastAxis
Definition kutil.h:355
int(* posInLOld)(const LSet Ls, const int Ll, LObject *Lo, const kStrategy strat)
Definition kutil.h:288
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}
#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 {
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 {
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}
#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;
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 {
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 11452 of file kutil.cc.

11453{
11454
11455 if (length==-1) return 0;
11456
11457 int o = p.ecart;
11458 int op=p.GetpFDeg();
11459 int ol = p.GetpLength();
11460
11461 if (set[length].ecart < o)
11462 return length+1;
11463 if (set[length].ecart == o)
11464 {
11465 int oo=set[length].GetpFDeg();
11466 if ((oo < op) || ((oo==op) && (set[length].length < ol)))
11467 return length+1;
11468 }
11469
11470 int i;
11471 int an = 0;
11472 int en= length;
11473 loop
11474 {
11475 if (an >= en-1)
11476 {
11477 if (set[an].ecart > o)
11478 return an;
11479 if (set[an].ecart == o)
11480 {
11481 int oo=set[an].GetpFDeg();
11482 if((oo > op)
11483 || ((oo==op) && (set[an].pLength > ol)))
11484 return an;
11485 }
11486 return en;
11487 }
11488 i=(an+en) / 2;
11489 if (set[i].ecart > o)
11490 en=i;
11491 else if (set[i].ecart == o)
11492 {
11493 int oo=set[i].GetpFDeg();
11494 if ((oo > op)
11495 || ((oo == op) && (set[i].pLength > ol)))
11496 en=i;
11497 else
11498 an=i;
11499 }
11500 else
11501 an=i;
11502 }
11503}

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

11507{
11508
11509 if (length==-1) return 0;
11510
11511 int op=p.GetpFDeg();
11512 int ol = p.GetpLength();
11513
11514 int oo=set[length].GetpFDeg();
11515 if ((oo < op) || ((oo==op) && (set[length].length < ol)))
11516 return length+1;
11517
11518 int i;
11519 int an = 0;
11520 int en= length;
11521 loop
11522 {
11523 if (an >= en-1)
11524 {
11525 int oo=set[an].GetpFDeg();
11526 if((oo > op)
11527 || ((oo==op) && (set[an].pLength > ol)))
11528 return an;
11529 return en;
11530 }
11531 i=(an+en) / 2;
11532 int oo=set[i].GetpFDeg();
11533 if ((oo > op)
11534 || ((oo == op) && (set[i].pLength > ol)))
11535 en=i;
11536 else
11537 an=i;
11538 }
11539}

◆ posInT_pLength()

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

Definition at line 11543 of file kutil.cc.

11544{
11545 int ol = p.GetpLength();
11546 if (length==-1)
11547 return 0;
11548 if (set[length].length<p.length)
11549 return length+1;
11550
11551 int i;
11552 int an = 0;
11553 int en= length;
11554
11555 loop
11556 {
11557 if (an >= en-1)
11558 {
11559 if (set[an].pLength>ol) return an;
11560 return en;
11561 }
11562 i=(an+en) / 2;
11563 if (set[i].pLength>ol) en=i;
11564 else an=i;
11565 }
11566}

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

10781{
10782 if(!nCoeff_is_Z(currRing->cf))
10783 return;
10784 poly pH = h->GetP();
10785 poly p,pp;
10786 p = pH;
10787 bool deleted = FALSE, ok = FALSE;
10788 for(int i = 0; i<=strat->sl; i++)
10789 {
10790 p = pH;
10791 if(pNext(strat->S[i]) == NULL)
10792 {
10793 //pWrite(p);
10794 //pWrite(strat->S[i]);
10795 while(ok == FALSE && p != NULL)
10796 {
10797 if(pLmDivisibleBy(strat->S[i], p)
10799 || (rIsLPRing(currRing) && pLPLmDivisibleBy(strat->S[i], p))
10800#endif
10801 )
10802 {
10803 number dummy = n_IntMod(p->coef, strat->S[i]->coef, currRing->cf);
10805 }
10806 if(nIsZero(p->coef))
10807 {
10808 pLmDelete(&p);
10809 h->p = p;
10810 deleted = TRUE;
10811 }
10812 else
10813 {
10814 ok = TRUE;
10815 }
10816 }
10817 if (p!=NULL)
10818 {
10819 pp = pNext(p);
10820 while(pp != NULL)
10821 {
10822 if(pLmDivisibleBy(strat->S[i], pp)
10824 || (rIsLPRing(currRing) && pLPLmDivisibleBy(strat->S[i], pp))
10825#endif
10826 )
10827 {
10828 number dummy = n_IntMod(pp->coef, strat->S[i]->coef, currRing->cf);
10830 if(nIsZero(pp->coef))
10831 {
10832 pLmDelete(&pNext(p));
10833 pp = pNext(p);
10834 deleted = TRUE;
10835 }
10836 else
10837 {
10838 p = pp;
10839 pp = pNext(p);
10840 }
10841 }
10842 else
10843 {
10844 p = pp;
10845 pp = pNext(p);
10846 }
10847 }
10848 }
10849 }
10850 }
10851 h->SetLmCurrRing();
10852 if((deleted)&&(h->p!=NULL))
10853 strat->initEcart(h);
10854}

◆ postReduceByMonSig()

void postReduceByMonSig ( LObject h,
kStrategy  strat 
)

Definition at line 10856 of file kutil.cc.

10857{
10858 if(!nCoeff_is_Z(currRing->cf))
10859 return;
10860 poly hSig = h->sig;
10861 poly pH = h->GetP();
10862 poly p,pp;
10863 p = pH;
10864 bool deleted = FALSE, ok = FALSE;
10865 for(int i = 0; i<=strat->sl; i++)
10866 {
10867 p = pH;
10868 if(pNext(strat->S[i]) == NULL)
10869 {
10870 while(ok == FALSE && p!=NULL)
10871 {
10872 if(pLmDivisibleBy(strat->S[i], p))
10873 {
10874 poly sigMult = pDivideM(pHead(p),pHead(strat->S[i]));
10875 sigMult = ppMult_mm(sigMult,pCopy(strat->sig[i]));
10876 if(sigMult!= NULL && pLtCmp(hSig,sigMult) == 1)
10877 {
10878 number dummy = n_IntMod(p->coef, strat->S[i]->coef, currRing->cf);
10880 }
10881 pDelete(&sigMult);
10882 }
10883 if(nIsZero(p->coef))
10884 {
10885 pLmDelete(&p);
10886 h->p = p;
10887 deleted = TRUE;
10888 }
10889 else
10890 {
10891 ok = TRUE;
10892 }
10893 }
10894 if(p == NULL)
10895 return;
10896 pp = pNext(p);
10897 while(pp != NULL)
10898 {
10899 if(pLmDivisibleBy(strat->S[i], pp))
10900 {
10901 poly sigMult = pDivideM(pHead(p),pHead(strat->S[i]));
10902 sigMult = ppMult_mm(sigMult,pCopy(strat->sig[i]));
10903 if(sigMult!= NULL && pLtCmp(hSig,sigMult) == 1)
10904 {
10905 number dummy = n_IntMod(pp->coef, strat->S[i]->coef, currRing->cf);
10907 if(nIsZero(pp->coef))
10908 {
10909 pLmDelete(&pNext(p));
10910 pp = pNext(p);
10911 deleted = TRUE;
10912 }
10913 else
10914 {
10915 p = pp;
10916 pp = pNext(p);
10917 }
10918 }
10919 else
10920 {
10921 p = pp;
10922 pp = pNext(p);
10923 }
10924 pDelete(&sigMult);
10925 }
10926 else
10927 {
10928 p = pp;
10929 pp = pNext(p);
10930 }
10931 }
10932 }
10933 }
10934 h->SetLmCurrRing();
10935 if(deleted)
10936 strat->initEcart(h);
10937
10938}
#define ppMult_mm(p, m)
Definition polys.h:201
#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 10613 of file kutil.cc.

10614{
10615 if(!nCoeff_is_Z(currRing->cf))
10616 return NULL;
10617 ideal F = idCopy(Forig);
10618 idSkipZeroes(F);
10619 poly pmon;
10621 ideal monred = idInit(1,1);
10622 for(int i=0; i<idElem(F); i++)
10623 {
10624 if(pNext(F->m[i]) == NULL)
10625 idInsertPoly(monred, pCopy(F->m[i]));
10626 }
10627 int posconst = idPosConstant(F);
10628 if((posconst != -1) && (!nIsZero(F->m[posconst]->coef)))
10629 {
10630 idDelete(&F);
10631 idDelete(&monred);
10632 return NULL;
10633 }
10634 int idelemQ = 0;
10635 if(Q!=NULL)
10636 {
10637 idelemQ = IDELEMS(Q);
10638 for(int i=0; i<idelemQ; i++)
10639 {
10640 if(pNext(Q->m[i]) == NULL)
10641 idInsertPoly(monred, pCopy(Q->m[i]));
10642 }
10645 //the constant, if found, will be from Q
10646 if((posconst != -1) && (!nIsZero(monred->m[posconst]->coef)))
10647 {
10648 pmon = pCopy(monred->m[posconst]);
10649 idDelete(&F);
10650 idDelete(&monred);
10651 return pmon;
10652 }
10653 }
10655 nKillChar(QQ_ring->cf);
10656 QQ_ring->cf = nInitChar(n_Q, NULL);
10657 rComplete(QQ_ring,1);
10660 nMapFunc nMap = n_SetMap(origR->cf, QQ_ring->cf);
10662 for(int i = 0, j = 0; i<IDELEMS(F); i++)
10663 II->m[j++] = prMapR(F->m[i], nMap, origR, QQ_ring);
10664 for(int i = 0, j = IDELEMS(F); i<idelemQ; i++)
10665 II->m[j++] = prMapR(Q->m[i], nMap, origR, QQ_ring);
10666 ideal one = kStd(II, NULL, isNotHomog, NULL);
10667 idSkipZeroes(one);
10668 if(idIsConstant(one))
10669 {
10670 //one should be <1>
10671 for(int i = IDELEMS(II)-1; i>=0; i--)
10672 if(II->m[i] != NULL)
10673 II->m[i+1] = II->m[i];
10674 II->m[0] = pOne();
10676 poly integer = NULL;
10677 for(int i = IDELEMS(syz)-1;i>=0; i--)
10678 {
10679 if(pGetComp(syz->m[i]) == 1)
10680 {
10681 pSetComp(syz->m[i],0);
10682 if(pIsConstant(pHead(syz->m[i])))
10683 {
10684 integer = pHead(syz->m[i]);
10685 break;
10686 }
10687 }
10688 }
10690 nMapFunc nMap2 = n_SetMap(QQ_ring->cf, origR->cf);
10692 idDelete(&monred);
10693 idDelete(&F);
10695 id_Delete(&one,QQ_ring);
10696 id_Delete(&syz,QQ_ring);
10699 return pmon;
10700 }
10701 else
10702 {
10703 if(idIs0(monred))
10704 {
10705 poly mindegmon = NULL;
10706 for(int i = 0; i<IDELEMS(one); i++)
10707 {
10708 if(pNext(one->m[i]) == NULL)
10709 {
10710 if(mindegmon == NULL)
10711 mindegmon = pCopy(one->m[i]);
10712 else
10713 {
10714 if(p_Deg(one->m[i], QQ_ring) < p_Deg(mindegmon, QQ_ring))
10715 mindegmon = pCopy(one->m[i]);
10716 }
10717 }
10718 }
10719 if(mindegmon != NULL)
10720 {
10721 for(int i = IDELEMS(II)-1; i>=0; i--)
10722 if(II->m[i] != NULL)
10723 II->m[i+1] = II->m[i];
10724 II->m[0] = pCopy(mindegmon);
10726 bool found = FALSE;
10727 for(int i = IDELEMS(syz)-1;i>=0; i--)
10728 {
10729 if(pGetComp(syz->m[i]) == 1)
10730 {
10731 pSetComp(syz->m[i],0);
10732 if(pIsConstant(pHead(syz->m[i])))
10733 {
10734 pSetCoeff(mindegmon, nCopy(syz->m[i]->coef));
10735 found = TRUE;
10736 break;
10737 }
10738 }
10739 }
10740 id_Delete(&syz,QQ_ring);
10741 if (found == FALSE)
10742 {
10744 idDelete(&monred);
10745 idDelete(&F);
10747 id_Delete(&one,QQ_ring);
10749 return NULL;
10750 }
10752 nMapFunc nMap2 = n_SetMap(QQ_ring->cf, origR->cf);
10754 idDelete(&monred);
10755 idDelete(&F);
10757 id_Delete(&one,QQ_ring);
10758 id_Delete(&syz,QQ_ring);
10760 return pmon;
10761 }
10762 }
10763 }
10765 idDelete(&monred);
10766 idDelete(&F);
10768 id_Delete(&one,QQ_ring);
10770 return NULL;
10771}
@ n_Q
rational (GMP) numbers
Definition coeffs.h:30
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
Definition coeffs.h:704
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition numbers.cc:419
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition coeffs.h:80
void nKillChar(coeffs r)
undo all initialisations
Definition numbers.cc:574
ideal idSyzygies(ideal h1, tHomog h, intvec **w, BOOLEAN setSyzComp, BOOLEAN setRegularity, int *deg, GbVariant alg)
Definition ideals.cc:830
#define idIsConstant(I)
Definition ideals.h:40
BOOLEAN idInsertPoly(ideal h1, poly h2)
insert h2 into h1 (if h2 is not the zero polynomial) return TRUE iff h2 was indeed inserted
ideal idCopy(ideal A)
Definition ideals.h:60
#define idPosConstant(I)
index of generator with leading term in ground ring (if any); otherwise -1
Definition ideals.h:37
ideal kStd(ideal F, ideal Q, tHomog h, intvec **w, intvec *hilb, int syzComp, int newIdeal, intvec *vw, s_poly_proc_t sp)
Definition kstd1.cc:2475
void rChangeCurrRing(ring r)
Definition polys.cc:15
poly prMapR(poly src, nMapFunc nMap, ring src_r, ring dest_r)
Definition prCopy.cc:45
BOOLEAN rComplete(ring r, int force)
this needs to be called whenever a new ring is created: new fields in ring are created (like VarOffse...
Definition ring.cc:3466
ring rAssure_c_dp(const ring r)
Definition ring.cc:5074
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
Definition ring.cc:1423
void rDelete(ring r)
unconditionally deletes fields in r
Definition ring.cc:452
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
static int idElem(const ideal F)
number of non-zero polys in F
@ isNotHomog
Definition structs.h:36

◆ redFirstShift()

int redFirstShift ( LObject h,
kStrategy  strat 
)

Definition at line 4975 of file kstd2.cc.

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

◆ redHomog()

int redHomog ( LObject h,
kStrategy  strat 
)

Definition at line 1114 of file kstd2.cc.

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

◆ redHoney()

int redHoney ( LObject h,
kStrategy  strat 
)

Definition at line 2074 of file kstd2.cc.

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

◆ redHoneyM()

int redHoneyM ( LObject h,
kStrategy  strat 
)

◆ redLazy()

int redLazy ( LObject h,
kStrategy  strat 
)

TEST_OPT_REDTHROUGH &&

Definition at line 1869 of file kstd2.cc.

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

◆ 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());
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
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;
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}
static poly lazyComp(number *A, poly *M, poly *T, int index, poly s, int *l, const ring tailR)
Definition kLiftstd.cc:132
static void kAppend(poly t, TObject *h)
Definition kLiftstd.cc:121
#define START_REDUCE
static poly kSplitAt(int k, TObject *h, kStrategy strat)
Definition kLiftstd.cc:28
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
int kBucketCanonicalize(kBucket_pt bucket)
Canonicalizes Bpoly, i.e. converts polys of buckets into one poly in one bucket: Returns number of bu...
#define nSize(n)
Definition numbers.h:39
#define A
Definition sirandom.c:24

◆ redNF()

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

Definition at line 2309 of file kstd2.cc.

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

◆ redRing()

int redRing ( LObject h,
kStrategy  strat 
)

Definition at line 951 of file kstd2.cc.

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

◆ 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
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 */
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);
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}
int ksReducePolyLC(LObject *PR, TObject *PW, poly spNoether, number *coef, kStrategy strat)
Definition kspoly.cc:481
int kFindDivisibleByInT_Z(const kStrategy strat, const LObject *L, const int start)
Definition kstd2.cc:213
void replaceInLAndSAndT(LObject &p, int tj, kStrategy strat)
Definition kutil.cc:9104
int ksReducePolyGCD(LObject *PR, TObject *PW, poly spNoether=NULL, number *coef=NULL, kStrategy strat=NULL)
int kFindSameLMInT_Z(const kStrategy strat, const LObject *L, const int start=0)
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 1333 of file kstd2.cc.

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

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

◆ 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 ((int)__p_GetComp(Ln.p,currRing)> strat->syzComp) break;
6995 }
6996 else
6997 {
6998 if ((int)__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 {
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 {
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)
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}
#define REDTAIL_CANONICALIZE
Definition kutil.h:38
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 1213 of file kInline.h.

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

◆ 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;
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);
7454 if (With == NULL) break;
7455 cnt--;
7456 if (cnt==0)
7457 {
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();
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)
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}
KINLINE int ksReducePolyTail_Z(LObject *PR, TObject *PW, LObject *Red)
Definition kInline.h:1126

◆ redtailBba_Ring() [2/2]

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

Definition at line 1226 of file kInline.h.

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

◆ 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();
7347 if (With == NULL) break;
7348 cnt--;
7349 if (cnt==0)
7350 {
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)
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 1231 of file kInline.h.

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

◆ 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 ((int)__p_GetComp(Ln.p,currRing)> strat->syzComp) break;
7223 }
7224 else
7225 {
7226 if ((int)__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 {
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)
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 {
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)
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}
KINLINE int ksReducePolyTailLC_Z(LObject *PR, TObject *PW, LObject *Red)
Definition kInline.h:1108

◆ 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 ((int)__p_GetComp(Ln.p,currRing)> strat->syzComp) break;
7104 }
7105 else
7106 {
7107 if ((int)__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 {
7121 if (With == NULL) break;
7122 }
7123 cnt--;
7124 if (cnt==0)
7125 {
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)
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}
#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 1219 of file kInline.h.

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

◆ redtailBbaShift()

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

Definition at line 13098 of file kutil.cc.

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

◆ redtailSba()

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

Definition at line 1749 of file kstd2.cc.

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

◆ 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 }
4675 else *suc=-1;
4676}

◆ replaceInLAndSAndT()

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

Definition at line 9104 of file kutil.cc.

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

◆ sba()

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

Definition at line 2984 of file kstd2.cc.

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

◆ 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);
1727 p_LmDelete(m1, strat->tailRing);
1728 p_LmDelete(m2, strat->tailRing);
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}
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:675
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:1060
static poly pp_Mult_mm(poly p, poly m, const ring r)
Definition p_polys.h:1031

◆ sbaRing()

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

Definition at line 11159 of file kutil.cc.

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

◆ updateResult()

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

Definition at line 10145 of file kutil.cc.

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

◆ updateS()

void updateS ( BOOLEAN  toT,
kStrategy  strat 
)

Definition at line 8611 of file kutil.cc.

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

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.