Macros | Typedefs | Functions | Variables
kstd1.h File Reference
#include "kernel/structs.h"
#include "polys/monomials/ring.h"

Go to the source code of this file.

Macros

#define KSTD_NF_LAZY   1
 
#define KSTD_NF_ECART   2
 
#define KSTD_NF_NONORM   4
 

Typedefs

typedef BOOLEAN(* s_poly_proc_t) (kStrategy strat)
 

Functions

ideal mora (ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
 
poly kNF1 (ideal F, ideal Q, poly q, kStrategy strat, int lazyReduce)
 
ideal kNF1 (ideal F, ideal Q, ideal q, kStrategy strat, int lazyReduce)
 
poly kNF (ideal F, ideal Q, poly p, int syzComp=0, int lazyReduce=0)
 
ideal kNF (ideal F, ideal Q, ideal p, int syzComp=0, int lazyReduce=0)
 
poly kNFBound (ideal F, ideal Q, poly p, int bound, int syzComp=0, int lazyReduce=0)
 
ideal kNFBound (ideal F, ideal Q, ideal p, int bound, int syzComp=0, int lazyReduce=0)
 
poly k_NF (ideal F, ideal Q, poly p, int syzComp, int lazyReduce, const ring _currRing)
 NOTE: this is just a wrapper which sets currRing for the actual kNF call. More...
 
ideal kSba (ideal F, ideal Q, tHomog h, intvec **mw, int incremental=0, int arri=0, intvec *hilb=NULL, int syzComp=0, int newIdeal=0, intvec *vw=NULL)
 
ideal kStd (ideal F, ideal Q, tHomog h, intvec **mw, intvec *hilb=NULL, int syzComp=0, int newIdeal=0, intvec *vw=NULL, s_poly_proc_t sp=NULL)
 
ideal kStdShift (ideal F, ideal Q, tHomog h, intvec **w, intvec *hilb, int syzComp, int newIdeal, intvec *vw)
 
void initMora (ideal F, kStrategy strat)
 
ideal kInterRed (ideal F, ideal Q=NULL)
 
ideal kInterRedOld (ideal F, ideal Q=NULL)
 
long kModDeg (poly p, ring r=currRing)
 
long kHomModDeg (poly p, ring r=currRing)
 
ideal stdred (ideal F, ideal Q, tHomog h, intvec **w)
 
ideal kMin_std (ideal F, ideal Q, tHomog h, intvec **w, ideal &M, intvec *hilb=NULL, int syzComp=0, int reduced=0)
 

Variables

int LazyPass
 
int LazyDegree
 
int Kstd1_mu
 
int Kstd1_deg
 
BITSET kOptions
 
BITSET validOpts
 
intveckModW
 
intveckHomW
 

Macro Definition Documentation

◆ KSTD_NF_ECART

#define KSTD_NF_ECART   2

Definition at line 19 of file kstd1.h.

◆ KSTD_NF_LAZY

#define KSTD_NF_LAZY   1

Definition at line 17 of file kstd1.h.

◆ KSTD_NF_NONORM

#define KSTD_NF_NONORM   4

Definition at line 21 of file kstd1.h.

Typedef Documentation

◆ s_poly_proc_t

typedef BOOLEAN(* s_poly_proc_t) (kStrategy strat)

Definition at line 14 of file kstd1.h.

Function Documentation

◆ initMora()

void initMora ( ideal  F,
kStrategy  strat 
)

Definition at line 1460 of file kstd1.cc.

1461 {
1462  int i,j;
1463 
1464  strat->NotUsedAxis = (BOOLEAN *)omAlloc(((currRing->N)+1)*sizeof(BOOLEAN));
1465  for (j=(currRing->N); j>0; j--) strat->NotUsedAxis[j] = TRUE;
1466  strat->enterS = enterSMora;
1467  strat->initEcartPair = initEcartPairMora; /*- ecart approximation -*/
1468  strat->posInLOld = strat->posInL;
1469  strat->posInLOldFlag = TRUE;
1470  strat->initEcart = initEcartNormal;
1471  strat->kHEdgeFound = (currRing->ppNoether) != NULL;
1472  if ( strat->kHEdgeFound )
1473  strat->kNoether = pCopy((currRing->ppNoether));
1474  else if (strat->kHEdgeFound || strat->homog)
1475  strat->red = redFirst; /*take the first possible in T*/
1476  else
1477  strat->red = redEcart;/*take the first possible in under ecart-restriction*/
1478  if (strat->kHEdgeFound)
1479  {
1480  strat->HCord = currRing->pFDeg((currRing->ppNoether),currRing)+1;
1481  strat->posInT = posInT2;
1482  }
1483  else
1484  {
1485  strat->HCord = 32000;/*- very large -*/
1486  }
1487 
1488  if (rField_is_Ring(currRing))
1489  strat->red = redRiloc;
1490 
1491  /*reads the ecartWeights used for Graebes method from the
1492  *intvec ecart and set ecartWeights
1493  */
1494  if ((TEST_OPT_WEIGHTM)&&(F!=NULL))
1495  {
1496  //interred machen Aenderung
1497  strat->pOrigFDeg=currRing->pFDeg;
1498  strat->pOrigLDeg=currRing->pLDeg;
1499  ecartWeights=(short *)omAlloc(((currRing->N)+1)*sizeof(short));
1500  /*uses automatic computation of the ecartWeights to set them*/
1502 
1504  if (TEST_OPT_PROT)
1505  {
1506  for(i=1; i<=(currRing->N); i++)
1507  Print(" %d",ecartWeights[i]);
1508  PrintLn();
1509  mflush();
1510  }
1511  }
1512  kOptimizeLDeg(currRing->pLDeg, strat);
1513 }
int(* posInL)(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.h:280
int j
Definition: facHensel.cc:105
char kHEdgeFound
Definition: kutil.h:374
void PrintLn()
Definition: reporter.cc:310
int posInT2(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5296
#define Print
Definition: emacs.cc:80
int redEcart(LObject *h, kStrategy strat)
Definition: kstd1.cc:166
#define TEST_OPT_PROT
Definition: options.h:102
void kEcartWeights(poly *s, int sl, short *eweight, const ring R)
Definition: weight.cc:182
long totaldegreeWecart(poly p, ring r)
Definition: weight.cc:217
short * ecartWeights
Definition: weight0.c:28
int redFirst(LObject *h, kStrategy strat)
Definition: kstd1.cc:528
BOOLEAN * NotUsedAxis
Definition: kutil.h:330
poly kNoether
Definition: kutil.h:326
#define TRUE
Definition: auxiliary.h:98
void(* initEcartPair)(LObject *h, poly f, poly g, int ecartF, int ecartG)
Definition: kutil.h:283
int(* red)(LObject *L, kStrategy strat)
Definition: kutil.h:274
#define omAlloc(size)
Definition: omAllocDecl.h:210
int(* posInT)(const TSet T, const int tl, LObject &h)
Definition: kutil.h:277
char posInLOldFlag
Definition: kutil.h:380
int HCord
Definition: kutil.h:353
#define mflush()
Definition: reporter.h:57
pFDegProc pOrigFDeg
Definition: kutil.h:292
int redRiloc(LObject *h, kStrategy strat)
Definition: kstd1.cc:342
void(* initEcart)(TObject *L)
Definition: kutil.h:276
pLDegProc pOrigLDeg
Definition: kutil.h:293
void initEcartPairMora(LObject *Lp, poly, poly, int ecartF, int ecartG)
Definition: kutil.cc:1306
void pSetDegProcs(ring r, pFDegProc new_FDeg, pLDegProc new_lDeg)
Definition: p_polys.cc:3597
void enterSMora(LObject &p, int atS, kStrategy strat, int atR=-1)
Definition: kstd1.cc:1270
void(* enterS)(LObject &h, int pos, kStrategy strat, int atR)
Definition: kutil.h:282
int i
Definition: cfEzgcd.cc:125
static void kOptimizeLDeg(pLDegProc ldeg, kStrategy strat)
Definition: kstd1.cc:97
int(* posInLOld)(const LSet Ls, const int Ll, LObject *Lo, const kStrategy strat)
Definition: kutil.h:284
#define IDELEMS(i)
Definition: simpleideals.h:23
#define TEST_OPT_WEIGHTM
Definition: options.h:119
char homog
Definition: kutil.h:370
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:479
#define NULL
Definition: omList.c:12
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
long maxdegreeWecart(poly p, int *l, ring r)
Definition: weight.cc:247
void initEcartNormal(TObject *h)
Definition: kutil.cc:1284
int BOOLEAN
Definition: auxiliary.h:85
#define pCopy(p)
return a copy of the poly
Definition: polys.h:180

◆ k_NF()

poly k_NF ( ideal  F,
ideal  Q,
poly  p,
int  syzComp,
int  lazyReduce,
const ring  _currRing 
)

NOTE: this is just a wrapper which sets currRing for the actual kNF call.

Definition at line 3033 of file kstd1.cc.

3034 {
3035  const ring save = currRing;
3036  if( currRing != _currRing ) rChangeCurrRing(_currRing);
3037  poly ret = kNF(F, Q, p, syzComp, lazyReduce);
3038  if( currRing != save ) rChangeCurrRing(save);
3039  return ret;
3040 }
poly kNF(ideal F, ideal Q, poly p, int syzComp, int lazyReduce)
Definition: kstd1.cc:2822
#define Q
Definition: sirandom.c:25
void rChangeCurrRing(ring r)
Definition: polys.cc:14
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
int p
Definition: cfModGcd.cc:4019

◆ kHomModDeg()

long kHomModDeg ( poly  p,
ring  r = currRing 
)

Definition at line 2075 of file kstd1.cc.

2076 {
2077  int i;
2078  long j=0;
2079 
2080  for (i=r->N;i>0;i--)
2081  j+=p_GetExp(p,i,r)*(*kHomW)[i-1];
2082  if (kModW == NULL) return j;
2083  i = __p_GetComp(p,r);
2084  if (i==0) return j;
2085  return j+(*kModW)[i-1];
2086 }
#define __p_GetComp(p, r)
Definition: monomials.h:63
int j
Definition: facHensel.cc:105
intvec * kModW
Definition: kstd1.cc:2063
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:468
int i
Definition: cfEzgcd.cc:125
#define NULL
Definition: omList.c:12
int p
Definition: cfModGcd.cc:4019

◆ kInterRed()

ideal kInterRed ( ideal  F,
ideal  Q = NULL 
)

Definition at line 3398 of file kstd1.cc.

3399 {
3400 #ifdef HAVE_PLURAL
3401  if(rIsPluralRing(currRing)) return kInterRedOld(F,Q);
3402 #endif
3405  )
3406  return kInterRedOld(F,Q);
3407 
3408  //return kInterRedOld(F,Q);
3409 
3410  BITSET save1;
3411  SI_SAVE_OPT1(save1);
3412  //si_opt_1|=Sy_bit(OPT_NOT_SUGAR);
3414  //si_opt_1&= ~Sy_bit(OPT_REDTAIL);
3415  //si_opt_1&= ~Sy_bit(OPT_REDSB);
3416  //extern char * showOption() ;
3417  //Print("%s\n",showOption());
3418 
3419  int need_retry;
3420  int counter=3;
3421  ideal res, res1;
3422  int elems;
3423  ideal null=NULL;
3424  if ((Q==NULL) || (!TEST_OPT_REDSB))
3425  {
3426  elems=idElem(F);
3427  res=kInterRedBba(F,Q,need_retry);
3428  }
3429  else
3430  {
3431  ideal FF=idSimpleAdd(F,Q);
3432  res=kInterRedBba(FF,NULL,need_retry);
3433  idDelete(&FF);
3434  null=idInit(1,1);
3435  if (need_retry)
3436  res1=kNF(null,Q,res,0,KSTD_NF_LAZY);
3437  else
3438  res1=kNF(null,Q,res);
3439  idDelete(&res);
3440  res=res1;
3441  need_retry=1;
3442  }
3443  if (idElem(res)<=1) need_retry=0;
3444  while (need_retry && (counter>0))
3445  {
3446  #ifdef KDEBUG
3447  if (TEST_OPT_DEBUG) { Print("retry counter %d\n",counter); }
3448  #endif
3449  res1=kInterRedBba(res,Q,need_retry);
3450  int new_elems=idElem(res1);
3451  counter -= (new_elems >= elems);
3452  elems = new_elems;
3453  idDelete(&res);
3454  if (idElem(res1)<=1) need_retry=0;
3455  if ((Q!=NULL) && (TEST_OPT_REDSB))
3456  {
3457  if (need_retry)
3458  res=kNF(null,Q,res1,0,KSTD_NF_LAZY);
3459  else
3460  res=kNF(null,Q,res1);
3461  idDelete(&res1);
3462  }
3463  else
3464  res = res1;
3465  if (idElem(res)<=1) need_retry=0;
3466  }
3467  if (null!=NULL) idDelete(&null);
3468  SI_RESTORE_OPT1(save1);
3469  idSkipZeroes(res);
3470  return res;
3471 }
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
Definition: ring.h:755
unsigned si_opt_1
Definition: options.c:5
poly kNF(ideal F, ideal Q, poly p, int syzComp, int lazyReduce)
Definition: kstd1.cc:2822
#define Print
Definition: emacs.cc:80
#define idDelete(H)
delete an ideal
Definition: ideals.h:29
#define idSimpleAdd(A, B)
Definition: ideals.h:42
#define TEST_OPT_REDSB
Definition: options.h:103
#define SI_SAVE_OPT1(A)
Definition: options.h:22
#define TEST_OPT_DEBUG
Definition: options.h:107
#define Q
Definition: sirandom.c:25
#define BITSET
Definition: structs.h:20
#define Sy_bit(x)
Definition: options.h:32
ideal kInterRedBba(ideal F, ideal Q, int &need_retry)
Definition: kstd1.cc:3138
#define KSTD_NF_LAZY
Definition: kstd1.h:17
CanonicalForm res
Definition: facAbsFact.cc:64
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition: ring.h:397
ideal kInterRedOld(ideal F, ideal Q)
Definition: kstd1.cc:3046
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:479
#define NULL
Definition: omList.c:12
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
#define OPT_REDTHROUGH
Definition: options.h:81
int idElem(const ideal F)
count non-zero elements
#define SI_RESTORE_OPT1(A)
Definition: options.h:25
static BOOLEAN rField_is_numeric(const ring r)
Definition: ring.h:510

◆ kInterRedOld()

ideal kInterRedOld ( ideal  F,
ideal  Q = NULL 
)

Definition at line 3046 of file kstd1.cc.

3047 {
3048  int j;
3049  kStrategy strat = new skStrategy;
3050 
3051  ideal tempF = F;
3052  ideal tempQ = Q;
3053 
3054 #ifdef HAVE_PLURAL
3055  if(rIsSCA(currRing))
3056  {
3057  const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
3058  const unsigned int m_iLastAltVar = scaLastAltVar(currRing);
3059  tempF = id_KillSquares(F, m_iFirstAltVar, m_iLastAltVar, currRing);
3060 
3061  // this should be done on the upper level!!! :
3062  // tempQ = SCAQuotient(currRing);
3063 
3064  if(Q == currRing->qideal)
3065  tempQ = SCAQuotient(currRing);
3066  }
3067 #endif
3068 
3069 // if (TEST_OPT_PROT)
3070 // {
3071 // writeTime("start InterRed:");
3072 // mflush();
3073 // }
3074  //strat->syzComp = 0;
3075  strat->kHEdgeFound = (currRing->ppNoether) != NULL;
3076  strat->kNoether=pCopy((currRing->ppNoether));
3077  strat->ak = id_RankFreeModule(tempF,currRing);
3078  initBuchMoraCrit(strat);
3079  strat->NotUsedAxis = (BOOLEAN *)omAlloc(((currRing->N)+1)*sizeof(BOOLEAN));
3080  for (j=(currRing->N); j>0; j--) strat->NotUsedAxis[j] = TRUE;
3081  strat->enterS = enterSBba;
3082  strat->posInT = posInT17;
3083  strat->initEcart = initEcartNormal;
3084  strat->sl = -1;
3085  strat->tl = -1;
3086  strat->tmax = setmaxT;
3087  strat->T = initT();
3088  strat->R = initR();
3089  strat->sevT = initsevT();
3091  initS(tempF, tempQ, strat);
3092  if (TEST_OPT_REDSB)
3093  strat->noTailReduction=FALSE;
3094  updateS(TRUE,strat);
3096  completeReduce(strat);
3097  //else if (TEST_OPT_PROT) PrintLn();
3098  cleanT(strat);
3099  if (strat->kHEdge!=NULL) pLmFree(&strat->kHEdge);
3100  omFreeSize((ADDRESS)strat->T,strat->tmax*sizeof(TObject));
3101  omFreeSize((ADDRESS)strat->ecartS,IDELEMS(strat->Shdl)*sizeof(int));
3102  omFreeSize((ADDRESS)strat->sevS,IDELEMS(strat->Shdl)*sizeof(unsigned long));
3103  omFreeSize((ADDRESS)strat->NotUsedAxis,((currRing->N)+1)*sizeof(BOOLEAN));
3104  omfree(strat->sevT);
3105  omfree(strat->S_2_R);
3106  omfree(strat->R);
3107 
3108  if (strat->fromQ)
3109  {
3110  for (j=IDELEMS(strat->Shdl)-1;j>=0;j--)
3111  {
3112  if(strat->fromQ[j]) pDelete(&strat->Shdl->m[j]);
3113  }
3114  omFreeSize((ADDRESS)strat->fromQ,IDELEMS(strat->Shdl)*sizeof(int));
3115  }
3116 // if (TEST_OPT_PROT)
3117 // {
3118 // writeTime("end Interred:");
3119 // mflush();
3120 // }
3121  ideal shdl=strat->Shdl;
3122  idSkipZeroes(shdl);
3123  if (strat->fromQ)
3124  {
3125  strat->fromQ=NULL;
3126  ideal res=kInterRed(shdl,NULL);
3127  idDelete(&shdl);
3128  shdl=res;
3129  }
3130  delete(strat);
3131 #ifdef HAVE_PLURAL
3132  if( tempF != F )
3133  id_Delete( &tempF, currRing);
3134 #endif
3135  return shdl;
3136 }
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
Definition: ring.h:755
ideal SCAQuotient(const ring r)
Definition: sca.h:10
KINLINE TObject ** initR()
Definition: kInline.h:95
int j
Definition: facHensel.cc:105
char kHEdgeFound
Definition: kutil.h:374
KINLINE unsigned long * initsevT()
Definition: kInline.h:100
poly kHEdge
Definition: kutil.h:325
#define idDelete(H)
delete an ideal
Definition: ideals.h:29
KINLINE TSet initT()
Definition: kInline.h:84
#define FALSE
Definition: auxiliary.h:94
int * S_2_R
Definition: kutil.h:340
char noTailReduction
Definition: kutil.h:376
BOOLEAN * NotUsedAxis
Definition: kutil.h:330
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
poly kNoether
Definition: kutil.h:326
int tl
Definition: kutil.h:348
#define TRUE
Definition: auxiliary.h:98
#define TEST_OPT_REDSB
Definition: options.h:103
unsigned long * sevT
Definition: kutil.h:321
void * ADDRESS
Definition: auxiliary.h:133
int ak
Definition: kutil.h:351
#define Q
Definition: sirandom.c:25
#define omAlloc(size)
Definition: omAllocDecl.h:210
int(* posInT)(const TSet T, const int tl, LObject &h)
Definition: kutil.h:277
void(* initEcart)(TObject *L)
Definition: kutil.h:276
void initS(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:8075
#define TEST_OPT_INTSTRATEGY
Definition: options.h:109
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
#define setmaxT
Definition: kutil.h:33
CanonicalForm res
Definition: facAbsFact.cc:64
intset fromQ
Definition: kutil.h:317
void(* enterS)(LObject &h, int pos, kStrategy strat, int atR)
Definition: kutil.h:282
#define omfree(addr)
Definition: omAllocDecl.h:237
ideal kInterRed(ideal F, ideal Q)
Definition: kstd1.cc:3398
void initBuchMoraCrit(kStrategy strat)
Definition: kutil.cc:9874
int posInT17(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5731
TObject ** R
Definition: kutil.h:338
#define IDELEMS(i)
Definition: simpleideals.h:23
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
static short scaFirstAltVar(ring r)
Definition: sca.h:18
int tmax
Definition: kutil.h:348
intset ecartS
Definition: kutil.h:305
#define NULL
Definition: omList.c:12
void cleanT(kStrategy strat)
Definition: kutil.cc:538
ideal id_KillSquares(const ideal id, const short iFirstAltVar, const short iLastAltVar, const ring r, const bool bSkipZeroes)
Definition: sca.cc:1520
#define pDelete(p_ptr)
Definition: polys.h:181
static short scaLastAltVar(ring r)
Definition: sca.h:25
void updateS(BOOLEAN toT, kStrategy strat)
Definition: kutil.cc:9034
unsigned long * sevS
Definition: kutil.h:318
static bool rIsSCA(const ring r)
Definition: nc.h:190
void completeReduce(kStrategy strat, BOOLEAN withT)
Definition: kutil.cc:10719
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
char honey
Definition: kutil.h:375
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
int sl
Definition: kutil.h:346
TSet T
Definition: kutil.h:322
void initEcartNormal(TObject *h)
Definition: kutil.cc:1284
ideal Shdl
Definition: kutil.h:299
int BOOLEAN
Definition: auxiliary.h:85
class sTObject TObject
Definition: kutil.h:53
void enterSBba(LObject &p, int atS, kStrategy strat, int atR)
Definition: kutil.cc:9261
#define pCopy(p)
return a copy of the poly
Definition: polys.h:180

◆ kMin_std()

ideal kMin_std ( ideal  F,
ideal  Q,
tHomog  h,
intvec **  w,
ideal &  M,
intvec hilb = NULL,
int  syzComp = 0,
int  reduced = 0 
)

Definition at line 2673 of file kstd1.cc.

2675 {
2676  if(idIs0(F))
2677  {
2678  M=idInit(1,F->rank);
2679  return idInit(1,F->rank);
2680  }
2682  {
2683  ideal sb;
2684  sb = kStd(F, Q, h, w, hilb);
2685  idSkipZeroes(sb);
2686  if(IDELEMS(sb) <= IDELEMS(F))
2687  {
2688  M = idCopy(sb);
2689  idSkipZeroes(M);
2690  return(sb);
2691  }
2692  else
2693  {
2694  M = idCopy(F);
2695  idSkipZeroes(M);
2696  return(sb);
2697  }
2698  }
2699  ideal r=NULL;
2700  int Kstd1_OldDeg = Kstd1_deg,i;
2701  intvec* temp_w=NULL;
2702  BOOLEAN b=currRing->pLexOrder,toReset=FALSE;
2703  BOOLEAN delete_w=(w==NULL);
2704  BOOLEAN oldDegBound=TEST_OPT_DEGBOUND;
2705  kStrategy strat=new skStrategy;
2706 
2707  if(!TEST_OPT_RETURN_SB)
2708  strat->syzComp = syzComp;
2710  strat->LazyPass=20;
2711  else
2712  strat->LazyPass=2;
2713  strat->LazyDegree = 1;
2714  strat->minim=(reduced % 2)+1;
2715  strat->ak = id_RankFreeModule(F,currRing);
2716  if (delete_w)
2717  {
2718  temp_w=new intvec((strat->ak)+1);
2719  w = &temp_w;
2720  }
2721  if (h==testHomog)
2722  {
2723  if (strat->ak == 0)
2724  {
2725  h = (tHomog)idHomIdeal(F,Q);
2726  w=NULL;
2727  }
2728  else
2729  {
2730  h = (tHomog)idHomModule(F,Q,w);
2731  }
2732  }
2733  if (h==isHomog)
2734  {
2735  if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
2736  {
2737  kModW = *w;
2738  strat->kModW = *w;
2739  assume(currRing->pFDeg != NULL && currRing->pLDeg != NULL);
2740  strat->pOrigFDeg = currRing->pFDeg;
2741  strat->pOrigLDeg = currRing->pLDeg;
2743 
2744  toReset = TRUE;
2745  if (reduced>1)
2746  {
2747  Kstd1_OldDeg=Kstd1_deg;
2748  Kstd1_deg = -1;
2749  for (i=IDELEMS(F)-1;i>=0;i--)
2750  {
2751  if ((F->m[i]!=NULL) && (currRing->pFDeg(F->m[i],currRing)>=Kstd1_deg))
2752  Kstd1_deg = currRing->pFDeg(F->m[i],currRing)+1;
2753  }
2754  }
2755  }
2756  currRing->pLexOrder = TRUE;
2757  strat->LazyPass*=2;
2758  }
2759  strat->homog=h;
2761  {
2762  if (w!=NULL)
2763  r=mora(F,Q,*w,hilb,strat);
2764  else
2765  r=mora(F,Q,NULL,hilb,strat);
2766  }
2767  else
2768  {
2769  if (w!=NULL)
2770  r=bba(F,Q,*w,hilb,strat);
2771  else
2772  r=bba(F,Q,NULL,hilb,strat);
2773  }
2774 #ifdef KDEBUG
2775  {
2776  int i;
2777  for (i=IDELEMS(r)-1; i>=0; i--) pTest(r->m[i]);
2778  }
2779 #endif
2780  idSkipZeroes(r);
2781  if (toReset)
2782  {
2783  pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
2784  kModW = NULL;
2785  }
2786  currRing->pLexOrder = b;
2787  HCord=strat->HCord;
2788  if ((delete_w)&&(temp_w!=NULL)) delete temp_w;
2789  if ((IDELEMS(r)==1) && (r->m[0]!=NULL) && pIsConstant(r->m[0]) && (strat->ak==0))
2790  {
2791  M=idInit(1,F->rank);
2792  M->m[0]=pOne();
2793  //if (strat->ak!=0) { pSetComp(M->m[0],strat->ak); pSetmComp(M->m[0]); }
2794  if (strat->M!=NULL) idDelete(&strat->M);
2795  }
2796  else if (strat->M==NULL)
2797  {
2798  M=idInit(1,F->rank);
2799  WarnS("no minimal generating set computed");
2800  }
2801  else
2802  {
2803  idSkipZeroes(strat->M);
2804  M=strat->M;
2805  }
2806  delete(strat);
2807  if (reduced>2)
2808  {
2809  Kstd1_deg=Kstd1_OldDeg;
2810  if (!oldDegBound)
2812  }
2813  else
2814  {
2815  if (IDELEMS(M)>IDELEMS(r)) {
2816  idDelete(&M);
2817  M=idCopy(r); }
2818  }
2819  return r;
2820 }
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
Definition: ring.h:755
unsigned si_opt_1
Definition: options.c:5
int HCord
Definition: kutil.cc:236
int syzComp
Definition: kutil.h:352
#define TEST_OPT_DEGBOUND
Definition: options.h:112
static BOOLEAN idHomIdeal(ideal id, ideal Q=NULL)
Definition: ideals.h:91
#define idDelete(H)
delete an ideal
Definition: ideals.h:29
#define FALSE
Definition: auxiliary.h:94
#define pTest(p)
Definition: polys.h:410
#define TRUE
Definition: auxiliary.h:98
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:2088
int ak
Definition: kutil.h:351
#define Q
Definition: sirandom.c:25
ideal bba(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
Definition: kstd2.cc:2178
#define WarnS
Definition: emacs.cc:78
#define Sy_bit(x)
Definition: options.h:32
int minim
Definition: kutil.h:356
static BOOLEAN rField_has_simple_inverse(const ring r)
Definition: ring.h:543
int HCord
Definition: kutil.h:353
pFDegProc pOrigFDeg
Definition: kutil.h:292
static BOOLEAN idHomModule(ideal m, ideal Q, intvec **w)
Definition: ideals.h:96
#define M
Definition: sirandom.c:24
CanonicalForm b
Definition: cfModGcd.cc:4044
pLDegProc pOrigLDeg
Definition: kutil.h:293
intvec * kModW
Definition: kstd1.cc:2063
Definition: intvec.h:19
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
tHomog
Definition: structs.h:39
void pSetDegProcs(ring r, pFDegProc new_FDeg, pLDegProc new_lDeg)
Definition: p_polys.cc:3597
#define assume(x)
Definition: mod2.h:390
#define pIsConstant(p)
like above, except that Comp must be 0
Definition: polys.h:233
ideal M
Definition: kutil.h:301
int i
Definition: cfEzgcd.cc:125
#define pOne()
Definition: polys.h:310
#define IDELEMS(i)
Definition: simpleideals.h:23
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
ideal idCopy(ideal A)
Definition: ideals.h:60
void pRestoreDegProcs(ring r, pFDegProc old_FDeg, pLDegProc old_lDeg)
Definition: p_polys.cc:3609
#define TEST_OPT_RETURN_SB
Definition: options.h:111
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35
char homog
Definition: kutil.h:370
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:479
#define NULL
Definition: omList.c:12
const CanonicalForm & w
Definition: facAbsFact.cc:55
intvec * kModW
Definition: kutil.h:333
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
long kModDeg(poly p, ring r)
Definition: kstd1.cc:2065
#define OPT_DEGBOUND
Definition: options.h:89
int LazyPass
Definition: kutil.h:351
int Kstd1_deg
Definition: kutil.cc:237
static Poly * h
Definition: janet.cc:971
int BOOLEAN
Definition: auxiliary.h:85
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
int LazyDegree
Definition: kutil.h:351
ideal mora(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
Definition: kstd1.cc:1517

◆ kModDeg()

long kModDeg ( poly  p,
ring  r = currRing 
)

Definition at line 2065 of file kstd1.cc.

2066 {
2067  long o=p_WDegree(p, r);
2068  long i=__p_GetComp(p, r);
2069  if (i==0) return o;
2070  //assume((i>0) && (i<=kModW->length()));
2071  if (i<=kModW->length())
2072  return o+(*kModW)[i-1];
2073  return o;
2074 }
#define __p_GetComp(p, r)
Definition: monomials.h:63
long p_WDegree(poly p, const ring r)
Definition: p_polys.cc:704
int i
Definition: cfEzgcd.cc:125
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:263
int p
Definition: cfModGcd.cc:4019

◆ kNF() [1/2]

poly kNF ( ideal  F,
ideal  Q,
poly  p,
int  syzComp = 0,
int  lazyReduce = 0 
)

Definition at line 2822 of file kstd1.cc.

2823 {
2824  if (p==NULL)
2825  return NULL;
2826 
2827  poly pp = p;
2828 
2829 #ifdef HAVE_PLURAL
2830  if(rIsSCA(currRing))
2831  {
2832  const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
2833  const unsigned int m_iLastAltVar = scaLastAltVar(currRing);
2834  pp = p_KillSquares(pp, m_iFirstAltVar, m_iLastAltVar, currRing);
2835 
2836  if(Q == currRing->qideal)
2837  Q = SCAQuotient(currRing);
2838  }
2839 #endif
2840 
2841  if ((idIs0(F))&&(Q==NULL))
2842  {
2843 #ifdef HAVE_PLURAL
2844  if(p != pp)
2845  return pp;
2846 #endif
2847  return pCopy(p); /*F+Q=0*/
2848  }
2849 
2850  kStrategy strat=new skStrategy;
2851  strat->syzComp = syzComp;
2852  strat->ak = si_max(id_RankFreeModule(F,currRing),pMaxComp(p));
2853  poly res;
2854 
2856  {
2857 #ifdef HAVE_SHIFTBBA
2858  if (currRing->isLPring)
2859  {
2860  WerrorS("No local ordering possible for shift algebra");
2861  return(NULL);
2862  }
2863 #endif
2864  res=kNF1(F,Q,pp,strat,lazyReduce);
2865  }
2866  else
2867  res=kNF2(F,Q,pp,strat,lazyReduce);
2868  delete(strat);
2869 
2870 #ifdef HAVE_PLURAL
2871  if(pp != p)
2872  p_Delete(&pp, currRing);
2873 #endif
2874  return res;
2875 }
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
Definition: ring.h:755
ideal SCAQuotient(const ring r)
Definition: sca.h:10
int syzComp
Definition: kutil.h:352
#define pMaxComp(p)
Definition: polys.h:294
int ak
Definition: kutil.h:351
void WerrorS(const char *s)
Definition: feFopen.cc:24
#define Q
Definition: sirandom.c:25
poly p_KillSquares(const poly p, const short iFirstAltVar, const short iLastAltVar, const ring r)
Definition: sca.cc:1465
poly kNF2(ideal F, ideal Q, poly q, kStrategy strat, int lazyReduce)
Definition: kstd2.cc:3503
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
CanonicalForm res
Definition: facAbsFact.cc:64
poly kNF1(ideal F, ideal Q, poly q, kStrategy strat, int lazyReduce)
Definition: kstd1.cc:1766
CanonicalForm pp(const CanonicalForm &)
CanonicalForm pp ( const CanonicalForm & f )
Definition: cf_gcd.cc:248
static int si_max(const int a, const int b)
Definition: auxiliary.h:138
static short scaFirstAltVar(ring r)
Definition: sca.h:18
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:856
#define NULL
Definition: omList.c:12
static short scaLastAltVar(ring r)
Definition: sca.h:25
static bool rIsSCA(const ring r)
Definition: nc.h:190
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
int p
Definition: cfModGcd.cc:4019
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
#define pCopy(p)
return a copy of the poly
Definition: polys.h:180

◆ kNF() [2/2]

ideal kNF ( ideal  F,
ideal  Q,
ideal  p,
int  syzComp = 0,
int  lazyReduce = 0 
)

Definition at line 2919 of file kstd1.cc.

2920 {
2921  ideal res;
2922  if (TEST_OPT_PROT)
2923  {
2924  Print("(S:%d)",IDELEMS(p));mflush();
2925  }
2926  if (idIs0(p))
2927  return idInit(IDELEMS(p),si_max(p->rank,F->rank));
2928 
2929  ideal pp = p;
2930 #ifdef HAVE_PLURAL
2931  if(rIsSCA(currRing))
2932  {
2933  const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
2934  const unsigned int m_iLastAltVar = scaLastAltVar(currRing);
2935  pp = id_KillSquares(pp, m_iFirstAltVar, m_iLastAltVar, currRing, false);
2936 
2937  if(Q == currRing->qideal)
2938  Q = SCAQuotient(currRing);
2939  }
2940 #endif
2941 
2942  if ((idIs0(F))&&(Q==NULL))
2943  {
2944 #ifdef HAVE_PLURAL
2945  if(p != pp)
2946  return pp;
2947 #endif
2948  return idCopy(p); /*F+Q=0*/
2949  }
2950 
2951  kStrategy strat=new skStrategy;
2952  strat->syzComp = syzComp;
2954  if (strat->ak>0) // only for module case, see Tst/Short/bug_reduce.tst
2955  {
2956  strat->ak = si_max(strat->ak,(int)F->rank);
2957  }
2958 
2960  {
2961 #ifdef HAVE_SHIFTBBA
2962  if (currRing->isLPring)
2963  {
2964  WerrorS("No local ordering possible for shift algebra");
2965  return(NULL);
2966  }
2967 #endif
2968  res=kNF1(F,Q,pp,strat,lazyReduce);
2969  }
2970  else
2971  res=kNF2(F,Q,pp,strat,lazyReduce);
2972  delete(strat);
2973 
2974 #ifdef HAVE_PLURAL
2975  if(pp != p)
2976  id_Delete(&pp, currRing);
2977 #endif
2978 
2979  return res;
2980 }
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
Definition: ring.h:755
ideal SCAQuotient(const ring r)
Definition: sca.h:10
#define Print
Definition: emacs.cc:80
int syzComp
Definition: kutil.h:352
#define TEST_OPT_PROT
Definition: options.h:102
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
int ak
Definition: kutil.h:351
void WerrorS(const char *s)
Definition: feFopen.cc:24
#define Q
Definition: sirandom.c:25
#define mflush()
Definition: reporter.h:57
poly kNF2(ideal F, ideal Q, poly q, kStrategy strat, int lazyReduce)
Definition: kstd2.cc:3503
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
CanonicalForm res
Definition: facAbsFact.cc:64
poly kNF1(ideal F, ideal Q, poly q, kStrategy strat, int lazyReduce)
Definition: kstd1.cc:1766
CanonicalForm pp(const CanonicalForm &)
CanonicalForm pp ( const CanonicalForm & f )
Definition: cf_gcd.cc:248
static int si_max(const int a, const int b)
Definition: auxiliary.h:138
#define IDELEMS(i)
Definition: simpleideals.h:23
static short scaFirstAltVar(ring r)
Definition: sca.h:18
ideal idCopy(ideal A)
Definition: ideals.h:60
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35
#define NULL
Definition: omList.c:12
ideal id_KillSquares(const ideal id, const short iFirstAltVar, const short iLastAltVar, const ring r, const bool bSkipZeroes)
Definition: sca.cc:1520
static short scaLastAltVar(ring r)
Definition: sca.h:25
static bool rIsSCA(const ring r)
Definition: nc.h:190
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
int p
Definition: cfModGcd.cc:4019
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal

◆ kNF1() [1/2]

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

Definition at line 1766 of file kstd1.cc.

1767 {
1768  assume(q!=NULL);
1769  assume(!(idIs0(F)&&(Q==NULL)));
1770 
1771 // lazy_reduce flags: can be combined by |
1772 //#define KSTD_NF_LAZY 1
1773  // do only a reduction of the leading term
1774 //#define KSTD_NF_ECART 2
1775  // only local: recude even with bad ecart
1776  poly p;
1777  int i;
1778  int j;
1779  int o;
1780  LObject h;
1781  BITSET save1;
1782  SI_SAVE_OPT1(save1);
1783 
1784  //if ((idIs0(F))&&(Q==NULL))
1785  // return pCopy(q); /*F=0*/
1786  //strat->ak = si_max(idRankFreeModule(F),pMaxComp(q));
1787  /*- creating temp data structures------------------- -*/
1788  strat->kHEdgeFound = (currRing->ppNoether) != NULL;
1789  strat->kNoether = pCopy((currRing->ppNoether));
1793  && (! TEST_V_DEG_STOP)
1794  && (0<Kstd1_deg)
1795  && ((!strat->kHEdgeFound)
1797  {
1798  pLmDelete(&strat->kNoether);
1799  strat->kNoether=pOne();
1800  pSetExp(strat->kNoether,1, Kstd1_deg+1);
1801  pSetm(strat->kNoether);
1802  strat->kHEdgeFound=TRUE;
1803  }
1804  initBuchMoraCrit(strat);
1806  initBuchMoraPosRing(strat);
1807  else
1808  initBuchMoraPos(strat);
1809  initMora(F,strat);
1810  strat->enterS = enterSMoraNF;
1811  /*- set T -*/
1812  strat->tl = -1;
1813  strat->tmax = setmaxT;
1814  strat->T = initT();
1815  strat->R = initR();
1816  strat->sevT = initsevT();
1817  /*- set S -*/
1818  strat->sl = -1;
1819  /*- init local data struct.-------------------------- -*/
1820  /*Shdl=*/initS(F,Q,strat);
1821  if ((strat->ak!=0)
1822  && (strat->kHEdgeFound))
1823  {
1824  if (strat->ak!=1)
1825  {
1826  pSetComp(strat->kNoether,1);
1827  pSetmComp(strat->kNoether);
1828  poly p=pHead(strat->kNoether);
1829  pSetComp(p,strat->ak);
1830  pSetmComp(p);
1831  p=pAdd(strat->kNoether,p);
1832  strat->kNoether=pNext(p);
1833  p_LmDelete(p,currRing);
1834  }
1835  }
1836  if ((lazyReduce & KSTD_NF_LAZY)==0)
1837  {
1838  for (i=strat->sl; i>=0; i--)
1839  pNorm(strat->S[i]);
1840  }
1841  /*- puts the elements of S also to T -*/
1842  for (i=0; i<=strat->sl; i++)
1843  {
1844  h.p = strat->S[i];
1845  h.ecart = strat->ecartS[i];
1846  if (strat->sevS[i] == 0) strat->sevS[i] = pGetShortExpVector(h.p);
1847  else assume(strat->sevS[i] == pGetShortExpVector(h.p));
1848  h.length = pLength(h.p);
1849  h.sev = strat->sevS[i];
1850  h.SetpFDeg();
1851  enterT(h,strat);
1852  }
1853 #ifdef KDEBUG
1854 // kDebugPrint(strat);
1855 #endif
1856  /*- compute------------------------------------------- -*/
1857  p = pCopy(q);
1858  deleteHC(&p,&o,&j,strat);
1859  kTest(strat);
1860  if (TEST_OPT_PROT) { PrintS("r"); mflush(); }
1861  if (BVERBOSE(23)) kDebugPrint(strat);
1863  {
1864  if (p!=NULL) p = redMoraNFRing(p,strat, lazyReduce & KSTD_NF_ECART);
1865  }
1866  else
1867  {
1868  if (p!=NULL) p = redMoraNF(p,strat, lazyReduce & KSTD_NF_ECART);
1869  }
1870  if ((p!=NULL)&&((lazyReduce & KSTD_NF_LAZY)==0))
1871  {
1872  if (TEST_OPT_PROT) { PrintS("t"); mflush(); }
1873  p = redtail(p,strat->sl,strat);
1874  }
1875  /*- release temp data------------------------------- -*/
1876  cleanT(strat);
1877  assume(strat->L==NULL); /*strat->L unsed */
1878  assume(strat->B==NULL); /*strat->B unused */
1879  omFreeSize((ADDRESS)strat->T,strat->tmax*sizeof(TObject));
1880  omFreeSize((ADDRESS)strat->ecartS,IDELEMS(strat->Shdl)*sizeof(int));
1881  omFreeSize((ADDRESS)strat->sevS,IDELEMS(strat->Shdl)*sizeof(unsigned long));
1882  omFreeSize((ADDRESS)strat->NotUsedAxis,((currRing->N)+1)*sizeof(BOOLEAN));
1883  omFree(strat->sevT);
1884  omFree(strat->S_2_R);
1885  omFree(strat->R);
1886 
1887  if ((Q!=NULL)&&(strat->fromQ!=NULL))
1888  {
1889  i=((IDELEMS(Q)+IDELEMS(F)+15)/16)*16;
1890  omFreeSize((ADDRESS)strat->fromQ,i*sizeof(int));
1891  strat->fromQ=NULL;
1892  }
1893  if (strat->kHEdge!=NULL) pLmFree(&strat->kHEdge);
1894  if (strat->kNoether!=NULL) pLmDelete(&strat->kNoether);
1895 // if ((TEST_OPT_WEIGHTM)&&(F!=NULL))
1896 // {
1897 // pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
1898 // if (ecartWeights)
1899 // {
1900 // omFreeSize((ADDRESS *)&ecartWeights,((currRing->N)+1)*sizeof(short));
1901 // ecartWeights=NULL;
1902 // }
1903 // }
1904  idDelete(&strat->Shdl);
1905  SI_RESTORE_OPT1(save1);
1906  if (TEST_OPT_PROT) PrintLn();
1907  return p;
1908 }
#define pSetmComp(p)
TODO:
Definition: polys.h:268
KINLINE TObject ** initR()
Definition: kInline.h:95
unsigned si_opt_1
Definition: options.c:5
int j
Definition: facHensel.cc:105
char kHEdgeFound
Definition: kutil.h:374
#define pSetm(p)
Definition: polys.h:266
void PrintLn()
Definition: reporter.cc:310
static poly redMoraNFRing(poly h, kStrategy strat, int flag)
Definition: kstd1.cc:762
KINLINE unsigned long * initsevT()
Definition: kInline.h:100
#define TEST_OPT_DEGBOUND
Definition: options.h:112
#define pAdd(p, q)
Definition: polys.h:198
void initBuchMoraPos(kStrategy strat)
Definition: kutil.cc:10025
poly kHEdge
Definition: kutil.h:325
void initMora(ideal F, kStrategy strat)
Definition: kstd1.cc:1460
#define idDelete(H)
delete an ideal
Definition: ideals.h:29
class sLObject LObject
Definition: kutil.h:54
KINLINE TSet initT()
Definition: kInline.h:84
#define TEST_OPT_PROT
Definition: options.h:102
#define pSetExp(p, i, v)
Definition: polys.h:42
int * S_2_R
Definition: kutil.h:340
BOOLEAN * NotUsedAxis
Definition: kutil.h:330
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
poly kNoether
Definition: kutil.h:326
int tl
Definition: kutil.h:348
#define pLmDelete(p)
assume p != NULL, deletes Lm(p)->coef and Lm(p)
Definition: polys.h:76
#define TRUE
Definition: auxiliary.h:98
#define kTest(A)
Definition: kutil.h:653
unsigned long * sevT
Definition: kutil.h:321
void * ADDRESS
Definition: auxiliary.h:133
#define SI_SAVE_OPT1(A)
Definition: options.h:22
int ak
Definition: kutil.h:351
#define Q
Definition: sirandom.c:25
#define BITSET
Definition: structs.h:20
void initBuchMoraPosRing(kStrategy strat)
Definition: kutil.cc:10111
#define Sy_bit(x)
Definition: options.h:32
void enterT(LObject &p, kStrategy strat, int atT)
Definition: kutil.cc:9576
#define mflush()
Definition: reporter.h:57
void initS(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:8075
#define KSTD_NF_LAZY
Definition: kstd1.h:17
#define setmaxT
Definition: kutil.h:33
#define OPT_REDTAIL
Definition: options.h:90
#define TEST_V_DEG_STOP
Definition: options.h:135
#define TEST_OPT_STAIRCASEBOUND
Definition: options.h:114
poly redtail(LObject *L, int end_pos, kStrategy strat)
Definition: kutil.cc:7405
#define omFree(addr)
Definition: omAllocDecl.h:261
#define assume(x)
Definition: mod2.h:390
intset fromQ
Definition: kutil.h:317
#define pGetShortExpVector(a)
returns the "Short Exponent Vector" – used to speed up divisibility tests (see polys-impl.cc )
Definition: polys.h:152
void(* enterS)(LObject &h, int pos, kStrategy strat, int atR)
Definition: kutil.h:282
#define KSTD_NF_ECART
Definition: kstd1.h:19
#define pSetComp(p, v)
Definition: polys.h:38
void initBuchMoraCrit(kStrategy strat)
Definition: kutil.cc:9874
int i
Definition: cfEzgcd.cc:125
void PrintS(const char *s)
Definition: reporter.cc:284
void deleteHC(LObject *L, kStrategy strat, BOOLEAN fromNext)
Definition: kutil.cc:244
#define pOne()
Definition: polys.h:310
TObject ** R
Definition: kutil.h:338
static unsigned pLength(poly a)
Definition: p_polys.h:191
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL ...
Definition: polys.h:67
polyset S
Definition: kutil.h:302
#define IDELEMS(i)
Definition: simpleideals.h:23
int tmax
Definition: kutil.h:348
#define OPT_INTSTRATEGY
Definition: options.h:91
#define BVERBOSE(a)
Definition: options.h:35
intset ecartS
Definition: kutil.h:305
LSet L
Definition: kutil.h:323
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:479
#define NULL
Definition: omList.c:12
void cleanT(kStrategy strat)
Definition: kutil.cc:538
LSet B
Definition: kutil.h:324
void pNorm(poly p, const ring R=currRing)
Definition: polys.h:358
#define pWTotaldegree(p)
Definition: polys.h:278
unsigned long * sevS
Definition: kutil.h:318
#define pNext(p)
Definition: monomials.h:36
static poly redMoraNF(poly h, kStrategy strat, int flag)
Definition: kstd1.cc:662
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
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
int sl
Definition: kutil.h:346
TSet T
Definition: kutil.h:322
static void p_LmDelete(poly p, const ring r)
Definition: p_polys.h:710
void enterSMoraNF(LObject &p, int atS, kStrategy strat, int atR=-1)
Definition: kstd1.cc:1324
int p
Definition: cfModGcd.cc:4019
int Kstd1_deg
Definition: kutil.cc:237
ideal Shdl
Definition: kutil.h:299
static Poly * h
Definition: janet.cc:971
int BOOLEAN
Definition: auxiliary.h:85
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
#define SI_RESTORE_OPT1(A)
Definition: options.h:25
void kDebugPrint(kStrategy strat)
Definition: kutil.cc:11923
class sTObject TObject
Definition: kutil.h:53
#define pCopy(p)
return a copy of the poly
Definition: polys.h:180

◆ kNF1() [2/2]

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

Definition at line 1910 of file kstd1.cc.

1911 {
1912  assume(!idIs0(q));
1913  assume(!(idIs0(F)&&(Q==NULL)));
1914 
1915 // lazy_reduce flags: can be combined by |
1916 //#define KSTD_NF_LAZY 1
1917  // do only a reduction of the leading term
1918 //#define KSTD_NF_ECART 2
1919  // only local: recude even with bad ecart
1920  poly p;
1921  int i;
1922  int j;
1923  int o;
1924  LObject h;
1925  ideal res;
1926  BITSET save1;
1927  SI_SAVE_OPT1(save1);
1928 
1929  //if (idIs0(q)) return idInit(IDELEMS(q),si_max(q->rank,F->rank));
1930  //if ((idIs0(F))&&(Q==NULL))
1931  // return idCopy(q); /*F=0*/
1932  //strat->ak = si_max(idRankFreeModule(F),idRankFreeModule(q));
1933  /*- creating temp data structures------------------- -*/
1934  strat->kHEdgeFound = (currRing->ppNoether) != NULL;
1935  strat->kNoether=pCopy((currRing->ppNoether));
1938  && (0<Kstd1_deg)
1939  && ((!strat->kHEdgeFound)
1941  {
1942  pLmDelete(&strat->kNoether);
1943  strat->kNoether=pOne();
1944  pSetExp(strat->kNoether,1, Kstd1_deg+1);
1945  pSetm(strat->kNoether);
1946  strat->kHEdgeFound=TRUE;
1947  }
1948  initBuchMoraCrit(strat);
1950  initBuchMoraPosRing(strat);
1951  else
1952  initBuchMoraPos(strat);
1953  initMora(F,strat);
1954  strat->enterS = enterSMoraNF;
1955  /*- set T -*/
1956  strat->tl = -1;
1957  strat->tmax = setmaxT;
1958  strat->T = initT();
1959  strat->R = initR();
1960  strat->sevT = initsevT();
1961  /*- set S -*/
1962  strat->sl = -1;
1963  /*- init local data struct.-------------------------- -*/
1964  /*Shdl=*/initS(F,Q,strat);
1965  if ((strat->ak!=0)
1966  && (strat->kHEdgeFound))
1967  {
1968  if (strat->ak!=1)
1969  {
1970  pSetComp(strat->kNoether,1);
1971  pSetmComp(strat->kNoether);
1972  poly p=pHead(strat->kNoether);
1973  pSetComp(p,strat->ak);
1974  pSetmComp(p);
1975  p=pAdd(strat->kNoether,p);
1976  strat->kNoether=pNext(p);
1977  p_LmDelete(p,currRing);
1978  }
1979  }
1980  if (TEST_OPT_INTSTRATEGY && ((lazyReduce & KSTD_NF_LAZY)==0))
1981  {
1982  for (i=strat->sl; i>=0; i--)
1983  pNorm(strat->S[i]);
1984  }
1985  /*- compute------------------------------------------- -*/
1986  res=idInit(IDELEMS(q),strat->ak);
1987  for (i=0; i<IDELEMS(q); i++)
1988  {
1989  if (q->m[i]!=NULL)
1990  {
1991  p = pCopy(q->m[i]);
1992  deleteHC(&p,&o,&j,strat);
1993  if (p!=NULL)
1994  {
1995  /*- puts the elements of S also to T -*/
1996  for (j=0; j<=strat->sl; j++)
1997  {
1998  h.p = strat->S[j];
1999  h.ecart = strat->ecartS[j];
2000  h.pLength = h.length = pLength(h.p);
2001  if (strat->sevS[j] == 0) strat->sevS[j] = pGetShortExpVector(h.p);
2002  else assume(strat->sevS[j] == pGetShortExpVector(h.p));
2003  h.sev = strat->sevS[j];
2004  h.SetpFDeg();
2006  enterT_strong(h,strat);
2007  else
2008  enterT(h,strat);
2009  }
2010  if (TEST_OPT_PROT) { PrintS("r"); mflush(); }
2012  {
2013  p = redMoraNFRing(p,strat, lazyReduce & KSTD_NF_ECART);
2014  }
2015  else
2016  p = redMoraNF(p,strat, lazyReduce & KSTD_NF_ECART);
2017  if ((p!=NULL)&&((lazyReduce & KSTD_NF_LAZY)==0))
2018  {
2019  if (TEST_OPT_PROT) { PrintS("t"); mflush(); }
2020  p = redtail(p,strat->sl,strat);
2021  }
2022  cleanT(strat);
2023  }
2024  res->m[i]=p;
2025  }
2026  //else
2027  // res->m[i]=NULL;
2028  }
2029  /*- release temp data------------------------------- -*/
2030  assume(strat->L==NULL); /*strat->L unsed */
2031  assume(strat->B==NULL); /*strat->B unused */
2032  omFreeSize((ADDRESS)strat->T,strat->tmax*sizeof(TObject));
2033  omFreeSize((ADDRESS)strat->ecartS,IDELEMS(strat->Shdl)*sizeof(int));
2034  omFreeSize((ADDRESS)strat->sevS,IDELEMS(strat->Shdl)*sizeof(unsigned long));
2035  omFreeSize((ADDRESS)strat->NotUsedAxis,((currRing->N)+1)*sizeof(BOOLEAN));
2036  omFree(strat->sevT);
2037  omFree(strat->S_2_R);
2038  omFree(strat->R);
2039  if ((Q!=NULL)&&(strat->fromQ!=NULL))
2040  {
2042  omFreeSize((ADDRESS)strat->fromQ,i*sizeof(int));
2043  strat->fromQ=NULL;
2044  }
2045  if (strat->kHEdge!=NULL) pLmFree(&strat->kHEdge);
2046  if (strat->kNoether!=NULL) pLmDelete(&strat->kNoether);
2047 // if ((TEST_OPT_WEIGHTM)&&(F!=NULL))
2048 // {
2049 // pFDeg=strat->pOrigFDeg;
2050 // pLDeg=strat->pOrigLDeg;
2051 // if (ecartWeights)
2052 // {
2053 // omFreeSize((ADDRESS *)&ecartWeights,((currRing->N)+1)*sizeof(short));
2054 // ecartWeights=NULL;
2055 // }
2056 // }
2057  idDelete(&strat->Shdl);
2058  SI_RESTORE_OPT1(save1);
2059  if (TEST_OPT_PROT) PrintLn();
2060  return res;
2061 }
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
Definition: ring.h:755
#define pSetmComp(p)
TODO:
Definition: polys.h:268
KINLINE TObject ** initR()
Definition: kInline.h:95
unsigned si_opt_1
Definition: options.c:5
int j
Definition: facHensel.cc:105
char kHEdgeFound
Definition: kutil.h:374
#define pSetm(p)
Definition: polys.h:266
void PrintLn()
Definition: reporter.cc:310
static poly redMoraNFRing(poly h, kStrategy strat, int flag)
Definition: kstd1.cc:762
KINLINE unsigned long * initsevT()
Definition: kInline.h:100
#define TEST_OPT_DEGBOUND
Definition: options.h:112
#define pAdd(p, q)
Definition: polys.h:198
void initBuchMoraPos(kStrategy strat)
Definition: kutil.cc:10025
poly kHEdge
Definition: kutil.h:325
void initMora(ideal F, kStrategy strat)
Definition: kstd1.cc:1460
#define idDelete(H)
delete an ideal
Definition: ideals.h:29
class sLObject LObject
Definition: kutil.h:54
KINLINE TSet initT()
Definition: kInline.h:84
#define TEST_OPT_PROT
Definition: options.h:102
#define pSetExp(p, i, v)
Definition: polys.h:42
int * S_2_R
Definition: kutil.h:340
BOOLEAN * NotUsedAxis
Definition: kutil.h:330
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
poly kNoether
Definition: kutil.h:326
int tl
Definition: kutil.h:348
#define pLmDelete(p)
assume p != NULL, deletes Lm(p)->coef and Lm(p)
Definition: polys.h:76
#define TRUE
Definition: auxiliary.h:98
unsigned long * sevT
Definition: kutil.h:321
void * ADDRESS
Definition: auxiliary.h:133
#define SI_SAVE_OPT1(A)
Definition: options.h:22
int ak
Definition: kutil.h:351
#define Q
Definition: sirandom.c:25
#define BITSET
Definition: structs.h:20
void initBuchMoraPosRing(kStrategy strat)
Definition: kutil.cc:10111
#define Sy_bit(x)
Definition: options.h:32
void enterT(LObject &p, kStrategy strat, int atT)
Definition: kutil.cc:9576
#define mflush()
Definition: reporter.h:57
void initS(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:8075
#define KSTD_NF_LAZY
Definition: kstd1.h:17
#define TEST_OPT_INTSTRATEGY
Definition: options.h:109
#define setmaxT
Definition: kutil.h:33
CanonicalForm res
Definition: facAbsFact.cc:64
#define OPT_REDTAIL
Definition: options.h:90
#define TEST_OPT_STAIRCASEBOUND
Definition: options.h:114
poly redtail(LObject *L, int end_pos, kStrategy strat)
Definition: kutil.cc:7405
#define omFree(addr)
Definition: omAllocDecl.h:261
#define assume(x)
Definition: mod2.h:390
intset fromQ
Definition: kutil.h:317
#define pGetShortExpVector(a)
returns the "Short Exponent Vector" – used to speed up divisibility tests (see polys-impl.cc )
Definition: polys.h:152
void(* enterS)(LObject &h, int pos, kStrategy strat, int atR)
Definition: kutil.h:282
#define KSTD_NF_ECART
Definition: kstd1.h:19
#define pSetComp(p, v)
Definition: polys.h:38
void initBuchMoraCrit(kStrategy strat)
Definition: kutil.cc:9874
int i
Definition: cfEzgcd.cc:125
void PrintS(const char *s)
Definition: reporter.cc:284
void deleteHC(LObject *L, kStrategy strat, BOOLEAN fromNext)
Definition: kutil.cc:244
#define pOne()
Definition: polys.h:310
TObject ** R
Definition: kutil.h:338
static unsigned pLength(poly a)
Definition: p_polys.h:191
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL ...
Definition: polys.h:67
polyset S
Definition: kutil.h:302
#define IDELEMS(i)
Definition: simpleideals.h:23
int tmax
Definition: kutil.h:348
void enterT_strong(LObject &p, kStrategy strat, int atT)
Definition: kutil.cc:9676
intset ecartS
Definition: kutil.h:305
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35
LSet L
Definition: kutil.h:323
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:479
#define NULL
Definition: omList.c:12
void cleanT(kStrategy strat)
Definition: kutil.cc:538
LSet B
Definition: kutil.h:324
void pNorm(poly p, const ring R=currRing)
Definition: polys.h:358
#define pWTotaldegree(p)
Definition: polys.h:278
unsigned long * sevS
Definition: kutil.h:318
#define pNext(p)
Definition: monomials.h:36
static poly redMoraNF(poly h, kStrategy strat, int flag)
Definition: kstd1.cc:662
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
#define setmaxTinc
Definition: kutil.h:34
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
int sl
Definition: kutil.h:346
TSet T
Definition: kutil.h:322
static void p_LmDelete(poly p, const ring r)
Definition: p_polys.h:710
void enterSMoraNF(LObject &p, int atS, kStrategy strat, int atR=-1)
Definition: kstd1.cc:1324
int p
Definition: cfModGcd.cc:4019
int Kstd1_deg
Definition: kutil.cc:237
ideal Shdl
Definition: kutil.h:299
static Poly * h
Definition: janet.cc:971
int BOOLEAN
Definition: auxiliary.h:85
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
#define SI_RESTORE_OPT1(A)
Definition: options.h:25
class sTObject TObject
Definition: kutil.h:53
#define pCopy(p)
return a copy of the poly
Definition: polys.h:180

◆ kNFBound() [1/2]

poly kNFBound ( ideal  F,
ideal  Q,
poly  p,
int  bound,
int  syzComp = 0,
int  lazyReduce = 0 
)

Definition at line 2877 of file kstd1.cc.

2878 {
2879  if (p==NULL)
2880  return NULL;
2881 
2882  poly pp = p;
2883 
2884 #ifdef HAVE_PLURAL
2885  if(rIsSCA(currRing))
2886  {
2887  const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
2888  const unsigned int m_iLastAltVar = scaLastAltVar(currRing);
2889  pp = p_KillSquares(pp, m_iFirstAltVar, m_iLastAltVar, currRing);
2890 
2891  if(Q == currRing->qideal)
2892  Q = SCAQuotient(currRing);
2893  }
2894 #endif
2895 
2896  if ((idIs0(F))&&(Q==NULL))
2897  {
2898 #ifdef HAVE_PLURAL
2899  if(p != pp)
2900  return pp;
2901 #endif
2902  return pCopy(p); /*F+Q=0*/
2903  }
2904 
2905  kStrategy strat=new skStrategy;
2906  strat->syzComp = syzComp;
2907  strat->ak = si_max(id_RankFreeModule(F,currRing),pMaxComp(p));
2908  poly res;
2909  res=kNF2Bound(F,Q,pp,bound,strat,lazyReduce);
2910  delete(strat);
2911 
2912 #ifdef HAVE_PLURAL
2913  if(pp != p)
2914  p_Delete(&pp, currRing);
2915 #endif
2916  return res;
2917 }
ideal SCAQuotient(const ring r)
Definition: sca.h:10
poly kNF2Bound(ideal F, ideal Q, poly q, int bound, kStrategy strat, int lazyReduce)
Definition: kstd2.cc:3596
static CanonicalForm bound(const CFMatrix &M)
Definition: cf_linsys.cc:460
int syzComp
Definition: kutil.h:352
#define pMaxComp(p)
Definition: polys.h:294
int ak
Definition: kutil.h:351
#define Q
Definition: sirandom.c:25
poly p_KillSquares(const poly p, const short iFirstAltVar, const short iLastAltVar, const ring r)
Definition: sca.cc:1465
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
CanonicalForm res
Definition: facAbsFact.cc:64
CanonicalForm pp(const CanonicalForm &)
CanonicalForm pp ( const CanonicalForm & f )
Definition: cf_gcd.cc:248
static int si_max(const int a, const int b)
Definition: auxiliary.h:138
static short scaFirstAltVar(ring r)
Definition: sca.h:18
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:856
#define NULL
Definition: omList.c:12
static short scaLastAltVar(ring r)
Definition: sca.h:25
static bool rIsSCA(const ring r)
Definition: nc.h:190
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
int p
Definition: cfModGcd.cc:4019
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
#define pCopy(p)
return a copy of the poly
Definition: polys.h:180

◆ kNFBound() [2/2]

ideal kNFBound ( ideal  F,
ideal  Q,
ideal  p,
int  bound,
int  syzComp = 0,
int  lazyReduce = 0 
)

Definition at line 2982 of file kstd1.cc.

2983 {
2984  ideal res;
2985  if (TEST_OPT_PROT)
2986  {
2987  Print("(S:%d)",IDELEMS(p));mflush();
2988  }
2989  if (idIs0(p))
2990  return idInit(IDELEMS(p),si_max(p->rank,F->rank));
2991 
2992  ideal pp = p;
2993 #ifdef HAVE_PLURAL
2994  if(rIsSCA(currRing))
2995  {
2996  const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
2997  const unsigned int m_iLastAltVar = scaLastAltVar(currRing);
2998  pp = id_KillSquares(pp, m_iFirstAltVar, m_iLastAltVar, currRing, false);
2999 
3000  if(Q == currRing->qideal)
3001  Q = SCAQuotient(currRing);
3002  }
3003 #endif
3004 
3005  if ((idIs0(F))&&(Q==NULL))
3006  {
3007 #ifdef HAVE_PLURAL
3008  if(p != pp)
3009  return pp;
3010 #endif
3011  return idCopy(p); /*F+Q=0*/
3012  }
3013 
3014  kStrategy strat=new skStrategy;
3015  strat->syzComp = syzComp;
3017  if (strat->ak>0) // only for module case, see Tst/Short/bug_reduce.tst
3018  {
3019  strat->ak = si_max(strat->ak,(int)F->rank);
3020  }
3021 
3022  res=kNF2Bound(F,Q,pp,bound,strat,lazyReduce);
3023  delete(strat);
3024 
3025 #ifdef HAVE_PLURAL
3026  if(pp != p)
3027  id_Delete(&pp, currRing);
3028 #endif
3029 
3030  return res;
3031 }
ideal SCAQuotient(const ring r)
Definition: sca.h:10
poly kNF2Bound(ideal F, ideal Q, poly q, int bound, kStrategy strat, int lazyReduce)
Definition: kstd2.cc:3596
static CanonicalForm bound(const CFMatrix &M)
Definition: cf_linsys.cc:460
#define Print
Definition: emacs.cc:80
int syzComp
Definition: kutil.h:352
#define TEST_OPT_PROT
Definition: options.h:102
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
int ak
Definition: kutil.h:351
#define Q
Definition: sirandom.c:25
#define mflush()
Definition: reporter.h:57
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
CanonicalForm res
Definition: facAbsFact.cc:64
CanonicalForm pp(const CanonicalForm &)
CanonicalForm pp ( const CanonicalForm & f )
Definition: cf_gcd.cc:248
static int si_max(const int a, const int b)
Definition: auxiliary.h:138
#define IDELEMS(i)
Definition: simpleideals.h:23
static short scaFirstAltVar(ring r)
Definition: sca.h:18
ideal idCopy(ideal A)
Definition: ideals.h:60
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35
#define NULL
Definition: omList.c:12
ideal id_KillSquares(const ideal id, const short iFirstAltVar, const short iLastAltVar, const ring r, const bool bSkipZeroes)
Definition: sca.cc:1520
static short scaLastAltVar(ring r)
Definition: sca.h:25
static bool rIsSCA(const ring r)
Definition: nc.h:190
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
int p
Definition: cfModGcd.cc:4019
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal

◆ kSba()

ideal kSba ( ideal  F,
ideal  Q,
tHomog  h,
intvec **  mw,
int  incremental = 0,
int  arri = 0,
intvec hilb = NULL,
int  syzComp = 0,
int  newIdeal = 0,
intvec vw = NULL 
)

Definition at line 2273 of file kstd1.cc.

2275 {
2276  if(idIs0(F))
2277  return idInit(1,F->rank);
2278  if(!rField_is_Ring(currRing))
2279  {
2280  ideal r;
2281  BOOLEAN b=currRing->pLexOrder,toReset=FALSE;
2282  BOOLEAN delete_w=(w==NULL);
2283  kStrategy strat=new skStrategy;
2284  strat->sbaOrder = sbaOrder;
2285  if (arri!=0)
2286  {
2287  strat->rewCrit1 = arriRewDummy;
2288  strat->rewCrit2 = arriRewCriterion;
2289  strat->rewCrit3 = arriRewCriterionPre;
2290  }
2291  else
2292  {
2293  strat->rewCrit1 = faugereRewCriterion;
2294  strat->rewCrit2 = faugereRewCriterion;
2295  strat->rewCrit3 = faugereRewCriterion;
2296  }
2297 
2298  if(!TEST_OPT_RETURN_SB)
2299  strat->syzComp = syzComp;
2300  if (TEST_OPT_SB_1)
2301  //if(!rField_is_Ring(currRing)) // always true here
2302  strat->newIdeal = newIdeal;
2304  strat->LazyPass=20;
2305  else
2306  strat->LazyPass=2;
2307  strat->LazyDegree = 1;
2309  strat->chainCrit=chainCritNormal;
2311  strat->ak = id_RankFreeModule(F,currRing);
2312  strat->kModW=kModW=NULL;
2313  strat->kHomW=kHomW=NULL;
2314  if (vw != NULL)
2315  {
2316  currRing->pLexOrder=FALSE;
2317  strat->kHomW=kHomW=vw;
2318  strat->pOrigFDeg = currRing->pFDeg;
2319  strat->pOrigLDeg = currRing->pLDeg;
2321  toReset = TRUE;
2322  }
2323  if (h==testHomog)
2324  {
2325  if (strat->ak == 0)
2326  {
2327  h = (tHomog)idHomIdeal(F,Q);
2328  w=NULL;
2329  }
2330  else if (!TEST_OPT_DEGBOUND)
2331  {
2332  if (w!=NULL)
2333  h = (tHomog)idHomModule(F,Q,w);
2334  else
2335  h = (tHomog)idHomIdeal(F,Q);
2336  }
2337  }
2338  currRing->pLexOrder=b;
2339  if (h==isHomog)
2340  {
2341  if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
2342  {
2343  strat->kModW = kModW = *w;
2344  if (vw == NULL)
2345  {
2346  strat->pOrigFDeg = currRing->pFDeg;
2347  strat->pOrigLDeg = currRing->pLDeg;
2349  toReset = TRUE;
2350  }
2351  }
2352  currRing->pLexOrder = TRUE;
2353  if (hilb==NULL) strat->LazyPass*=2;
2354  }
2355  strat->homog=h;
2356  #ifdef KDEBUG
2357  idTest(F);
2358  if(Q != NULL)
2359  idTest(Q);
2360  #endif
2361  #ifdef HAVE_PLURAL
2362  if (rIsPluralRing(currRing))
2363  {
2364  const BOOLEAN bIsSCA = rIsSCA(currRing) && strat->z2homog; // for Z_2 prod-crit
2365  strat->no_prod_crit = ! bIsSCA;
2366  if (w!=NULL)
2367  r = nc_GB(F, Q, *w, hilb, strat, currRing);
2368  else
2369  r = nc_GB(F, Q, NULL, hilb, strat, currRing);
2370  }
2371  else
2372  #endif
2373  {
2375  {
2376  if (w!=NULL)
2377  r=mora(F,Q,*w,hilb,strat);
2378  else
2379  r=mora(F,Q,NULL,hilb,strat);
2380  }
2381  else
2382  {
2383  strat->sigdrop = FALSE;
2384  if (w!=NULL)
2385  r=sba(F,Q,*w,hilb,strat);
2386  else
2387  r=sba(F,Q,NULL,hilb,strat);
2388  }
2389  }
2390  #ifdef KDEBUG
2391  idTest(r);
2392  #endif
2393  if (toReset)
2394  {
2395  kModW = NULL;
2396  pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
2397  }
2398  currRing->pLexOrder = b;
2399  //Print("%d reductions canceled \n",strat->cel);
2400  HCord=strat->HCord;
2401  //delete(strat);
2402  if ((delete_w)&&(w!=NULL)&&(*w!=NULL)) delete *w;
2403  return r;
2404  }
2405  else
2406  {
2407  //--------------------------RING CASE-------------------------
2408  assume(sbaOrder == 1);
2409  assume(arri == 0);
2410  ideal r;
2411  r = idCopy(F);
2412  int sbaEnterS = -1;
2413  bool sigdrop = TRUE;
2414  //This is how we set the SBA algorithm;
2415  int totalsbaruns = 1,blockedreductions = 20,blockred = 0,loops = 0;
2416  while(sigdrop && (loops < totalsbaruns || totalsbaruns == -1)
2417  && (blockred <= blockedreductions))
2418  {
2419  loops++;
2420  if(loops == 1)
2421  sigdrop = FALSE;
2422  BOOLEAN b=currRing->pLexOrder,toReset=FALSE;
2423  BOOLEAN delete_w=(w==NULL);
2424  kStrategy strat=new skStrategy;
2425  strat->sbaEnterS = sbaEnterS;
2426  strat->sigdrop = sigdrop;
2427  #if 0
2428  strat->blockred = blockred;
2429  #else
2430  strat->blockred = 0;
2431  #endif
2432  strat->blockredmax = blockedreductions;
2433  //printf("\nsbaEnterS beginning = %i\n",strat->sbaEnterS);
2434  //printf("\nsigdrop beginning = %i\n",strat->sigdrop);
2435  strat->sbaOrder = sbaOrder;
2436  if (arri!=0)
2437  {
2438  strat->rewCrit1 = arriRewDummy;
2439  strat->rewCrit2 = arriRewCriterion;
2440  strat->rewCrit3 = arriRewCriterionPre;
2441  }
2442  else
2443  {
2444  strat->rewCrit1 = faugereRewCriterion;
2445  strat->rewCrit2 = faugereRewCriterion;
2446  strat->rewCrit3 = faugereRewCriterion;
2447  }
2448 
2449  if(!TEST_OPT_RETURN_SB)
2450  strat->syzComp = syzComp;
2451  if (TEST_OPT_SB_1)
2452  if(!rField_is_Ring(currRing))
2453  strat->newIdeal = newIdeal;
2455  strat->LazyPass=20;
2456  else
2457  strat->LazyPass=2;
2458  strat->LazyDegree = 1;
2460  strat->chainCrit=chainCritNormal;
2462  strat->ak = id_RankFreeModule(F,currRing);
2463  strat->kModW=kModW=NULL;
2464  strat->kHomW=kHomW=NULL;
2465  if (vw != NULL)
2466  {
2467  currRing->pLexOrder=FALSE;
2468  strat->kHomW=kHomW=vw;
2469  strat->pOrigFDeg = currRing->pFDeg;
2470  strat->pOrigLDeg = currRing->pLDeg;
2472  toReset = TRUE;
2473  }
2474  if (h==testHomog)
2475  {
2476  if (strat->ak == 0)
2477  {
2478  h = (tHomog)idHomIdeal(F,Q);
2479  w=NULL;
2480  }
2481  else if (!TEST_OPT_DEGBOUND)
2482  {
2483  if (w!=NULL)
2484  h = (tHomog)idHomModule(F,Q,w);
2485  else
2486  h = (tHomog)idHomIdeal(F,Q);
2487  }
2488  }
2489  currRing->pLexOrder=b;
2490  if (h==isHomog)
2491  {
2492  if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
2493  {
2494  strat->kModW = kModW = *w;
2495  if (vw == NULL)
2496  {
2497  strat->pOrigFDeg = currRing->pFDeg;
2498  strat->pOrigLDeg = currRing->pLDeg;
2500  toReset = TRUE;
2501  }
2502  }
2503  currRing->pLexOrder = TRUE;
2504  if (hilb==NULL) strat->LazyPass*=2;
2505  }
2506  strat->homog=h;
2507  #ifdef KDEBUG
2508  idTest(F);
2509  if(Q != NULL)
2510  idTest(Q);
2511  #endif
2512  #ifdef HAVE_PLURAL
2513  if (rIsPluralRing(currRing))
2514  {
2515  const BOOLEAN bIsSCA = rIsSCA(currRing) && strat->z2homog; // for Z_2 prod-crit
2516  strat->no_prod_crit = ! bIsSCA;
2517  if (w!=NULL)
2518  r = nc_GB(F, Q, *w, hilb, strat, currRing);
2519  else
2520  r = nc_GB(F, Q, NULL, hilb, strat, currRing);
2521  }
2522  else
2523  #endif
2524  {
2526  {
2527  if (w!=NULL)
2528  r=mora(F,Q,*w,hilb,strat);
2529  else
2530  r=mora(F,Q,NULL,hilb,strat);
2531  }
2532  else
2533  {
2534  if (w!=NULL)
2535  r=sba(r,Q,*w,hilb,strat);
2536  else
2537  {
2538  r=sba(r,Q,NULL,hilb,strat);
2539  }
2540  }
2541  }
2542  #ifdef KDEBUG
2543  idTest(r);
2544  #endif
2545  if (toReset)
2546  {
2547  kModW = NULL;
2548  pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
2549  }
2550  currRing->pLexOrder = b;
2551  //Print("%d reductions canceled \n",strat->cel);
2552  HCord=strat->HCord;
2553  sigdrop = strat->sigdrop;
2554  sbaEnterS = strat->sbaEnterS;
2555  blockred = strat->blockred;
2556  delete(strat);
2557  if ((delete_w)&&(w!=NULL)&&(*w!=NULL)) delete *w;
2558  }
2559  // Go to std
2560  if(sigdrop || blockred > blockedreductions)
2561  {
2562  r = kStd(r, Q, h, w, hilb, syzComp, newIdeal, vw);
2563  }
2564  return r;
2565  }
2566 }
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
Definition: ring.h:755
int HCord
Definition: kutil.cc:236
int syzComp
Definition: kutil.h:352
#define TEST_OPT_DEGBOUND
Definition: options.h:112
BOOLEAN(* rewCrit1)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.h:289
static BOOLEAN idHomIdeal(ideal id, ideal Q=NULL)
Definition: ideals.h:91
bool sigdrop
Definition: kutil.h:358
BOOLEAN faugereRewCriterion(poly sig, unsigned long not_sevSig, poly, kStrategy strat, int start=0)
Definition: kutil.cc:7129
#define FALSE
Definition: auxiliary.h:94
void chainCritNormal(poly p, int ecart, kStrategy strat)
Definition: kutil.cc:3192
int sbaEnterS
Definition: kutil.h:361
BOOLEAN(* rewCrit2)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.h:290
#define TRUE
Definition: auxiliary.h:98
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:2088
BOOLEAN(* rewCrit3)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.h:291
int ak
Definition: kutil.h:351
#define Q
Definition: sirandom.c:25
ideal sba(ideal F0, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
Definition: kstd2.cc:2536
void enterOnePairNormal(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR=-1)
Definition: kutil.cc:1929
static BOOLEAN rField_has_simple_inverse(const ring r)
Definition: ring.h:543
int HCord
Definition: kutil.h:353
pFDegProc pOrigFDeg
Definition: kutil.h:292
static BOOLEAN idHomModule(ideal m, ideal Q, intvec **w)
Definition: ideals.h:96
intvec * kHomW
Definition: kstd1.cc:2063
int blockredmax
Definition: kutil.h:364
void(* enterOnePair)(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR)
Definition: kutil.h:286
CanonicalForm b
Definition: cfModGcd.cc:4044
if(yy_init)
Definition: libparse.cc:1418
pLDegProc pOrigLDeg
Definition: kutil.h:293
intvec * kModW
Definition: kstd1.cc:2063
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
tHomog
Definition: structs.h:39
void pSetDegProcs(ring r, pFDegProc new_FDeg, pLDegProc new_lDeg)
Definition: p_polys.cc:3597
#define assume(x)
Definition: mod2.h:390
char no_prod_crit
Definition: kutil.h:392
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition: ring.h:397
long kHomModDeg(poly p, ring r)
Definition: kstd1.cc:2075
unsigned sbaOrder
Definition: kutil.h:312
ideal idCopy(ideal A)
Definition: ideals.h:60
void pRestoreDegProcs(ring r, pFDegProc old_FDeg, pLDegProc old_lDeg)
Definition: p_polys.cc:3609
BOOLEAN arriRewCriterion(poly, unsigned long, poly, kStrategy strat, int start=0)
Definition: kutil.cc:7188
#define TEST_OPT_RETURN_SB
Definition: options.h:111
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35
BOOLEAN arriRewCriterionPre(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int)
Definition: kutil.cc:7213
char homog
Definition: kutil.h:370
void(* chainCrit)(poly p, int ecart, kStrategy strat)
Definition: kutil.h:287
char z2homog
Definition: kutil.h:372
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:479
#define NULL
Definition: omList.c:12
intvec * kHomW
Definition: kutil.h:334
#define TEST_OPT_SB_1
Definition: options.h:117
int blockred
Definition: kutil.h:363
const CanonicalForm & w
Definition: facAbsFact.cc:55
intvec * kModW
Definition: kutil.h:333
static bool rIsSCA(const ring r)
Definition: nc.h:190
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
long kModDeg(poly p, ring r)
Definition: kstd1.cc:2065
void chainCritOpt_1(poly, int, kStrategy strat)
Definition: kutil.cc:3405
int LazyPass
Definition: kutil.h:351
int newIdeal
Definition: kutil.h:355
static ideal nc_GB(const ideal F, const ideal Q, const intvec *w, const intvec *hilb, kStrategy strat, const ring r)
Definition: nc.h:27
static Poly * h
Definition: janet.cc:971
int BOOLEAN
Definition: auxiliary.h:85
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
KINLINE BOOLEAN arriRewDummy(poly, unsigned long, poly, kStrategy, int)
Definition: kInline.h:1203
int LazyDegree
Definition: kutil.h:351
ideal mora(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
Definition: kstd1.cc:1517
#define idTest(id)
Definition: ideals.h:47

◆ kStd()

ideal kStd ( ideal  F,
ideal  Q,
tHomog  h,
intvec **  mw,
intvec hilb = NULL,
int  syzComp = 0,
int  newIdeal = 0,
intvec vw = NULL,
s_poly_proc_t  sp = NULL 
)

Definition at line 2088 of file kstd1.cc.

2090 {
2091  if(idIs0(F))
2092  return idInit(1,F->rank);
2093 
2094 #ifdef HAVE_SHIFTBBA
2095  if(rIsLPRing(currRing)) return freegb(F);
2096 #endif
2097 
2098  ideal r;
2099  BOOLEAN b=currRing->pLexOrder,toReset=FALSE;
2100  BOOLEAN delete_w=(w==NULL);
2101  kStrategy strat=new skStrategy;
2102 
2103  strat->s_poly=sp;
2104  if(!TEST_OPT_RETURN_SB)
2105  strat->syzComp = syzComp;
2106  if (TEST_OPT_SB_1
2107  &&(!rField_is_Ring(currRing))
2108  )
2109  strat->newIdeal = newIdeal;
2111  strat->LazyPass=20;
2112  else
2113  strat->LazyPass=2;
2114  strat->LazyDegree = 1;
2115  strat->ak = id_RankFreeModule(F,currRing);
2116  strat->kModW=kModW=NULL;
2117  strat->kHomW=kHomW=NULL;
2118  if (vw != NULL)
2119  {
2120  currRing->pLexOrder=FALSE;
2121  strat->kHomW=kHomW=vw;
2122  strat->pOrigFDeg = currRing->pFDeg;
2123  strat->pOrigLDeg = currRing->pLDeg;
2125  toReset = TRUE;
2126  }
2127  if (h==testHomog)
2128  {
2129  if (strat->ak == 0)
2130  {
2131  h = (tHomog)idHomIdeal(F,Q);
2132  w=NULL;
2133  }
2134  else if (!TEST_OPT_DEGBOUND)
2135  {
2136  if (w!=NULL)
2137  h = (tHomog)idHomModule(F,Q,w);
2138  else
2139  h = (tHomog)idHomIdeal(F,Q);
2140  }
2141  }
2142  currRing->pLexOrder=b;
2143  if (h==isHomog)
2144  {
2145  if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
2146  {
2147  strat->kModW = kModW = *w;
2148  if (vw == NULL)
2149  {
2150  strat->pOrigFDeg = currRing->pFDeg;
2151  strat->pOrigLDeg = currRing->pLDeg;
2153  toReset = TRUE;
2154  }
2155  }
2156  currRing->pLexOrder = TRUE;
2157  if (hilb==NULL) strat->LazyPass*=2;
2158  }
2159  strat->homog=h;
2160 #ifdef KDEBUG
2161  idTest(F);
2162  if (Q!=NULL) idTest(Q);
2163 #endif
2164 #ifdef HAVE_PLURAL
2165  if (rIsPluralRing(currRing))
2166  {
2167  const BOOLEAN bIsSCA = rIsSCA(currRing) && strat->z2homog; // for Z_2 prod-crit
2168  strat->no_prod_crit = ! bIsSCA;
2169  if (w!=NULL)
2170  r = nc_GB(F, Q, *w, hilb, strat, currRing);
2171  else
2172  r = nc_GB(F, Q, NULL, hilb, strat, currRing);
2173  }
2174  else
2175 #endif
2176  {
2177  #if PRE_INTEGER_CHECK
2178  //the preinteger check strategy is not for modules
2179  if(nCoeff_is_Z(currRing->cf) && strat->ak <= 0)
2180  {
2181  ideal FCopy = idCopy(F);
2182  poly pFmon = preIntegerCheck(FCopy, Q);
2183  if(pFmon != NULL)
2184  {
2185  idInsertPoly(FCopy, pFmon);
2186  strat->kModW=kModW=NULL;
2187  if (h==testHomog)
2188  {
2189  if (strat->ak == 0)
2190  {
2191  h = (tHomog)idHomIdeal(FCopy,Q);
2192  w=NULL;
2193  }
2194  else if (!TEST_OPT_DEGBOUND)
2195  {
2196  if (w!=NULL)
2197  h = (tHomog)idHomModule(FCopy,Q,w);
2198  else
2199  h = (tHomog)idHomIdeal(FCopy,Q);
2200  }
2201  }
2202  currRing->pLexOrder=b;
2203  if (h==isHomog)
2204  {
2205  if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
2206  {
2207  strat->kModW = kModW = *w;
2208  if (vw == NULL)
2209  {
2210  strat->pOrigFDeg = currRing->pFDeg;
2211  strat->pOrigLDeg = currRing->pLDeg;
2213  toReset = TRUE;
2214  }
2215  }
2216  currRing->pLexOrder = TRUE;
2217  if (hilb==NULL) strat->LazyPass*=2;
2218  }
2219  strat->homog=h;
2220  }
2221  omTestMemory(1);
2222  if(w == NULL)
2223  {
2225  r=mora(FCopy,Q,NULL,hilb,strat);
2226  else
2227  r=bba(FCopy,Q,NULL,hilb,strat);
2228  }
2229  else
2230  {
2232  r=mora(FCopy,Q,*w,hilb,strat);
2233  else
2234  r=bba(FCopy,Q,*w,hilb,strat);
2235  }
2236  idDelete(&FCopy);
2237  }
2238  else
2239  #endif
2240  {
2241  if(w==NULL)
2242  {
2244  r=mora(F,Q,NULL,hilb,strat);
2245  else
2246  r=bba(F,Q,NULL,hilb,strat);
2247  }
2248  else
2249  {
2251  r=mora(F,Q,*w,hilb,strat);
2252  else
2253  r=bba(F,Q,*w,hilb,strat);
2254  }
2255  }
2256  }
2257 #ifdef KDEBUG
2258  idTest(r);
2259 #endif
2260  if (toReset)
2261  {
2262  kModW = NULL;
2263  pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
2264  }
2265  currRing->pLexOrder = b;
2266 //Print("%d reductions canceled \n",strat->cel);
2267  HCord=strat->HCord;
2268  delete(strat);
2269  if ((delete_w)&&(w!=NULL)&&(*w!=NULL)) delete *w;
2270  return r;
2271 }
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
Definition: ring.h:755
int HCord
Definition: kutil.cc:236
int syzComp
Definition: kutil.h:352
#define TEST_OPT_DEGBOUND
Definition: options.h:112
static BOOLEAN idHomIdeal(ideal id, ideal Q=NULL)
Definition: ideals.h:91
#define idDelete(H)
delete an ideal
Definition: ideals.h:29
#define FALSE
Definition: auxiliary.h:94
#define TRUE
Definition: auxiliary.h:98
int ak
Definition: kutil.h:351
poly preIntegerCheck(const ideal Forig, const ideal Q)
used for GB over ZZ: look for constant and monomial elements in the ideal background: any known const...
Definition: kutil.cc:10968
#define Q
Definition: sirandom.c:25
ideal bba(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
Definition: kstd2.cc:2178
static BOOLEAN rIsLPRing(const ring r)
Definition: ring.h:408
static FORCE_INLINE BOOLEAN nCoeff_is_Z(const coeffs r)
Definition: coeffs.h:838
static BOOLEAN rField_has_simple_inverse(const ring r)
Definition: ring.h:543
int HCord
Definition: kutil.h:353
pFDegProc pOrigFDeg
Definition: kutil.h:292
static BOOLEAN idHomModule(ideal m, ideal Q, intvec **w)
Definition: ideals.h:96
intvec * kHomW
Definition: kstd1.cc:2063
CanonicalForm b
Definition: cfModGcd.cc:4044
if(yy_init)
Definition: libparse.cc:1418
omError_t omTestMemory(int check_level)
Definition: omDebug.c:94
pLDegProc pOrigLDeg
Definition: kutil.h:293
intvec * kModW
Definition: kstd1.cc:2063
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
tHomog
Definition: structs.h:39
void pSetDegProcs(ring r, pFDegProc new_FDeg, pLDegProc new_lDeg)
Definition: p_polys.cc:3597
char no_prod_crit
Definition: kutil.h:392
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition: ring.h:397
long kHomModDeg(poly p, ring r)
Definition: kstd1.cc:2075
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
void pRestoreDegProcs(ring r, pFDegProc old_FDeg, pLDegProc old_lDeg)
Definition: p_polys.cc:3609
#define TEST_OPT_RETURN_SB
Definition: options.h:111
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35
s_poly_proc_t s_poly
Definition: kutil.h:296
char homog
Definition: kutil.h:370
char z2homog
Definition: kutil.h:372
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:479
#define NULL
Definition: omList.c:12
intvec * kHomW
Definition: kutil.h:334
#define TEST_OPT_SB_1
Definition: options.h:117
const CanonicalForm & w
Definition: facAbsFact.cc:55
intvec * kModW
Definition: kutil.h:333
ideal freegb(ideal I)
Definition: kstd2.cc:4459
static bool rIsSCA(const ring r)
Definition: nc.h:190
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
long kModDeg(poly p, ring r)
Definition: kstd1.cc:2065
int LazyPass
Definition: kutil.h:351
int newIdeal
Definition: kutil.h:355
static ideal nc_GB(const ideal F, const ideal Q, const intvec *w, const intvec *hilb, kStrategy strat, const ring r)
Definition: nc.h:27
static Poly * h
Definition: janet.cc:971
int BOOLEAN
Definition: auxiliary.h:85
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
int LazyDegree
Definition: kutil.h:351
ideal mora(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
Definition: kstd1.cc:1517
#define idTest(id)
Definition: ideals.h:47

◆ kStdShift()

ideal kStdShift ( ideal  F,
ideal  Q,
tHomog  h,
intvec **  w,
intvec hilb,
int  syzComp,
int  newIdeal,
intvec vw 
)

Definition at line 2569 of file kstd1.cc.

2571 {
2572  ideal r;
2573  BOOLEAN b=currRing->pLexOrder,toReset=FALSE;
2574  BOOLEAN delete_w=(w==NULL);
2575  kStrategy strat=new skStrategy;
2576  intvec* temp_w=NULL;
2577 
2578  if(!TEST_OPT_RETURN_SB)
2579  strat->syzComp = syzComp;
2580  if (TEST_OPT_SB_1)
2581  if(!rField_is_Ring(currRing))
2582  strat->newIdeal = newIdeal;
2584  strat->LazyPass=20;
2585  else
2586  strat->LazyPass=2;
2587  strat->LazyDegree = 1;
2588  strat->ak = id_RankFreeModule(F,currRing);
2589  strat->kModW=kModW=NULL;
2590  strat->kHomW=kHomW=NULL;
2591  if (vw != NULL)
2592  {
2593  currRing->pLexOrder=FALSE;
2594  strat->kHomW=kHomW=vw;
2595  strat->pOrigFDeg = currRing->pFDeg;
2596  strat->pOrigLDeg = currRing->pLDeg;
2598  toReset = TRUE;
2599  }
2600  if (h==testHomog)
2601  {
2602  if (strat->ak == 0)
2603  {
2604  h = (tHomog)idHomIdeal(F,Q);
2605  w=NULL;
2606  }
2607  else if (!TEST_OPT_DEGBOUND)
2608  {
2609  if (w!=NULL)
2610  h = (tHomog)idHomModule(F,Q,w);
2611  else
2612  h = (tHomog)idHomIdeal(F,Q);
2613  }
2614  }
2615  currRing->pLexOrder=b;
2616  if (h==isHomog)
2617  {
2618  if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
2619  {
2620  strat->kModW = kModW = *w;
2621  if (vw == NULL)
2622  {
2623  strat->pOrigFDeg = currRing->pFDeg;
2624  strat->pOrigLDeg = currRing->pLDeg;
2626  toReset = TRUE;
2627  }
2628  }
2629  currRing->pLexOrder = TRUE;
2630  if (hilb==NULL) strat->LazyPass*=2;
2631  }
2632  strat->homog=h;
2633 #ifdef KDEBUG
2634  idTest(F);
2635 #endif
2637  {
2638  /* error: no local ord yet with shifts */
2639  WerrorS("No local ordering possible for shift algebra");
2640  return(NULL);
2641  }
2642  else
2643  {
2644  /* global ordering */
2645  if (w!=NULL)
2646  r=bbaShift(F,Q,*w,hilb,strat);
2647  else
2648  r=bbaShift(F,Q,NULL,hilb,strat);
2649  }
2650 #ifdef KDEBUG
2651  idTest(r);
2652 #endif
2653  if (toReset)
2654  {
2655  kModW = NULL;
2656  pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
2657  }
2658  currRing->pLexOrder = b;
2659 //Print("%d reductions canceled \n",strat->cel);
2660  HCord=strat->HCord;
2661  delete(strat);
2662  if ((delete_w)&&(w!=NULL)&&(*w!=NULL)) delete *w;
2663  return r;
2664 }
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
Definition: ring.h:755
int HCord
Definition: kutil.cc:236
int syzComp
Definition: kutil.h:352
#define TEST_OPT_DEGBOUND
Definition: options.h:112
static BOOLEAN idHomIdeal(ideal id, ideal Q=NULL)
Definition: ideals.h:91
#define FALSE
Definition: auxiliary.h:94
#define TRUE
Definition: auxiliary.h:98
int ak
Definition: kutil.h:351
void WerrorS(const char *s)
Definition: feFopen.cc:24
#define Q
Definition: sirandom.c:25
static BOOLEAN rField_has_simple_inverse(const ring r)
Definition: ring.h:543
int HCord
Definition: kutil.h:353
pFDegProc pOrigFDeg
Definition: kutil.h:292
static BOOLEAN idHomModule(ideal m, ideal Q, intvec **w)
Definition: ideals.h:96
intvec * kHomW
Definition: kstd1.cc:2063
CanonicalForm b
Definition: cfModGcd.cc:4044
if(yy_init)
Definition: libparse.cc:1418
pLDegProc pOrigLDeg
Definition: kutil.h:293
intvec * kModW
Definition: kstd1.cc:2063
Definition: intvec.h:19
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
tHomog
Definition: structs.h:39
void pSetDegProcs(ring r, pFDegProc new_FDeg, pLDegProc new_lDeg)
Definition: p_polys.cc:3597
long kHomModDeg(poly p, ring r)
Definition: kstd1.cc:2075
ideal bbaShift(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
Definition: kstd2.cc:4163
void pRestoreDegProcs(ring r, pFDegProc old_FDeg, pLDegProc old_lDeg)
Definition: p_polys.cc:3609
#define TEST_OPT_RETURN_SB
Definition: options.h:111
char homog
Definition: kutil.h:370
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:479
#define NULL
Definition: omList.c:12
intvec * kHomW
Definition: kutil.h:334
#define TEST_OPT_SB_1
Definition: options.h:117
const CanonicalForm & w
Definition: facAbsFact.cc:55
intvec * kModW
Definition: kutil.h:333
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
long kModDeg(poly p, ring r)
Definition: kstd1.cc:2065
int LazyPass
Definition: kutil.h:351
int newIdeal
Definition: kutil.h:355
static Poly * h
Definition: janet.cc:971
int BOOLEAN
Definition: auxiliary.h:85
int LazyDegree
Definition: kutil.h:351
#define idTest(id)
Definition: ideals.h:47

◆ mora()

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

Definition at line 1517 of file kstd1.cc.

1518 {
1519  int olddeg = 0;
1520  int reduc = 0;
1521  int red_result = 1;
1522  int hilbeledeg=1,hilbcount=0;
1523  BITSET save1;
1524  SI_SAVE_OPT1(save1);
1526  {
1527  si_opt_1 &= ~Sy_bit(OPT_REDSB);
1529  }
1530 
1531  strat->update = TRUE;
1532  /*- setting global variables ------------------- -*/
1533  initBuchMoraCrit(strat);
1534  initHilbCrit(F,Q,&hilb,strat);
1535  initMora(F,strat);
1537  initBuchMoraPosRing(strat);
1538  else
1539  initBuchMoraPos(strat);
1540  /*Shdl=*/initBuchMora(F,Q,strat);
1541  if (TEST_OPT_FASTHC) missingAxis(&strat->lastAxis,strat);
1542  /*updateS in initBuchMora has Hecketest
1543  * and could have put strat->kHEdgdeFound FALSE*/
1544  if ((currRing->ppNoether)!=NULL)
1545  {
1546  strat->kHEdgeFound = TRUE;
1547  }
1548  if (strat->kHEdgeFound && strat->update)
1549  {
1550  firstUpdate(strat);
1551  updateLHC(strat);
1552  reorderL(strat);
1553  }
1554  if (TEST_OPT_FASTHC && (strat->lastAxis) && strat->posInLOldFlag)
1555  {
1556  strat->posInLOld = strat->posInL;
1557  strat->posInLOldFlag = FALSE;
1558  strat->posInL = posInL10;
1559  updateL(strat);
1560  reorderL(strat);
1561  }
1562  kTest_TS(strat);
1563  strat->use_buckets = kMoraUseBucket(strat);
1564 
1565 #ifdef HAVE_TAIL_RING
1566  if (strat->homog && strat->red == redFirst)
1567  if(!idIs0(F) &&(!rField_is_Ring(currRing)))
1568  kStratInitChangeTailRing(strat);
1569 #endif
1570 
1571  if (BVERBOSE(23))
1572  {
1573  kDebugPrint(strat);
1574  }
1575 //deleteInL(strat->L,&strat->Ll,1,strat);
1576 //deleteInL(strat->L,&strat->Ll,0,strat);
1577 
1578  /*- compute-------------------------------------------*/
1579  while (strat->Ll >= 0)
1580  {
1581  #ifdef KDEBUG
1582  if (TEST_OPT_DEBUG) messageSets(strat);
1583  #endif
1584  if (siCntrlc)
1585  {
1586  while (strat->Ll >= 0)
1587  deleteInL(strat->L,&strat->Ll,strat->Ll,strat);
1588  strat->noClearS=TRUE;
1589  }
1590  if (TEST_OPT_DEGBOUND
1591  && (strat->L[strat->Ll].ecart+strat->L[strat->Ll].GetpFDeg()> Kstd1_deg))
1592  {
1593  /*
1594  * stops computation if
1595  * - 24 (degBound)
1596  * && upper degree is bigger than Kstd1_deg
1597  */
1598  while ((strat->Ll >= 0)
1599  && (strat->L[strat->Ll].p1!=NULL) && (strat->L[strat->Ll].p2!=NULL)
1600  && (strat->L[strat->Ll].ecart+strat->L[strat->Ll].GetpFDeg()> Kstd1_deg)
1601  )
1602  {
1603  deleteInL(strat->L,&strat->Ll,strat->Ll,strat);
1604  //if (TEST_OPT_PROT)
1605  //{
1606  // PrintS("D"); mflush();
1607  //}
1608  }
1609  if (strat->Ll<0) break;
1610  else strat->noClearS=TRUE;
1611  }
1612  strat->P = strat->L[strat->Ll];/*- picks the last element from the lazyset L -*/
1613  if (strat->Ll==0) strat->interpt=TRUE;
1614  strat->Ll--;
1615  // create the real Spoly
1616  if (pNext(strat->P.p) == strat->tail)
1617  {
1618  /*- deletes the short spoly and computes -*/
1619  if (rField_is_Ring(currRing))
1620  pLmDelete(strat->P.p);
1621  else
1622  pLmFree(strat->P.p);
1623  strat->P.p = NULL;
1624  poly m1 = NULL, m2 = NULL;
1625  // check that spoly creation is ok
1626  while (strat->tailRing != currRing &&
1627  !kCheckSpolyCreation(&(strat->P), strat, m1, m2))
1628  {
1629  assume(m1 == NULL && m2 == NULL);
1630  // if not, change to a ring where exponents are large enough
1631  kStratChangeTailRing(strat);
1632  }
1633  /* create the real one */
1634  ksCreateSpoly(&(strat->P), strat->kNoetherTail(), strat->use_buckets,
1635  strat->tailRing, m1, m2, strat->R);
1636  if (!strat->use_buckets)
1637  strat->P.SetLength(strat->length_pLength);
1638  }
1639  else if (strat->P.p1 == NULL)
1640  {
1641  // for input polys, prepare reduction (buckets !)
1642  strat->P.SetLength(strat->length_pLength);
1643  strat->P.PrepareRed(strat->use_buckets);
1644  }
1645 
1646  // the s-poly
1647  if (!strat->P.IsNull())
1648  {
1649  // might be NULL from noether !!!
1650  if (TEST_OPT_PROT)
1651  message(strat->P.ecart+strat->P.GetpFDeg(),&olddeg,&reduc,strat, red_result);
1652  // reduce
1653  red_result = strat->red(&strat->P,strat);
1654  }
1655 
1656  // the reduced s-poly
1657  if (! strat->P.IsNull())
1658  {
1659  strat->P.GetP();
1660  // statistics
1661  if (TEST_OPT_PROT) PrintS("s");
1662  // normalization
1664  strat->P.pCleardenom();
1665  else
1666  strat->P.pNorm();
1667  // tailreduction
1668  strat->P.p = redtail(&(strat->P),strat->sl,strat);
1669  if (strat->P.p==NULL)
1670  {
1671  WerrorS("expoent overflow - wrong ordering");
1672  return(idInit(1,1));
1673  }
1674  // set ecart -- might have changed because of tail reductions
1675  if ((!strat->noTailReduction) && (!strat->honey))
1676  strat->initEcart(&strat->P);
1677  // cancel unit
1678  cancelunit(&strat->P);
1679  // for char 0, clear denominators
1680  if ((strat->P.p->next==NULL) /* i.e. cancelunit did something*/
1682  strat->P.pCleardenom();
1683 
1684  enterT(strat->P,strat);
1685  // build new pairs
1686  if (rField_is_Ring(currRing))
1687  superenterpairs(strat->P.p,strat->sl,strat->P.ecart,0,strat, strat->tl);
1688  else
1689  enterpairs(strat->P.p,strat->sl,strat->P.ecart,0,strat, strat->tl);
1690  // put in S
1691  strat->enterS(strat->P,
1692  posInS(strat,strat->sl,strat->P.p, strat->P.ecart),
1693  strat, strat->tl);
1694  // apply hilbert criterion
1695  if (hilb!=NULL)
1696  {
1697  if (strat->homog==isHomog)
1698  khCheck(Q,w,hilb,hilbeledeg,hilbcount,strat);
1699  else
1700  khCheckLocInhom(Q,w,hilb,hilbcount,strat);
1701  }
1702 
1703  // clear strat->P
1704  kDeleteLcm(&strat->P);
1705 
1706 #ifdef KDEBUG
1707  // make sure kTest_TS does not complain about strat->P
1708  memset(&strat->P,0,sizeof(strat->P));
1709 #endif
1710  }
1711  if (strat->kHEdgeFound)
1712  {
1713  if ((TEST_OPT_FINDET)
1714  || ((TEST_OPT_MULTBOUND) && (scMult0Int(strat->Shdl,NULL,strat->tailRing) < Kstd1_mu)))
1715  {
1716  // obachman: is this still used ???
1717  /*
1718  * stops computation if strat->kHEdgeFound and
1719  * - 27 (finiteDeterminacyTest)
1720  * or
1721  * - 23
1722  * (multBound)
1723  * && multiplicity of the ideal is smaller then a predefined number mu
1724  */
1725  while (strat->Ll >= 0) deleteInL(strat->L,&strat->Ll,strat->Ll,strat);
1726  }
1727  }
1728  kTest_TS(strat);
1729  }
1730  /*- complete reduction of the standard basis------------------------ -*/
1731  if (TEST_OPT_REDSB) completeReduce(strat);
1732  else if (TEST_OPT_PROT) PrintLn();
1733  /*- release temp data------------------------------- -*/
1734  exitBuchMora(strat);
1735  /*- polynomials used for HECKE: HC, noether -*/
1736  if (TEST_OPT_FINDET)
1737  {
1738  if (strat->kHEdge!=NULL)
1739  Kstd1_mu=currRing->pFDeg(strat->kHEdge,currRing);
1740  else
1741  Kstd1_mu=-1;
1742  }
1743  if (strat->kHEdge!=NULL) pLmFree(&strat->kHEdge);
1744  strat->update = TRUE; //???
1745  strat->lastAxis = 0; //???
1746  if (strat->kNoether!=NULL) pLmDelete(&strat->kNoether);
1747  omFreeSize((ADDRESS)strat->NotUsedAxis,((currRing->N)+1)*sizeof(BOOLEAN));
1748  if ((TEST_OPT_PROT)||(TEST_OPT_DEBUG)) messageStat(hilbcount,strat);
1749 // if (TEST_OPT_WEIGHTM)
1750 // {
1751 // pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
1752 // if (ecartWeights)
1753 // {
1754 // omFreeSize((ADDRESS)ecartWeights,((currRing->N)+1)*sizeof(short));
1755 // ecartWeights=NULL;
1756 // }
1757 // }
1758  if(nCoeff_is_Z(currRing->cf))
1759  finalReduceByMon(strat);
1760  if (Q!=NULL) updateResult(strat->Shdl,Q,strat);
1761  SI_RESTORE_OPT1(save1);
1762  idTest(strat->Shdl);
1763  return (strat->Shdl);
1764 }
#define OPT_REDSB
Definition: options.h:75
int(* posInL)(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.h:280
unsigned si_opt_1
Definition: options.c:5
char kHEdgeFound
Definition: kutil.h:374
void PrintLn()
Definition: reporter.cc:310
#define TEST_OPT_DEGBOUND
Definition: options.h:112
void initBuchMoraPos(kStrategy strat)
Definition: kutil.cc:10025
void message(int i, int *reduc, int *olddeg, kStrategy strat, int red_result)
Definition: kutil.cc:7954
void initMora(ideal F, kStrategy strat)
Definition: kstd1.cc:1460
void messageStat(int hilbcount, kStrategy strat)
Definition: kutil.cc:7995
#define TEST_OPT_PROT
Definition: options.h:102
int Ll
Definition: kutil.h:349
#define FALSE
Definition: auxiliary.h:94
void initBuchMora(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:10198
int redFirst(LObject *h, kStrategy strat)
Definition: kstd1.cc:528
char interpt
Definition: kutil.h:369
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
void enterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
Definition: kutil.cc:4859
#define pLmDelete(p)
assume p != NULL, deletes Lm(p)->coef and Lm(p)
Definition: polys.h:76
#define TEST_OPT_MULTBOUND
Definition: options.h:113
char noClearS
Definition: kutil.h:400
#define TRUE
Definition: auxiliary.h:98
#define TEST_OPT_REDSB
Definition: options.h:103
static void kDeleteLcm(LObject *P)
Definition: kutil.h:876
void * ADDRESS
Definition: auxiliary.h:133
#define SI_SAVE_OPT1(A)
Definition: options.h:22
void cancelunit(LObject *L, BOOLEAN inNF)
Definition: kutil.cc:333
void WerrorS(const char *s)
Definition: feFopen.cc:24
#define TEST_OPT_DEBUG
Definition: options.h:107
#define Q
Definition: sirandom.c:25
#define BITSET
Definition: structs.h:20
int(* red)(LObject *L, kStrategy strat)
Definition: kutil.h:274
void initBuchMoraPosRing(kStrategy strat)
Definition: kutil.cc:10111
#define Sy_bit(x)
Definition: options.h:32
char posInLOldFlag
Definition: kutil.h:380
static FORCE_INLINE BOOLEAN nCoeff_is_Z(const coeffs r)
Definition: coeffs.h:838
char length_pLength
Definition: kutil.h:385
void updateL(kStrategy strat)
Definition: kstd1.cc:1039
char use_buckets
Definition: kutil.h:381
int lastAxis
Definition: kutil.h:354
void kStratInitChangeTailRing(kStrategy strat)
Definition: kutil.cc:11476
int Kstd1_mu
Definition: kutil.cc:238
#define TEST_OPT_FINDET
Definition: options.h:110
void enterT(LObject &p, kStrategy strat, int atT)
Definition: kutil.cc:9576
void missingAxis(int *last, kStrategy strat)
Definition: kstd1.cc:925
void deleteInL(LSet set, int *length, int j, kStrategy strat)
Definition: kutil.cc:1203
#define TEST_OPT_INTSTRATEGY
Definition: options.h:109
#define kTest_TS(A)
Definition: kutil.h:654
#define OPT_REDTAIL
Definition: options.h:90
poly redtail(LObject *L, int end_pos, kStrategy strat)
Definition: kutil.cc:7405
void initHilbCrit(ideal, ideal, intvec **hilb, kStrategy strat)
Definition: kutil.cc:9856
int scMult0Int(ideal S, ideal Q, const ring tailRing)
Definition: hdegree.cc:918
#define assume(x)
Definition: mod2.h:390
#define messageSets(s)
Definition: kutil.h:540
void updateLHC(kStrategy strat)
Definition: kstd1.cc:1110
void ksCreateSpoly(LObject *Pair, poly spNoether, int use_buckets, ring tailRing, poly m1, poly m2, TObject **R)
Definition: kspoly.cc:1145
BOOLEAN kStratChangeTailRing(kStrategy strat, LObject *L, TObject *T, unsigned long expbound)
Definition: kutil.cc:11377
LObject P
Definition: kutil.h:298
void initBuchMoraCrit(kStrategy strat)
Definition: kutil.cc:9874
void reorderL(kStrategy strat)
Definition: kstd1.cc:867
BOOLEAN siCntrlc
Definition: options.c:14
void PrintS(const char *s)
Definition: reporter.cc:284
poly tail
Definition: kutil.h:332
int(* posInLOld)(const LSet Ls, const int Ll, LObject *Lo, const kStrategy strat)
Definition: kutil.h:284
TObject ** R
Definition: kutil.h:338
BOOLEAN rHasMixedOrdering(const ring r)
Definition: ring.h:756
BOOLEAN kCheckSpolyCreation(LObject *L, kStrategy strat, poly &m1, poly &m2)
Definition: kutil.cc:10905
#define BVERBOSE(a)
Definition: options.h:35
void khCheck(ideal Q, intvec *w, intvec *hilb, int &eledeg, int &count, kStrategy strat)
Definition: khstd.cc:28
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35
char homog
Definition: kutil.h:370
LSet L
Definition: kutil.h:323
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:479
#define NULL
Definition: omList.c:12
void superenterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
Definition: kutil.cc:4831
void firstUpdate(kStrategy strat)
Definition: kstd1.cc:1203
ring tailRing
Definition: kutil.h:341
void khCheckLocInhom(ideal Q, intvec *w, intvec *hilb, int &count, kStrategy strat)
Definition: khstd.cc:133
int posInS(const kStrategy strat, const int length, const poly p, const int ecart_p)
Definition: kutil.cc:5035
void completeReduce(kStrategy strat, BOOLEAN withT)
Definition: kutil.cc:10719
#define pNext(p)
Definition: monomials.h:36
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
void updateResult(ideal r, ideal Q, kStrategy strat)
Definition: kutil.cc:10507
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
char update
Definition: kutil.h:379
static BOOLEAN kMoraUseBucket(kStrategy strat)
Definition: kstd1.cc:3474
#define TEST_OPT_FASTHC
Definition: options.h:108
int Kstd1_deg
Definition: kutil.cc:237
void finalReduceByMon(kStrategy strat)
used for GB over ZZ: final reduction by constant elements background: any known constant element of i...
Definition: kutil.cc:11292
int BOOLEAN
Definition: auxiliary.h:85
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
KINLINE poly kNoetherTail()
Definition: kInline.h:66
#define SI_RESTORE_OPT1(A)
Definition: options.h:25
void exitBuchMora(kStrategy strat)
Definition: kutil.cc:10274
int posInL10(const LSet set, const int length, LObject *p, const kStrategy strat)
Definition: kstd1.cc:1006
void kDebugPrint(kStrategy strat)
Definition: kutil.cc:11923
#define idTest(id)
Definition: ideals.h:47

◆ stdred()

ideal stdred ( ideal  F,
ideal  Q,
tHomog  h,
intvec **  w 
)

Variable Documentation

◆ kHomW

intvec* kHomW

Definition at line 2063 of file kstd1.cc.

◆ kModW

intvec* kModW

Definition at line 2063 of file kstd1.cc.

◆ kOptions

BITSET kOptions

Definition at line 42 of file kstd1.cc.

◆ Kstd1_deg

int Kstd1_deg

Definition at line 237 of file kutil.cc.

◆ Kstd1_mu

int Kstd1_mu

Definition at line 238 of file kutil.cc.

◆ LazyDegree

int LazyDegree

◆ LazyPass

int LazyPass

◆ validOpts

BITSET validOpts

Definition at line 57 of file kstd1.cc.