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

6664{
6666 return FALSE;
6667 poly p1 = pOne();
6668 poly p2 = pOne();
6669 for (int ii=strat->sl; ii>start; ii--)
6670 {
6671 if (p_LmShortDivisibleBy(strat->sig[ii], strat->sevSig[ii], strat->P.sig, ~strat->P.sevSig, currRing))
6672 {
6673 p_ExpVectorSum(p1,strat->P.sig,strat->S[ii],currRing);
6674 p_ExpVectorSum(p2,strat->sig[ii],strat->P.p,currRing);
6675 if (!(pLmCmp(p1,p2) == 1))
6676 {
6677 pDelete(&p1);
6678 pDelete(&p2);
6679 return TRUE;
6680 }
6681 }
6682 }
6683 pDelete(&p1);
6684 pDelete(&p2);
6685 return FALSE;
6686}
#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 6688 of file kutil.cc.

6689{
6690 //Over Rings, there are still some changes to do: considering coeffs
6692 return FALSE;
6693 int found = -1;
6694 for (int i=strat->Bl; i>-1; i--)
6695 {
6696 if (pLmEqual(strat->B[i].sig,sig))
6697 {
6698 found = i;
6699 break;
6700 }
6701 }
6702 if (found != -1)
6703 {
6704 if (pLmCmp(lm,strat->B[found].GetLmCurrRing()) == -1)
6705 {
6706 deleteInL(strat->B,&strat->Bl,found,strat);
6707 }
6708 else
6709 {
6710 return TRUE;
6711 }
6712 }
6713 poly p1 = pOne();
6714 poly p2 = pOne();
6715 for (int ii=strat->sl; ii>-1; ii--)
6716 {
6717 if (p_LmShortDivisibleBy(strat->sig[ii], strat->sevSig[ii], sig, not_sevSig, currRing))
6718 {
6719 p_ExpVectorSum(p1,sig,strat->S[ii],currRing);
6720 p_ExpVectorSum(p2,strat->sig[ii],lm,currRing);
6721 if (!(pLmCmp(p1,p2) == 1))
6722 {
6723 pDelete(&p1);
6724 pDelete(&p2);
6725 return TRUE;
6726 }
6727 }
6728 }
6729 pDelete(&p1);
6730 pDelete(&p2);
6731 return FALSE;
6732}
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:1214
#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:11559
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:7511
void initBuchMora(ideal F, ideal Q, kStrategy strat)
Definition kutil.cc:9799
void enterT(LObject &p, kStrategy strat, int atT)
Definition kutil.cc:9177
BOOLEAN kTest_TS(kStrategy strat)
Definition kutil.cc:1072
void enterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
Definition kutil.cc:4508
void redtailBbaAlsoLC_Z(LObject *L, int end_pos, kStrategy strat)
Definition kutil.cc:7187
void initHilbCrit(ideal, ideal, intvec **hilb, kStrategy strat)
Definition kutil.cc:9457
void initBuchMoraPos(kStrategy strat)
Definition kutil.cc:9626
BOOLEAN kStratChangeTailRing(kStrategy strat, LObject *L, TObject *T, unsigned long expbound)
Definition kutil.cc:11020
void exitBuchMora(kStrategy strat)
Definition kutil.cc:9884
int posInS(const kStrategy strat, const int length, const poly p, const int ecart_p)
Definition kutil.cc:4684
BOOLEAN kCheckSpolyCreation(LObject *L, kStrategy strat, poly &m1, poly &m2)
Definition kutil.cc:10533
void cleanT(kStrategy strat)
Definition kutil.cc:564
void updateResult(ideal r, ideal Q, kStrategy strat)
Definition kutil.cc:10127
void superenterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
Definition kutil.cc:4477
void kStratInitChangeTailRing(kStrategy strat)
Definition kutil.cc:11113
void initBuchMoraCrit(kStrategy strat)
Definition kutil.cc:9475
void completeReduce(kStrategy strat, BOOLEAN withT)
Definition kutil.cc:10339
void initBuchMoraPosRing(kStrategy strat)
Definition kutil.cc:9712
void messageSets(kStrategy strat)
Definition kutil.cc:7584
void messageStat(int hilbcount, kStrategy strat)
Definition kutil.cc:7552
void finalReduceByMon(kStrategy strat)
used for GB over ZZ: final reduction by constant elements background: any known constant element of i...
Definition kutil.cc:10927
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 4591 of file kstd2.cc.

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

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

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

◆ chainCritSig()

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

Definition at line 3473 of file kutil.cc.

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

◆ cleanT()

void cleanT ( kStrategy strat)

Definition at line 564 of file kutil.cc.

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

10340{
10341 int i;
10342 int low = (((rHasGlobalOrdering(currRing)) && (strat->ak==0)) ? 1 : 0);
10343 LObject L;
10344
10345#ifdef KDEBUG
10346 // need to set this: during tailreductions of T[i], T[i].max is out of
10347 // sync
10348 sloppy_max = TRUE;
10349#endif
10350
10351 strat->noTailReduction = FALSE;
10352 //if(rHasMixedOrdering(currRing)) strat->noTailReduction = TRUE;
10353 if (TEST_OPT_PROT)
10354 {
10355 PrintLn();
10356// if (timerv) writeTime("standard base computed:");
10357 }
10358 if (TEST_OPT_PROT)
10359 {
10360 Print("(S:%d)",strat->sl);mflush();
10361 }
10362 for (i=strat->sl; i>=low; i--)
10363 {
10364 int end_pos=strat->sl;
10365 if ((strat->fromQ!=NULL) && (strat->fromQ[i])) continue; // do not reduce Q_i
10366 if (strat->ak==0) end_pos=i-1;
10367 TObject* T_j = strat->s_2_t(i);
10368 if ((T_j != NULL)&&(T_j->p==strat->S[i]))
10369 {
10370 L = *T_j;
10371 #ifdef KDEBUG
10372 if (TEST_OPT_DEBUG)
10373 {
10374 Print("test S[%d]:",i);
10375 p_wrp(L.p,currRing,strat->tailRing);
10376 PrintLn();
10377 }
10378 #endif
10380 strat->S[i] = redtailBba(&L, end_pos, strat, withT,FALSE /*no normalize*/);
10381 else
10382 strat->S[i] = redtail(&L, strat->sl, strat);
10383 #ifdef KDEBUG
10384 if (TEST_OPT_DEBUG)
10385 {
10386 Print("to (tailR) S[%d]:",i);
10387 p_wrp(strat->S[i],currRing,strat->tailRing);
10388 PrintLn();
10389 }
10390 #endif
10391
10392 if (strat->redTailChange)
10393 {
10394 if (T_j->max_exp != NULL) p_LmFree(T_j->max_exp, strat->tailRing);
10395 if (pNext(T_j->p) != NULL)
10396 T_j->max_exp = p_GetMaxExpP(pNext(T_j->p), strat->tailRing);
10397 else
10398 T_j->max_exp = NULL;
10399 }
10401 T_j->pCleardenom();
10402 }
10403 else
10404 {
10405 assume(currRing == strat->tailRing);
10406 #ifdef KDEBUG
10407 if (TEST_OPT_DEBUG)
10408 {
10409 Print("test S[%d]:",i);
10410 p_wrp(strat->S[i],currRing,strat->tailRing);
10411 PrintLn();
10412 }
10413 #endif
10415 strat->S[i] = redtailBba(strat->S[i], end_pos, strat, withT);
10416 else
10417 strat->S[i] = redtail(strat->S[i], strat->sl, strat);
10419 {
10421 {
10422 number n;
10423 p_Cleardenom_n(strat->S[i], currRing, n);// also does remove Content
10424 if (!nIsOne(n))
10425 {
10427 denom->n=nInvers(n);
10428 denom->next=DENOMINATOR_LIST;
10430 }
10431 nDelete(&n);
10432 }
10433 else
10434 {
10435 strat->S[i]=p_Cleardenom(strat->S[i], currRing);// also does remove Content
10436 }
10437 }
10438 #ifdef KDEBUG
10439 if (TEST_OPT_DEBUG)
10440 {
10441 Print("to (-tailR) S[%d]:",i);
10442 p_wrp(strat->S[i],currRing,strat->tailRing);
10443 PrintLn();
10444 }
10445 #endif
10446 }
10447 if (TEST_OPT_PROT)
10448 PrintS("-");
10449 }
10450 if (TEST_OPT_PROT) PrintLn();
10451#ifdef KDEBUG
10452 sloppy_max = FALSE;
10453#endif
10454}
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:6882
poly redtailBba(LObject *L, int end_pos, kStrategy strat, BOOLEAN withT, BOOLEAN normalize)
Definition kutil.cc:6958
STATIC_VAR BOOLEAN sloppy_max
Definition kutil.cc:799
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:925
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 1214 of file kutil.cc.

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

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

4249{
4250 if (nIsOne(pGetCoeff(h))) return;
4251 number gcd;
4252 number zero=n_Init(0,currRing->cf);
4253 bool go = false;
4254 if (n_DivBy(zero, pGetCoeff(h), currRing->cf))
4255 {
4256 gcd = n_Ann(pGetCoeff(h),currRing->cf);
4257 go = true;
4258 }
4259 else
4260 gcd = n_Gcd(zero, pGetCoeff(h), strat->tailRing->cf);
4261 if (go || !nIsOne(gcd))
4262 {
4263 poly p = h->next;
4264 if (!go)
4265 {
4266 number tmp = gcd;
4267 gcd = n_Ann(gcd,currRing->cf);
4268 nDelete(&tmp);
4269 }
4270 p_Test(p,strat->tailRing);
4271 p = __pp_Mult_nn(p, gcd, strat->tailRing);
4272
4273 if (p != NULL)
4274 {
4275 if (TEST_OPT_PROT)
4276 {
4277 PrintS("Z");
4278 }
4279#ifdef KDEBUG
4280 if (TEST_OPT_DEBUG)
4281 {
4282 PrintS("--- create zero spoly: ");
4283 p_wrp(h,currRing,strat->tailRing);
4284 PrintS(" ---> ");
4285 }
4286#endif
4287 poly tmp = pInit();
4289 for (int i = 1; i <= rVar(currRing); i++)
4290 {
4291 pSetExp(tmp, i, p_GetExp(p, i, strat->tailRing));
4292 }
4294 {
4296 }
4298 p = p_LmFreeAndNext(p, strat->tailRing);
4299 pNext(tmp) = p;
4300 LObject Lp;
4301 Lp.Init();
4302 Lp.p = tmp;
4303 Lp.tailRing = strat->tailRing;
4304 int posx;
4305 if (Lp.p!=NULL)
4306 {
4307 strat->initEcart(&Lp);
4308 if (strat->Ll==-1)
4309 posx =0;
4310 else
4311 posx = strat->posInL(strat->L,strat->Ll,&Lp,strat);
4312 Lp.sev = pGetShortExpVector(Lp.p);
4313 if (strat->tailRing != currRing)
4314 {
4315 Lp.t_p = k_LmInit_currRing_2_tailRing(Lp.p, strat->tailRing);
4316 }
4317#ifdef KDEBUG
4318 if (TEST_OPT_DEBUG)
4319 {
4320 p_wrp(tmp,currRing,strat->tailRing);
4321 PrintLn();
4322 }
4323#endif
4324 enterL(&strat->L,&strat->Ll,&strat->Lmax,Lp,posx);
4325 }
4326 }
4327 }
4328 nDelete(&zero);
4329 nDelete(&gcd);
4330}
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:1279
#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 4332 of file kutil.cc.

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

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

◆ enterOnePairNormal()

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

Definition at line 1951 of file kutil.cc.

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

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

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

◆ enterpairsShift()

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

Definition at line 13027 of file kutil.cc.

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

◆ enterpairsSig()

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

Definition at line 4534 of file kutil.cc.

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

◆ enterSBba()

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

Definition at line 8828 of file kutil.cc.

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

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

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

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

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

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

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

◆ exitBuchMora()

void exitBuchMora ( kStrategy strat)

Definition at line 9884 of file kutil.cc.

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

◆ exitSba()

void exitSba ( kStrategy strat)

Definition at line 10087 of file kutil.cc.

10088{
10089 /*- release temp data -*/
10091 cleanTSbaRing(strat);
10092 else
10093 cleanT(strat);
10094 omFreeSize(strat->T,(strat->tmax)*sizeof(TObject));
10095 omFreeSize(strat->R,(strat->tmax)*sizeof(TObject*));
10096 omFreeSize(strat->sevT, (strat->tmax)*sizeof(unsigned long));
10097 omFreeSize(strat->ecartS,IDELEMS(strat->Shdl)*sizeof(int));
10098 omFreeSize((ADDRESS)strat->sevS,IDELEMS(strat->Shdl)*sizeof(unsigned long));
10099 omFreeSize((ADDRESS)strat->sevSig,IDELEMS(strat->Shdl)*sizeof(unsigned long));
10100 if(strat->syzmax>0)
10101 {
10102 omFreeSize((ADDRESS)strat->syz,(strat->syzmax)*sizeof(poly));
10103 omFreeSize((ADDRESS)strat->sevSyz,(strat->syzmax)*sizeof(unsigned long));
10104 if (strat->sbaOrder == 1)
10105 {
10106 omFreeSize(strat->syzIdx,(strat->syzidxmax)*sizeof(int));
10107 }
10108 }
10109 omFreeSize(strat->S_2_R,IDELEMS(strat->Shdl)*sizeof(int));
10110 /*- set L: should be empty -*/
10111 omFreeSize(strat->L,(strat->Lmax)*sizeof(LObject));
10112 /*- set B: should be empty -*/
10113 omFreeSize(strat->B,(strat->Bmax)*sizeof(LObject));
10114 /*- set sig: no need for the signatures anymore -*/
10115 omFreeSize(strat->sig,IDELEMS(strat->Shdl)*sizeof(poly));
10116 pLmDelete(&strat->tail);
10117 strat->syzComp=0;
10118}
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:623

◆ 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 4279 of file kstd2.cc.

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

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

10928{
10929 assume(strat->tl<0); /* can only be called with no elements in T:
10930 i.e. after exitBuchMora */
10931 /* do not use strat->S, strat->sl as they may be out of sync*/
10932 if(!nCoeff_is_Z(currRing->cf))
10933 return;
10934 poly p,pp;
10935 for(int j = 0; j<IDELEMS(strat->Shdl); j++)
10936 {
10937 if((strat->Shdl->m[j]!=NULL)&&(pNext(strat->Shdl->m[j]) == NULL))
10938 {
10939 for(int i = 0; i<IDELEMS(strat->Shdl); i++)
10940 {
10941 if((i != j) && (strat->Shdl->m[i] != NULL))
10942 {
10943 p = strat->Shdl->m[i];
10944 while((p!=NULL) && (pLmDivisibleBy(strat->Shdl->m[j], p)
10945#if HAVE_SHIFTBBA
10946 || (rIsLPRing(currRing) && pLPLmDivisibleBy(strat->Shdl->m[j], p))
10947#endif
10948 ))
10949 {
10950 number dummy = n_IntMod(p->coef, strat->Shdl->m[j]->coef, currRing->cf);
10951 if (!nEqual(dummy,p->coef))
10952 {
10953 if (nIsZero(dummy))
10954 {
10955 nDelete(&dummy);
10956 pLmDelete(&strat->Shdl->m[i]);
10957 p=strat->Shdl->m[i];
10958 }
10959 else
10960 {
10962 break;
10963 }
10964 }
10965 else
10966 {
10967 nDelete(&dummy);
10968 break;
10969 }
10970 }
10971 if (p!=NULL)
10972 {
10973 pp = pNext(p);
10974 while(pp != NULL)
10975 {
10976 if(pLmDivisibleBy(strat->Shdl->m[j], pp)
10977#if HAVE_SHIFTBBA
10978 || (rIsLPRing(currRing) && pLPLmDivisibleBy(strat->Shdl->m[j], pp))
10979#endif
10980 )
10981 {
10982 number dummy = n_IntMod(pp->coef, strat->Shdl->m[j]->coef, currRing->cf);
10983 if (!nEqual(dummy,pp->coef))
10984 {
10986 if(nIsZero(pp->coef))
10987 {
10988 pLmDelete(&pNext(p));
10989 pp = pNext(p);
10990 }
10991 else
10992 {
10993 p = pp;
10994 pp = pNext(p);
10995 }
10996 }
10997 else
10998 {
10999 nDelete(&dummy);
11000 p = pp;
11001 pp = pNext(p);
11002 }
11003 }
11004 else
11005 {
11006 p = pp;
11007 pp = pNext(p);
11008 }
11009 }
11010 }
11011 }
11012 }
11013 //idPrint(strat->Shdl);
11014 }
11015 }
11016 idSkipZeroes(strat->Shdl);
11017}
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,/*k,*/p;
503
504 if (currRing->pLexOrder
506 || (strat->ak >1)
508 {
509 return;
510 }
512 if (p!=0)
513 strat->NotUsedAxis[p] = FALSE;
514 /*- the leading term of pp is a power of the p-th variable -*/
515 for (j=(currRing->N);j>0; j--)
516 {
517 if (strat->NotUsedAxis[j])
518 {
519 strat->kAllAxis=FALSE;
520 return;
521 }
522 }
523 strat->kAllAxis=TRUE;
524}
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:1325
void initEcartNormal(TObject *h)
Definition kutil.cc:1303
void initEcartBBA(TObject *h)
Definition kutil.cc:1311
void initEcartPairBba(LObject *Lp, poly, poly, int, int)
Definition kutil.cc:1318
static BOOLEAN rIsNCRing(const ring r)
Definition ring.h:426

◆ initBuchMora()

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

Definition at line 9799 of file kutil.cc.

9800{
9801 strat->interpt = BTEST1(OPT_INTERRUPT);
9802 /*- creating temp data structures------------------- -*/
9803 //strat->cp = 0; // already by skStragy()
9804 //strat->c3 = 0; // already by skStragy()
9805#ifdef HAVE_SHIFTBBA
9806 strat->cv = 0; // already by skStragy()
9807#endif
9808 strat->tail = pInit();
9809 /*- set s -*/
9810 strat->sl = -1;
9811 /*- set L -*/
9812 strat->Lmax = ((IDELEMS(F)+setmaxLinc-1)/setmaxLinc)*setmaxLinc;
9813 strat->Ll = -1;
9814 strat->L = initL(strat->Lmax);
9815 /*- set B -*/
9816 strat->Bmax = setmaxL;
9817 strat->Bl = -1;
9818 strat->B = initL();
9819 /*- set T -*/
9820 strat->tl = -1;
9821 strat->tmax = setmaxT;
9822 strat->T = initT();
9823 strat->R = initR();
9824 strat->sevT = initsevT();
9825 /*- init local data struct.---------------------------------------- -*/
9826 //strat->P.ecart=0; // already by skStragy()
9827 //strat->P.length=0; // already by skStragy()
9828 //strat->P.pLength=0; // already by skStragy()
9830 {
9831 if (strat->kNoether!=NULL)
9832 {
9833 pSetComp(strat->kNoether, strat->ak);
9834 pSetComp(strat->kNoetherTail(), strat->ak);
9835 }
9836 }
9838 {
9839 /*Shdl=*/initSL(F, Q,strat); /*sets also S, ecartS, fromQ */
9840 }
9841 else
9842 {
9843 if(TEST_OPT_SB_1)
9844 {
9845 int i;
9846 ideal P=idInit(IDELEMS(F)-strat->newIdeal,F->rank);
9847 for (i=strat->newIdeal;i<IDELEMS(F);i++)
9848 {
9849 P->m[i-strat->newIdeal] = F->m[i];
9850 F->m[i] = NULL;
9851 }
9852 initSSpecial(F,Q,P,strat);
9853 for (i=strat->newIdeal;i<IDELEMS(F);i++)
9854 {
9855 F->m[i] = P->m[i-strat->newIdeal];
9856 P->m[i-strat->newIdeal] = NULL;
9857 }
9858 idDelete(&P);
9859 }
9860 else
9861 {
9862 /*Shdl=*/initSL(F, Q,strat); /*sets also S, ecartS, fromQ */
9863 // /*Shdl=*/initS(F, Q,strat); /*sets also S, ecartS, fromQ */
9864 }
9865 }
9866 strat->fromT = FALSE;
9868 if ((!TEST_OPT_SB_1)
9870 )
9871 {
9872 updateS(TRUE,strat);
9873 }
9874#ifdef HAVE_SHIFTBBA
9875 if (!(rIsLPRing(currRing) && strat->rightGB)) // for right GB, we need to check later whether a poly is from Q
9876#endif
9877 {
9878 if (strat->fromQ!=NULL) omFreeSize(strat->fromQ,IDELEMS(strat->Shdl)*sizeof(int));
9879 strat->fromQ=NULL;
9880 }
9881 assume(kTest_TS(strat));
9882}
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:8130
void updateS(BOOLEAN toT, kStrategy strat)
Definition kutil.cc:8593
void initSL(ideal F, ideal Q, kStrategy strat)
Definition kutil.cc:7728
#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 9475 of file kutil.cc.

9476{
9479 if (TEST_OPT_SB_1)
9481#ifdef HAVE_RINGS
9483 {
9485 strat->chainCrit=chainCritRing;
9486 }
9487#endif
9488#ifdef HAVE_RATGRING
9489 if (rIsRatGRing(currRing))
9490 {
9491 strat->chainCrit=chainCritPart;
9492 /* enterOnePairNormal get rational part in it */
9493 }
9494#endif
9495 if (TEST_OPT_IDLIFT
9496 && (strat->syzComp==1)
9497 && (!rIsPluralRing(currRing)))
9499
9501 strat->Gebauer = strat->homog || strat->sugarCrit;
9502 strat->honey = !strat->homog || strat->sugarCrit || TEST_OPT_WEIGHTM;
9503 if (TEST_OPT_NOT_SUGAR) strat->honey = FALSE;
9504 strat->pairtest = NULL;
9505 /* always use tailreduction, except:
9506 * - in local rings, - in lex order case, -in ring over extensions */
9508 //if(rHasMixedOrdering(currRing)==2)
9509 //{
9510 // strat->noTailReduction =TRUE;
9511 //}
9512
9513#ifdef HAVE_PLURAL
9514 // and r is plural_ring
9515 // hence this holds for r a rational_plural_ring
9516 if( rIsPluralRing(currRing) || (rIsSCA(currRing) && !strat->z2homog) )
9517 { //or it has non-quasi-comm type... later
9518 strat->sugarCrit = FALSE;
9519 strat->Gebauer = FALSE;
9520 strat->honey = FALSE;
9521 }
9522#endif
9523
9524 // Coefficient ring?
9526 {
9527 strat->sugarCrit = FALSE;
9528 strat->Gebauer = FALSE;
9529 strat->honey = FALSE;
9530 }
9531 #ifdef KDEBUG
9532 if (TEST_OPT_DEBUG)
9533 {
9534 if (strat->homog) PrintS("ideal/module is homogeneous\n");
9535 else PrintS("ideal/module is not homogeneous\n");
9536 }
9537 #endif
9538}
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:1951
void chainCritOpt_1(poly, int, kStrategy strat)
Definition kutil.cc:3457
static void enterOnePairRing(int i, poly p, int, int isFromQ, kStrategy strat, int atR)
Definition kutil.cc:1345
static void enterOnePairLift(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR=-1)
Definition kutil.cc:2233
void chainCritPart(poly p, int ecart, kStrategy strat)
Definition kutil.cc:3532
void chainCritNormal(poly p, int ecart, kStrategy strat)
Definition kutil.cc:3216
void chainCritRing(poly p, int, kStrategy strat)
Definition kutil.cc:4008
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 9626 of file kutil.cc.

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

◆ initBuchMoraPosRing()

void initBuchMoraPosRing ( kStrategy strat)

Definition at line 9712 of file kutil.cc.

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

◆ initEcartBBA()

void initEcartBBA ( TObject * h)

Definition at line 1311 of file kutil.cc.

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

◆ initEcartNormal()

void initEcartNormal ( TObject * h)

Definition at line 1303 of file kutil.cc.

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

◆ initEcartPairBba()

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

Definition at line 1318 of file kutil.cc.

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

◆ initEcartPairMora()

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

Definition at line 1325 of file kutil.cc.

1326{
1327 Lp->FDeg = Lp->pFDeg();
1328 (*Lp).ecart = si_max(ecartF,ecartG);
1329 (*Lp).ecart = (*Lp).ecart- (Lp->FDeg -p_FDeg((*Lp).lcm,currRing));
1330 (*Lp).length = 0;
1331}
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 3821 of file kutil.cc.

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

◆ initHilbCrit()

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

Definition at line 9457 of file kutil.cc.

9458{
9459
9460 //if the ordering is local, then hilb criterion
9461 //can be used also if the ideal is not homogeneous
9463 {
9465 *hilb=NULL;
9466 else
9467 return;
9468 }
9469 if (strat->homog!=isHomog)
9470 {
9471 *hilb=NULL;
9472 }
9473}
@ 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 7634 of file kutil.cc.

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

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

◆ initSbaCrit()

void initSbaCrit ( kStrategy strat)

Definition at line 9540 of file kutil.cc.

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

◆ initSbaPos()

void initSbaPos ( kStrategy strat)

Definition at line 9910 of file kutil.cc.

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

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

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

◆ initSLSba()

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

Definition at line 7825 of file kutil.cc.

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

◆ initSyzRules()

void initSyzRules ( kStrategy strat)

Definition at line 7975 of file kutil.cc.

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

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

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

◆ kDebugPrint()

void kDebugPrint ( kStrategy strat)

Output some debug info about a given strategy.

Definition at line 11559 of file kutil.cc.

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

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

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

◆ kFindInTShift()

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

Definition at line 742 of file kutil.cc.

743{
744 int i;
745
746 for (i=0; i<=tlength; i++)
747 {
748 // in the Letterplace ring the LMs in T and L are copies thus we have to use pEqualPolys() instead of ==
749 if (pEqualPolys(T[i].p, p)) return i;
750 }
751 return -1;
752}
#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 4106 of file kstd2.cc.

4107{
4108 assume(!idIs0(q));
4109 assume(!(idIs0(F)&&(Q==NULL)));
4110// lazy_reduce flags: can be combined by |
4111//#define KSTD_NF_LAZY 1
4112 // do only a reduction of the leading term
4113//#define KSTD_NF_NONORM 4
4114 // only global: avoid normalization, return a multiply of NF
4115 poly p;
4116 int i;
4117 ideal res;
4118 int max_ind;
4119
4120 //if (idIs0(q))
4121 // return idInit(IDELEMS(q),si_max(q->rank,F->rank));
4122 //if ((idIs0(F))&&(Q==NULL))
4123 // return idCopy(q); /*F=0*/
4124 //strat->ak = idRankFreeModule(F);
4125 /*- creating temp data structures------------------- -*/
4126 BITSET save1;
4129 initBuchMoraCrit(strat);
4130 strat->initEcart = initEcartBBA;
4131#ifdef HAVE_SHIFTBBA
4132 if (rIsLPRing(currRing))
4133 {
4134 strat->enterS = enterSBbaShift;
4135 }
4136 else
4137#endif
4138 {
4139 strat->enterS = enterSBba;
4140 }
4141 /*- set S -*/
4142 strat->sl = -1;
4143#ifndef NO_BUCKETS
4145#endif
4146 /*- init local data struct.---------------------------------------- -*/
4147 /*Shdl=*/initS(F,Q,strat);
4148 /*- compute------------------------------------------------------- -*/
4149 res=idInit(IDELEMS(q),si_max(q->rank,F->rank));
4150 for (i=IDELEMS(q)-1; i>=0; i--)
4151 {
4152 if (q->m[i]!=NULL)
4153 {
4154 if (TEST_OPT_PROT) { PrintS("r");mflush(); }
4155 p = redNF(pCopy(q->m[i]),max_ind,
4157 if ((p!=NULL)&&((lazyReduce & KSTD_NF_LAZY)==0))
4158 {
4159 if (TEST_OPT_PROT) { PrintS("t"); mflush(); }
4161 {
4162 p = redtailBba_NF(p,strat);
4163 }
4164 else
4165 {
4166 si_opt_1 &= ~Sy_bit(OPT_INTSTRATEGY);
4168 }
4169 }
4170 res->m[i]=p;
4171 }
4172 //else
4173 // res->m[i]=NULL;
4174 }
4175 /*- release temp data------------------------------- -*/
4176 assume(strat->L==NULL); /* strat->L unused */
4177 assume(strat->B==NULL); /* strat->B unused */
4178 omFree(strat->sevS);
4179 omFree(strat->ecartS);
4180 assume(strat->T==NULL);//omfree(strat->T);
4181 assume(strat->sevT==NULL);//omfree(strat->sevT);
4182 assume(strat->R==NULL);//omfree(strat->R);
4183 omfree(strat->S_2_R);
4184 omfree(strat->fromQ);
4185 idDelete(&strat->Shdl);
4187 if (TEST_OPT_PROT) PrintLn();
4188 return res;
4189}
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:7634
poly redtailBba_NF(poly p, kStrategy strat)
Definition kutil.cc:7397
void enterSBbaShift(LObject &p, int atS, kStrategy strat, int atR)
Definition kutil.cc:8928
#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 idDelete(&strat->Shdl);
4028 if (TEST_OPT_PROT) PrintLn();
4029 return p;
4030}
KINLINE poly redtailBba_Ring(poly p, int pos, kStrategy strat)
Definition kInline.h:1226
BOOLEAN kTest(kStrategy strat)
Definition kutil.cc:1011
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 4191 of file kstd2.cc.

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

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

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

11021{
11022 assume((strat->tailRing == currRing) || (strat->tailRing->bitmask <= currRing->bitmask));
11023 /* initial setup or extending */
11024
11025 if (rIsLPRing(currRing)) return TRUE;
11026 if (expbound == 0) expbound = strat->tailRing->bitmask << 1;
11027 if (expbound >= currRing->bitmask) return FALSE;
11028 strat->overflow=FALSE;
11030 // Hmmm .. the condition pFDeg == p_Deg
11031 // might be too strong
11032 (strat->homog && currRing->pFDeg == p_Deg && !(rField_is_Ring(currRing))), // omit degree
11033 (strat->ak==0), // omit_comp if the input is an ideal
11034 expbound); // exp_limit
11035
11036 if (new_tailRing == currRing) return TRUE;
11037
11038 strat->pOrigFDeg_TailRing = new_tailRing->pFDeg;
11039 strat->pOrigLDeg_TailRing = new_tailRing->pLDeg;
11040
11041 if (currRing->pFDeg != currRing->pFDegOrig)
11042 {
11043 new_tailRing->pFDeg = currRing->pFDeg;
11044 new_tailRing->pLDeg = currRing->pLDeg;
11045 }
11046
11047 if (TEST_OPT_PROT)
11048 Print("[%lu:%d", (unsigned long) new_tailRing->bitmask, new_tailRing->ExpL_Size);
11049 kTest_TS(strat);
11050 assume(new_tailRing != strat->tailRing);
11051 pShallowCopyDeleteProc p_shallow_copy_delete
11053
11055
11056 int i;
11057 for (i=0; i<=strat->tl; i++)
11058 {
11059 strat->T[i].ShallowCopyDelete(new_tailRing, new_tailBin,
11060 p_shallow_copy_delete);
11061 }
11062 for (i=0; i<=strat->Ll; i++)
11063 {
11064 assume(strat->L[i].p != NULL);
11065 if (pNext(strat->L[i].p) != strat->tail)
11066 strat->L[i].ShallowCopyDelete(new_tailRing, p_shallow_copy_delete);
11067 }
11068 if ((strat->P.t_p != NULL) ||
11069 ((strat->P.p != NULL) && pNext(strat->P.p) != strat->tail))
11070 strat->P.ShallowCopyDelete(new_tailRing, p_shallow_copy_delete);
11071
11072 if ((L != NULL) && (L->tailRing != new_tailRing))
11073 {
11074 if (L->i_r < 0)
11075 L->ShallowCopyDelete(new_tailRing, p_shallow_copy_delete);
11076 else
11077 {
11078 assume(L->i_r <= strat->tl);
11079 TObject* t_l = strat->R[L->i_r];
11080 assume(t_l != NULL);
11081 L->tailRing = new_tailRing;
11082 L->p = t_l->p;
11083 L->t_p = t_l->t_p;
11084 L->max_exp = t_l->max_exp;
11085 }
11086 }
11087
11088 if ((T != NULL) && (T->tailRing != new_tailRing && T->i_r < 0))
11089 T->ShallowCopyDelete(new_tailRing, new_tailBin, p_shallow_copy_delete);
11090
11091 omMergeStickyBinIntoBin(strat->tailBin, strat->tailRing->PolyBin);
11092 if (strat->tailRing != currRing)
11094
11095 strat->tailRing = new_tailRing;
11096 strat->tailBin = new_tailBin;
11099
11100 if (strat->kNoether != NULL)
11101 {
11102 if (strat->t_kNoether != NULL)
11103 p_LmFree(strat->t_kNoether, strat->tailRing);
11105 }
11106
11107 kTest_TS(strat);
11108 if (TEST_OPT_PROT)
11109 PrintS("]");
11110 return TRUE;
11111}
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 11113 of file kutil.cc.

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

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

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

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

◆ kTest_T()

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

Definition at line 800 of file kutil.cc.

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

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

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

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

◆ messageSets()

void messageSets ( kStrategy strat)

Definition at line 7584 of file kutil.cc.

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

◆ messageStat()

void messageStat ( int hilbcount,
kStrategy strat )

Definition at line 7552 of file kutil.cc.

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

◆ messageStatSBA()

void messageStatSBA ( int hilbcount,
kStrategy strat )

Definition at line 7565 of file kutil.cc.

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

◆ newHEdge()

BOOLEAN newHEdge ( kStrategy strat)

Definition at line 10461 of file kutil.cc.

10462{
10463 if (currRing->pLexOrder || rHasMixedOrdering(currRing))
10464 return FALSE;
10465 int i,j;
10466 poly newNoether;
10467
10468#if 0
10469 if (currRing->weight_all_1)
10470 scComputeHC(strat->Shdl,NULL,strat->ak,strat->kNoether);
10471 else
10472 scComputeHCw(strat->Shdl,NULL,strat->ak,strat->kNoether);
10473#else
10474 scComputeHC(strat->Shdl,NULL,strat->ak,strat->kNoether);
10475#endif
10476 if (strat->kNoether==NULL) return FALSE;
10477 if (strat->t_kNoether != NULL)
10478 {
10479 p_LmFree(strat->t_kNoether, strat->tailRing);
10480 strat->t_kNoether=NULL;
10481 }
10482 if (strat->tailRing != currRing)
10484 /* compare old and new noether*/
10485 newNoether = pLmInit(strat->kNoether);
10488 for (i=1; i<=(currRing->N); i++)
10489 {
10491 }
10493 if (j < HCord) /*- statistics -*/
10494 {
10495 if (TEST_OPT_PROT)
10496 {
10497 Print("H(%d)",j);
10498 mflush();
10499 }
10500 HCord=j;
10501 #ifdef KDEBUG
10502 if (TEST_OPT_DEBUG)
10503 {
10504 Print("H(%d):",j);
10505 wrp(strat->kNoether);
10506 PrintLn();
10507 }
10508 #endif
10509 }
10510 if (pCmp(strat->kNoether,newNoether)!=1)
10511 {
10512 if (strat->kNoether!=NULL) p_LmDelete0(strat->kNoether,currRing);
10513 strat->kNoether=newNoether;
10514 if (strat->t_kNoether != NULL)
10515 {
10516 p_LmFree(strat->t_kNoether, strat->tailRing);
10517 strat->t_kNoether=NULL;
10518 }
10519 if (strat->tailRing != currRing)
10521
10522 return TRUE;
10523 }
10525 return FALSE;
10526}
void scComputeHC(ideal S, ideal Q, int ak, poly &hEdge)
Definition hdegree.cc:1100
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 4862 of file kutil.cc.

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

◆ posInL0()

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

Definition at line 5642 of file kutil.cc.

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

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

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

◆ posInL110()

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

Definition at line 6092 of file kutil.cc.

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

◆ posInL11Ring()

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

Definition at line 5875 of file kutil.cc.

5877{
5878 if (length<0) return 0;
5879
5880 int o = p->GetpFDeg();
5881 int op = set[length].GetpFDeg();
5882
5883 if ((op > o)
5884 || ((op == o) && (pLtCmpOrdSgnDiffM(set[length].p,p->p))))
5885 return length+1;
5886 int i;
5887 int an = 0;
5888 int en= length;
5889 loop
5890 {
5891 if (an >= en-1)
5892 {
5893 op = set[an].GetpFDeg();
5894 if ((op > o)
5895 || ((op == o) && (pLtCmpOrdSgnDiffM(set[an].p,p->p))))
5896 return en;
5897 return an;
5898 }
5899 i=(an+en) / 2;
5900 op = set[i].GetpFDeg();
5901 if ((op > o)
5902 || ((op == o) && (pLtCmpOrdSgnDiffM(set[i].p,p->p))))
5903 an=i;
5904 else
5905 en=i;
5906 }
5907}
#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 5945 of file kutil.cc.

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

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

◆ posInL15()

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

Definition at line 6216 of file kutil.cc.

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

◆ posInL15Ring()

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

Definition at line 6252 of file kutil.cc.

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

◆ posInL17()

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

Definition at line 6293 of file kutil.cc.

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

◆ posInLF5C()

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

Definition at line 5820 of file kutil.cc.

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

◆ posInLF5CRing()

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

Definition at line 5909 of file kutil.cc.

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

◆ posInLSig()

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

Definition at line 5702 of file kutil.cc.

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

◆ posInLSigRing()

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

Definition at line 5727 of file kutil.cc.

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

◆ posInS()

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

Definition at line 4684 of file kutil.cc.

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

◆ posInSMonFirst()

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

Definition at line 4785 of file kutil.cc.

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

◆ posInSyz()

int posInSyz ( const kStrategy strat,
const poly sig )

Definition at line 5791 of file kutil.cc.

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

◆ posInT0()

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

Definition at line 4906 of file kutil.cc.

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

◆ posInT1()

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

Definition at line 4917 of file kutil.cc.

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

◆ posInT11()

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

Definition at line 4974 of file kutil.cc.

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

◆ posInT110()

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

Definition at line 5052 of file kutil.cc.

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

◆ posInT13()

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

Definition at line 5142 of file kutil.cc.

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

◆ posInT15()

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

Definition at line 5209 of file kutil.cc.

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

◆ posInT17()

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

Definition at line 5305 of file kutil.cc.

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

◆ posInT17_c()

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

Definition at line 5413 of file kutil.cc.

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

◆ posInT19()

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

Definition at line 5541 of file kutil.cc.

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

◆ posInT2()

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

Definition at line 4946 of file kutil.cc.

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

◆ posInT_EcartFDegpLength()

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

Definition at line 11434 of file kutil.cc.

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

◆ posInT_EcartpLength()

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

Definition at line 5171 of file kutil.cc.

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

◆ posInT_FDegpLength()

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

Definition at line 11488 of file kutil.cc.

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

◆ posInT_pLength()

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

Definition at line 11525 of file kutil.cc.

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

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

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

◆ postReduceByMonSig()

void postReduceByMonSig ( LObject * h,
kStrategy strat )

Definition at line 10838 of file kutil.cc.

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

10596{
10597 if(!nCoeff_is_Z(currRing->cf))
10598 return NULL;
10599 ideal F = idCopy(Forig);
10600 idSkipZeroes(F);
10601 poly pmon;
10603 ideal monred = idInit(1,1);
10604 for(int i=0; i<idElem(F); i++)
10605 {
10606 if(pNext(F->m[i]) == NULL)
10607 idInsertPoly(monred, pCopy(F->m[i]));
10608 }
10609 int posconst = idPosConstant(F);
10610 if((posconst != -1) && (!nIsZero(F->m[posconst]->coef)))
10611 {
10612 idDelete(&F);
10613 idDelete(&monred);
10614 return NULL;
10615 }
10616 int idelemQ = 0;
10617 if(Q!=NULL)
10618 {
10619 idelemQ = IDELEMS(Q);
10620 for(int i=0; i<idelemQ; i++)
10621 {
10622 if(pNext(Q->m[i]) == NULL)
10623 idInsertPoly(monred, pCopy(Q->m[i]));
10624 }
10627 //the constant, if found, will be from Q
10628 if((posconst != -1) && (!nIsZero(monred->m[posconst]->coef)))
10629 {
10630 pmon = pCopy(monred->m[posconst]);
10631 idDelete(&F);
10632 idDelete(&monred);
10633 return pmon;
10634 }
10635 }
10637 nKillChar(QQ_ring->cf);
10638 QQ_ring->cf = nInitChar(n_Q, NULL);
10639 rComplete(QQ_ring,1);
10642 nMapFunc nMap = n_SetMap(origR->cf, QQ_ring->cf);
10644 for(int i = 0, j = 0; i<IDELEMS(F); i++)
10645 II->m[j++] = prMapR(F->m[i], nMap, origR, QQ_ring);
10646 for(int i = 0, j = IDELEMS(F); i<idelemQ; i++)
10647 II->m[j++] = prMapR(Q->m[i], nMap, origR, QQ_ring);
10648 ideal one = kStd(II, NULL, isNotHomog, NULL);
10649 idSkipZeroes(one);
10650 if(idIsConstant(one))
10651 {
10652 //one should be <1>
10653 for(int i = IDELEMS(II)-1; i>=0; i--)
10654 if(II->m[i] != NULL)
10655 II->m[i+1] = II->m[i];
10656 II->m[0] = pOne();
10658 poly integer = NULL;
10659 for(int i = IDELEMS(syz)-1;i>=0; i--)
10660 {
10661 if(pGetComp(syz->m[i]) == 1)
10662 {
10663 pSetComp(syz->m[i],0);
10664 if(pIsConstant(pHead(syz->m[i])))
10665 {
10666 integer = pHead(syz->m[i]);
10667 break;
10668 }
10669 }
10670 }
10672 nMapFunc nMap2 = n_SetMap(QQ_ring->cf, origR->cf);
10674 idDelete(&monred);
10675 idDelete(&F);
10677 id_Delete(&one,QQ_ring);
10678 id_Delete(&syz,QQ_ring);
10681 return pmon;
10682 }
10683 else
10684 {
10685 if(idIs0(monred))
10686 {
10687 poly mindegmon = NULL;
10688 for(int i = 0; i<IDELEMS(one); i++)
10689 {
10690 if(pNext(one->m[i]) == NULL)
10691 {
10692 if(mindegmon == NULL)
10693 mindegmon = pCopy(one->m[i]);
10694 else
10695 {
10696 if(p_Deg(one->m[i], QQ_ring) < p_Deg(mindegmon, QQ_ring))
10697 mindegmon = pCopy(one->m[i]);
10698 }
10699 }
10700 }
10701 if(mindegmon != NULL)
10702 {
10703 for(int i = IDELEMS(II)-1; i>=0; i--)
10704 if(II->m[i] != NULL)
10705 II->m[i+1] = II->m[i];
10706 II->m[0] = pCopy(mindegmon);
10708 bool found = FALSE;
10709 for(int i = IDELEMS(syz)-1;i>=0; i--)
10710 {
10711 if(pGetComp(syz->m[i]) == 1)
10712 {
10713 pSetComp(syz->m[i],0);
10714 if(pIsConstant(pHead(syz->m[i])))
10715 {
10716 pSetCoeff(mindegmon, nCopy(syz->m[i]->coef));
10717 found = TRUE;
10718 break;
10719 }
10720 }
10721 }
10722 id_Delete(&syz,QQ_ring);
10723 if (found == FALSE)
10724 {
10726 idDelete(&monred);
10727 idDelete(&F);
10729 id_Delete(&one,QQ_ring);
10731 return NULL;
10732 }
10734 nMapFunc nMap2 = n_SetMap(QQ_ring->cf, origR->cf);
10736 idDelete(&monred);
10737 idDelete(&F);
10739 id_Delete(&one,QQ_ring);
10740 id_Delete(&syz,QQ_ring);
10742 return pmon;
10743 }
10744 }
10745 }
10747 idDelete(&monred);
10748 idDelete(&F);
10750 id_Delete(&one,QQ_ring);
10752 return NULL;
10753}
@ 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:2483
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 4971 of file kstd2.cc.

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

◆ 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:9086
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:10838
BOOLEAN sbaCheckGcdPair(LObject *h, kStrategy strat)
Definition kutil.cc:1699

◆ redtail() [1/2]

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

Definition at line 6882 of file kutil.cc.

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

◆ redtail() [2/2]

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

Definition at line 6952 of file kutil.cc.

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

◆ redtailBba() [1/3]

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

Definition at line 6958 of file kutil.cc.

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

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

◆ redtailBba_Ring() [1/2]

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

Definition at line 7422 of file kutil.cc.

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

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

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

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

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

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

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

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

◆ replaceInLAndSAndT()

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

Definition at line 9086 of file kutil.cc.

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

◆ 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:3814
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:4279
void initSbaPos(kStrategy strat)
Definition kutil.cc:9910
void enterpairsSig(poly h, poly hSig, int hFrom, int k, int ecart, int pos, kStrategy strat, int atR)
Definition kutil.cc:4534
void superenterpairsSig(poly h, poly hSig, int hFrom, int k, int ecart, int pos, kStrategy strat, int atR)
Definition kutil.cc:4490
ring sbaRing(kStrategy strat, const ring r, BOOLEAN, int)
Definition kutil.cc:11141
void messageStatSBA(int hilbcount, kStrategy strat)
Definition kutil.cc:7565
void initSyzRules(kStrategy strat)
Definition kutil.cc:7975
void initSbaBuchMora(ideal F, ideal Q, kStrategy strat)
Definition kutil.cc:10012
void exitSba(kStrategy strat)
Definition kutil.cc:10087
int posInIdealMonFirst(const ideal F, const poly p, int start, int end)
Definition kutil.cc:4862
void initSbaCrit(kStrategy strat)
Definition kutil.cc:9540
#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...
int F1(int a1, int &r1)
F1.

◆ sbaCheckGcdPair()

BOOLEAN sbaCheckGcdPair ( LObject * h,
kStrategy strat )

Definition at line 1699 of file kutil.cc.

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

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

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

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

4491{
4493 // enter also zero divisor * poly, if this is non zero and of smaller degree
4495 if(strat->sigdrop) return;
4496 initenterpairsSigRing(h, hSig, hFrom, k, ecart, 0, strat, atR);
4497 if(strat->sigdrop) return;
4498 initenterstrongPairsSig(h, hSig, k, ecart, 0, strat, atR);
4499 if(strat->sigdrop) return;
4500 clearSbatch(h, k, pos, strat);
4501}
void initenterpairsSigRing(poly h, poly hSig, int hFrom, int k, int ecart, int isFromQ, kStrategy strat, int atR=-1)
Definition kutil.cc:3946
static void initenterstrongPairsSig(poly h, poly hSig, int k, int ecart, int isFromQ, kStrategy strat, int atR=-1)
Definition kutil.cc:4221
void enterExtendedSpolySig(poly h, poly hSig, kStrategy strat)
Definition kutil.cc:4332

◆ syzCriterion()

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

Definition at line 6520 of file kutil.cc.

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

◆ syzCriterionInc()

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

Definition at line 6555 of file kutil.cc.

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

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

◆ updateS()

void updateS ( BOOLEAN toT,
kStrategy strat )

Definition at line 8593 of file kutil.cc.

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

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.