My Project  debian-1:4.1.1-p2+ds-4build4
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, int uptodeg, int lVblock)
 
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 1461 of file kstd1.cc.

1462 {
1463  int i,j;
1464 
1465  strat->NotUsedAxis = (BOOLEAN *)omAlloc(((currRing->N)+1)*sizeof(BOOLEAN));
1466  for (j=(currRing->N); j>0; j--) strat->NotUsedAxis[j] = TRUE;
1467  strat->enterS = enterSMora;
1468  strat->initEcartPair = initEcartPairMora; /*- ecart approximation -*/
1469  strat->posInLOld = strat->posInL;
1470  strat->posInLOldFlag = TRUE;
1471  strat->initEcart = initEcartNormal;
1472  strat->kHEdgeFound = (currRing->ppNoether) != NULL;
1473  if ( strat->kHEdgeFound )
1474  strat->kNoether = pCopy((currRing->ppNoether));
1475  else if (strat->kHEdgeFound || strat->homog)
1476  strat->red = redFirst; /*take the first possible in T*/
1477  else
1478  strat->red = redEcart;/*take the first possible in under ecart-restriction*/
1479  if (strat->kHEdgeFound)
1480  {
1481  strat->HCord = currRing->pFDeg((currRing->ppNoether),currRing)+1;
1482  strat->posInT = posInT2;
1483  }
1484  else
1485  {
1486  strat->HCord = 32000;/*- very large -*/
1487  }
1488 
1489  if (rField_is_Ring(currRing))
1490  strat->red = redRiloc;
1491 
1492  /*reads the ecartWeights used for Graebes method from the
1493  *intvec ecart and set ecartWeights
1494  */
1495  if ((TEST_OPT_WEIGHTM)&&(F!=NULL))
1496  {
1497  //interred machen Aenderung
1498  strat->pOrigFDeg=currRing->pFDeg;
1499  strat->pOrigLDeg=currRing->pLDeg;
1500  ecartWeights=(short *)omAlloc(((currRing->N)+1)*sizeof(short));
1501  /*uses automatic computation of the ecartWeights to set them*/
1503 
1505  if (TEST_OPT_PROT)
1506  {
1507  for(i=1; i<=(currRing->N); i++)
1508  Print(" %d",ecartWeights[i]);
1509  PrintLn();
1510  mflush();
1511  }
1512  }
1513  kOptimizeLDeg(currRing->pLDeg, strat);
1514 }
int BOOLEAN
Definition: auxiliary.h:85
#define TRUE
Definition: auxiliary.h:98
int i
Definition: cfEzgcd.cc:125
char posInLOldFlag
Definition: kutil.h:376
poly kNoether
Definition: kutil.h:321
BOOLEAN * NotUsedAxis
Definition: kutil.h:325
int(* posInL)(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.h:275
pFDegProc pOrigFDeg
Definition: kutil.h:287
int(* posInLOld)(const LSet Ls, const int Ll, LObject *Lo, const kStrategy strat)
Definition: kutil.h:279
void(* initEcartPair)(LObject *h, poly f, poly g, int ecartF, int ecartG)
Definition: kutil.h:278
void(* enterS)(LObject &h, int pos, kStrategy strat, int atR)
Definition: kutil.h:277
void(* initEcart)(TObject *L)
Definition: kutil.h:271
int(* posInT)(const TSet T, const int tl, LObject &h)
Definition: kutil.h:272
int(* red)(LObject *L, kStrategy strat)
Definition: kutil.h:269
char kHEdgeFound
Definition: kutil.h:370
int HCord
Definition: kutil.h:348
char homog
Definition: kutil.h:366
pLDegProc pOrigLDeg
Definition: kutil.h:288
#define Print
Definition: emacs.cc:80
int j
Definition: facHensel.cc:105
int redFirst(LObject *h, kStrategy strat)
Definition: kstd1.cc:530
int redEcart(LObject *h, kStrategy strat)
Definition: kstd1.cc:168
static void kOptimizeLDeg(pLDegProc ldeg, kStrategy strat)
Definition: kstd1.cc:99
int redRiloc(LObject *h, kStrategy strat)
Definition: kstd1.cc:344
void enterSMora(LObject &p, int atS, kStrategy strat, int atR=-1)
Definition: kstd1.cc:1274
int posInT2(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5196
void initEcartPairMora(LObject *Lp, poly, poly, int ecartF, int ecartG)
Definition: kutil.cc:1261
void initEcartNormal(TObject *h)
Definition: kutil.cc:1239
#define omAlloc(size)
Definition: omAllocDecl.h:210
#define NULL
Definition: omList.c:10
#define TEST_OPT_WEIGHTM
Definition: options.h:119
#define TEST_OPT_PROT
Definition: options.h:102
void pSetDegProcs(ring r, pFDegProc new_FDeg, pLDegProc new_lDeg)
Definition: p_polys.cc:3574
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
#define pCopy(p)
return a copy of the poly
Definition: polys.h:172
void PrintLn()
Definition: reporter.cc:310
#define mflush()
Definition: reporter.h:57
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:477
#define IDELEMS(i)
Definition: simpleideals.h:24
long totaldegreeWecart(poly p, ring r)
Definition: weight.cc:223
long maxdegreeWecart(poly p, int *l, ring r)
Definition: weight.cc:253
void kEcartWeights(poly *s, int sl, short *eweight, const ring R)
Definition: weight.cc:188
short * ecartWeights
Definition: weight0.c:28

◆ 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 3006 of file kstd1.cc.

3007 {
3008  const ring save = currRing;
3009  if( currRing != _currRing ) rChangeCurrRing(_currRing);
3010  poly ret = kNF(F, Q, p, syzComp, lazyReduce);
3011  if( currRing != save ) rChangeCurrRing(save);
3012  return ret;
3013 }
int p
Definition: cfModGcd.cc:4019
poly kNF(ideal F, ideal Q, poly p, int syzComp, int lazyReduce)
Definition: kstd1.cc:2813
void rChangeCurrRing(ring r)
Definition: polys.cc:15
#define Q
Definition: sirandom.c:25

◆ kHomModDeg()

long kHomModDeg ( poly  p,
ring  r = currRing 
)

Definition at line 2083 of file kstd1.cc.

2084 {
2085  int i;
2086  long j=0;
2087 
2088  for (i=r->N;i>0;i--)
2089  j+=p_GetExp(p,i,r)*(*kHomW)[i-1];
2090  if (kModW == NULL) return j;
2091  i = __p_GetComp(p,r);
2092  if (i==0) return j;
2093  return j+(*kModW)[i-1];
2094 }
intvec * kModW
Definition: kstd1.cc:2071
#define __p_GetComp(p, r)
Definition: monomials.h:70
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent @Note: the integer VarOffset encodes:
Definition: p_polys.h:469

◆ kInterRed()

ideal kInterRed ( ideal  F,
ideal  Q = NULL 
)

Definition at line 3387 of file kstd1.cc.

3388 {
3389 #ifdef HAVE_PLURAL
3390  if(rIsPluralRing(currRing)) return kInterRedOld(F,Q);
3391 #endif
3394  )
3395  return kInterRedOld(F,Q);
3396 
3397  //return kInterRedOld(F,Q);
3398 
3399  BITSET save1;
3400  SI_SAVE_OPT1(save1);
3401  //si_opt_1|=Sy_bit(OPT_NOT_SUGAR);
3403  //si_opt_1&= ~Sy_bit(OPT_REDTAIL);
3404  //si_opt_1&= ~Sy_bit(OPT_REDSB);
3405  //extern char * showOption() ;
3406  //Print("%s\n",showOption());
3407 
3408  int need_retry;
3409  int counter=3;
3410  ideal res, res1;
3411  int elems;
3412  ideal null=NULL;
3413  if ((Q==NULL) || (!TEST_OPT_REDSB))
3414  {
3415  elems=idElem(F);
3416  res=kInterRedBba(F,Q,need_retry);
3417  }
3418  else
3419  {
3420  ideal FF=idSimpleAdd(F,Q);
3421  res=kInterRedBba(FF,NULL,need_retry);
3422  idDelete(&FF);
3423  null=idInit(1,1);
3424  if (need_retry)
3425  res1=kNF(null,Q,res,0,KSTD_NF_LAZY);
3426  else
3427  res1=kNF(null,Q,res);
3428  idDelete(&res);
3429  res=res1;
3430  need_retry=1;
3431  }
3432  if (idElem(res)<=1) need_retry=0;
3433  while (need_retry && (counter>0))
3434  {
3435  #ifdef KDEBUG
3436  if (TEST_OPT_DEBUG) { Print("retry counter %d\n",counter); }
3437  #endif
3438  res1=kInterRedBba(res,Q,need_retry);
3439  int new_elems=idElem(res1);
3440  counter -= (new_elems >= elems);
3441  elems = new_elems;
3442  idDelete(&res);
3443  if (idElem(res1)<=1) need_retry=0;
3444  if ((Q!=NULL) && (TEST_OPT_REDSB))
3445  {
3446  if (need_retry)
3447  res=kNF(null,Q,res1,0,KSTD_NF_LAZY);
3448  else
3449  res=kNF(null,Q,res1);
3450  idDelete(&res1);
3451  }
3452  else
3453  res = res1;
3454  if (idElem(res)<=1) need_retry=0;
3455  }
3456  if (null!=NULL) idDelete(&null);
3457  SI_RESTORE_OPT1(save1);
3458  idSkipZeroes(res);
3459  return res;
3460 }
CanonicalForm res
Definition: facAbsFact.cc:64
#define idDelete(H)
delete an ideal
Definition: ideals.h:29
#define idSimpleAdd(A, B)
Definition: ideals.h:42
ideal kInterRedOld(ideal F, ideal Q)
Definition: kstd1.cc:3019
ideal kInterRedBba(ideal F, ideal Q, int &need_retry)
Definition: kstd1.cc:3111
#define KSTD_NF_LAZY
Definition: kstd1.h:17
unsigned si_opt_1
Definition: options.c:5
#define SI_SAVE_OPT1(A)
Definition: options.h:22
#define SI_RESTORE_OPT1(A)
Definition: options.h:25
#define OPT_REDTHROUGH
Definition: options.h:81
#define Sy_bit(x)
Definition: options.h:32
#define TEST_OPT_REDSB
Definition: options.h:103
#define TEST_OPT_DEBUG
Definition: options.h:107
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition: ring.h:404
static BOOLEAN rField_is_numeric(const ring r)
Definition: ring.h:507
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
Definition: ring.h:752
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:37
int idElem(const ideal F)
count non-zero elements
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
#define BITSET
Definition: structs.h:18

◆ kInterRedOld()

ideal kInterRedOld ( ideal  F,
ideal  Q = NULL 
)

Definition at line 3019 of file kstd1.cc.

3020 {
3021  int j;
3022  kStrategy strat = new skStrategy;
3023 
3024  ideal tempF = F;
3025  ideal tempQ = Q;
3026 
3027 #ifdef HAVE_PLURAL
3028  if(rIsSCA(currRing))
3029  {
3030  const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
3031  const unsigned int m_iLastAltVar = scaLastAltVar(currRing);
3032  tempF = id_KillSquares(F, m_iFirstAltVar, m_iLastAltVar, currRing);
3033 
3034  // this should be done on the upper level!!! :
3035  // tempQ = SCAQuotient(currRing);
3036 
3037  if(Q == currRing->qideal)
3038  tempQ = SCAQuotient(currRing);
3039  }
3040 #endif
3041 
3042 // if (TEST_OPT_PROT)
3043 // {
3044 // writeTime("start InterRed:");
3045 // mflush();
3046 // }
3047  //strat->syzComp = 0;
3048  strat->kHEdgeFound = (currRing->ppNoether) != NULL;
3049  strat->kNoether=pCopy((currRing->ppNoether));
3050  strat->ak = id_RankFreeModule(tempF,currRing);
3051  initBuchMoraCrit(strat);
3052  strat->NotUsedAxis = (BOOLEAN *)omAlloc(((currRing->N)+1)*sizeof(BOOLEAN));
3053  for (j=(currRing->N); j>0; j--) strat->NotUsedAxis[j] = TRUE;
3054  strat->enterS = enterSBba;
3055  strat->posInT = posInT17;
3056  strat->initEcart = initEcartNormal;
3057  strat->sl = -1;
3058  strat->tl = -1;
3059  strat->tmax = setmaxT;
3060  strat->T = initT();
3061  strat->R = initR();
3062  strat->sevT = initsevT();
3064  initS(tempF, tempQ, strat);
3065  if (TEST_OPT_REDSB)
3066  strat->noTailReduction=FALSE;
3067  updateS(TRUE,strat);
3069  completeReduce(strat);
3070  //else if (TEST_OPT_PROT) PrintLn();
3071  cleanT(strat);
3072  if (strat->kHEdge!=NULL) pLmFree(&strat->kHEdge);
3073  omFreeSize((ADDRESS)strat->T,strat->tmax*sizeof(TObject));
3074  omFreeSize((ADDRESS)strat->ecartS,IDELEMS(strat->Shdl)*sizeof(int));
3075  omFreeSize((ADDRESS)strat->sevS,IDELEMS(strat->Shdl)*sizeof(unsigned long));
3076  omFreeSize((ADDRESS)strat->NotUsedAxis,((currRing->N)+1)*sizeof(BOOLEAN));
3077  omfree(strat->sevT);
3078  omfree(strat->S_2_R);
3079  omfree(strat->R);
3080 
3081  if (strat->fromQ)
3082  {
3083  for (j=IDELEMS(strat->Shdl)-1;j>=0;j--)
3084  {
3085  if(strat->fromQ[j]) pDelete(&strat->Shdl->m[j]);
3086  }
3087  omFreeSize((ADDRESS)strat->fromQ,IDELEMS(strat->Shdl)*sizeof(int));
3088  }
3089 // if (TEST_OPT_PROT)
3090 // {
3091 // writeTime("end Interred:");
3092 // mflush();
3093 // }
3094  ideal shdl=strat->Shdl;
3095  idSkipZeroes(shdl);
3096  if (strat->fromQ)
3097  {
3098  strat->fromQ=NULL;
3099  ideal res=kInterRed(shdl,NULL);
3100  idDelete(&shdl);
3101  shdl=res;
3102  }
3103  delete(strat);
3104 #ifdef HAVE_PLURAL
3105  if( tempF != F )
3106  id_Delete( &tempF, currRing);
3107 #endif
3108  return shdl;
3109 }
#define FALSE
Definition: auxiliary.h:94
void * ADDRESS
Definition: auxiliary.h:133
int * S_2_R
Definition: kutil.h:335
char noTailReduction
Definition: kutil.h:372
TSet T
Definition: kutil.h:317
intset ecartS
Definition: kutil.h:300
char honey
Definition: kutil.h:371
int ak
Definition: kutil.h:346
TObject ** R
Definition: kutil.h:333
poly kHEdge
Definition: kutil.h:320
int tl
Definition: kutil.h:343
unsigned long * sevT
Definition: kutil.h:316
ideal Shdl
Definition: kutil.h:294
int tmax
Definition: kutil.h:343
intset fromQ
Definition: kutil.h:312
int sl
Definition: kutil.h:341
unsigned long * sevS
Definition: kutil.h:313
KINLINE unsigned long * initsevT()
Definition: kInline.h:97
KINLINE TSet initT()
Definition: kInline.h:81
KINLINE TObject ** initR()
Definition: kInline.h:92
ideal kInterRed(ideal F, ideal Q)
Definition: kstd1.cc:3387
int posInT17(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5631
void initS(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:7848
void updateS(BOOLEAN toT, kStrategy strat)
Definition: kutil.cc:8807
void cleanT(kStrategy strat)
Definition: kutil.cc:537
void initBuchMoraCrit(kStrategy strat)
Definition: kutil.cc:9554
void completeReduce(kStrategy strat, BOOLEAN withT)
Definition: kutil.cc:10399
void enterSBba(LObject &p, int atS, kStrategy strat, int atR)
Definition: kutil.cc:9034
#define setmaxT
Definition: kutil.h:33
class sTObject TObject
Definition: kutil.h:53
static bool rIsSCA(const ring r)
Definition: nc.h:198
ideal id_KillSquares(const ideal id, const short iFirstAltVar, const short iLastAltVar, const ring r, const bool bSkipZeroes)
Definition: sca.cc:1520
#define omfree(addr)
Definition: omAllocDecl.h:237
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
#define TEST_OPT_INTSTRATEGY
Definition: options.h:109
#define pDelete(p_ptr)
Definition: polys.h:173
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
ideal SCAQuotient(const ring r)
Definition: sca.h:10
static short scaLastAltVar(ring r)
Definition: sca.h:25
static short scaFirstAltVar(ring r)
Definition: sca.h:18
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s

◆ 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 2664 of file kstd1.cc.

2666 {
2667  if(idIs0(F))
2668  {
2669  M=idInit(1,F->rank);
2670  return idInit(1,F->rank);
2671  }
2673  {
2674  ideal sb;
2675  sb = kStd(F, Q, h, w, hilb);
2676  idSkipZeroes(sb);
2677  if(IDELEMS(sb) <= IDELEMS(F))
2678  {
2679  M = idCopy(sb);
2680  idSkipZeroes(M);
2681  return(sb);
2682  }
2683  else
2684  {
2685  M = idCopy(F);
2686  idSkipZeroes(M);
2687  return(sb);
2688  }
2689  }
2690  ideal r=NULL;
2691  int Kstd1_OldDeg = Kstd1_deg,i;
2692  intvec* temp_w=NULL;
2693  BOOLEAN b=currRing->pLexOrder,toReset=FALSE;
2694  BOOLEAN delete_w=(w==NULL);
2695  BOOLEAN oldDegBound=TEST_OPT_DEGBOUND;
2696  kStrategy strat=new skStrategy;
2697 
2698  if(!TEST_OPT_RETURN_SB)
2699  strat->syzComp = syzComp;
2701  strat->LazyPass=20;
2702  else
2703  strat->LazyPass=2;
2704  strat->LazyDegree = 1;
2705  strat->minim=(reduced % 2)+1;
2706  strat->ak = id_RankFreeModule(F,currRing);
2707  if (delete_w)
2708  {
2709  temp_w=new intvec((strat->ak)+1);
2710  w = &temp_w;
2711  }
2712  if (h==testHomog)
2713  {
2714  if (strat->ak == 0)
2715  {
2716  h = (tHomog)idHomIdeal(F,Q);
2717  w=NULL;
2718  }
2719  else
2720  {
2721  h = (tHomog)idHomModule(F,Q,w);
2722  }
2723  }
2724  if (h==isHomog)
2725  {
2726  if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
2727  {
2728  kModW = *w;
2729  strat->kModW = *w;
2730  assume(currRing->pFDeg != NULL && currRing->pLDeg != NULL);
2731  strat->pOrigFDeg = currRing->pFDeg;
2732  strat->pOrigLDeg = currRing->pLDeg;
2734 
2735  toReset = TRUE;
2736  if (reduced>1)
2737  {
2738  Kstd1_OldDeg=Kstd1_deg;
2739  Kstd1_deg = -1;
2740  for (i=IDELEMS(F)-1;i>=0;i--)
2741  {
2742  if ((F->m[i]!=NULL) && (currRing->pFDeg(F->m[i],currRing)>=Kstd1_deg))
2743  Kstd1_deg = currRing->pFDeg(F->m[i],currRing)+1;
2744  }
2745  }
2746  }
2747  currRing->pLexOrder = TRUE;
2748  strat->LazyPass*=2;
2749  }
2750  strat->homog=h;
2752  {
2753  if (w!=NULL)
2754  r=mora(F,Q,*w,hilb,strat);
2755  else
2756  r=mora(F,Q,NULL,hilb,strat);
2757  }
2758  else
2759  {
2760  if (w!=NULL)
2761  r=bba(F,Q,*w,hilb,strat);
2762  else
2763  r=bba(F,Q,NULL,hilb,strat);
2764  }
2765 #ifdef KDEBUG
2766  {
2767  int i;
2768  for (i=IDELEMS(r)-1; i>=0; i--) pTest(r->m[i]);
2769  }
2770 #endif
2771  idSkipZeroes(r);
2772  if (toReset)
2773  {
2774  pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
2775  kModW = NULL;
2776  }
2777  currRing->pLexOrder = b;
2778  HCord=strat->HCord;
2779  if ((delete_w)&&(temp_w!=NULL)) delete temp_w;
2780  if ((IDELEMS(r)==1) && (r->m[0]!=NULL) && pIsConstant(r->m[0]) && (strat->ak==0))
2781  {
2782  M=idInit(1,F->rank);
2783  M->m[0]=pOne();
2784  //if (strat->ak!=0) { pSetComp(M->m[0],strat->ak); pSetmComp(M->m[0]); }
2785  if (strat->M!=NULL) idDelete(&strat->M);
2786  }
2787  else if (strat->M==NULL)
2788  {
2789  M=idInit(1,F->rank);
2790  WarnS("no minimal generating set computed");
2791  }
2792  else
2793  {
2794  idSkipZeroes(strat->M);
2795  M=strat->M;
2796  }
2797  delete(strat);
2798  if (reduced>2)
2799  {
2800  Kstd1_deg=Kstd1_OldDeg;
2801  if (!oldDegBound)
2803  }
2804  else
2805  {
2806  if (IDELEMS(M)>IDELEMS(r)) {
2807  idDelete(&M);
2808  M=idCopy(r); }
2809  }
2810  return r;
2811 }
CanonicalForm b
Definition: cfModGcd.cc:4044
Definition: intvec.h:21
intvec * kModW
Definition: kutil.h:328
int syzComp
Definition: kutil.h:347
int minim
Definition: kutil.h:351
ideal M
Definition: kutil.h:296
int LazyPass
Definition: kutil.h:346
int LazyDegree
Definition: kutil.h:346
#define WarnS
Definition: emacs.cc:78
const CanonicalForm & w
Definition: facAbsFact.cc:55
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
static BOOLEAN idHomModule(ideal m, ideal Q, intvec **w)
Definition: ideals.h:96
static BOOLEAN idHomIdeal(ideal id, ideal Q=NULL)
Definition: ideals.h:91
ideal idCopy(ideal A)
Definition: ideals.h:60
static Poly * h
Definition: janet.cc:972
ideal mora(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
Definition: kstd1.cc:1518
long kModDeg(poly p, ring r)
Definition: kstd1.cc:2073
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:2096
int Kstd1_deg
Definition: kstd1.h:47
ideal bba(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
Definition: kstd2.cc:1919
int HCord
Definition: kutil.cc:235
#define assume(x)
Definition: mod2.h:390
#define TEST_OPT_DEGBOUND
Definition: options.h:112
#define TEST_OPT_RETURN_SB
Definition: options.h:111
#define OPT_DEGBOUND
Definition: options.h:89
void pRestoreDegProcs(ring r, pFDegProc old_FDeg, pLDegProc old_lDeg)
Definition: p_polys.cc:3586
#define pTest(p)
Definition: polys.h:401
#define pIsConstant(p)
like above, except that Comp might be != 0
Definition: polys.h:225
#define pOne()
Definition: polys.h:301
static BOOLEAN rField_has_simple_inverse(const ring r)
Definition: ring.h:540
#define M
Definition: sirandom.c:24
tHomog
Definition: structs.h:38
@ isHomog
Definition: structs.h:40
@ testHomog
Definition: structs.h:41

◆ kModDeg()

long kModDeg ( poly  p,
ring  r = currRing 
)

Definition at line 2073 of file kstd1.cc.

2074 {
2075  long o=p_WDegree(p, r);
2076  long i=__p_GetComp(p, r);
2077  if (i==0) return o;
2078  //assume((i>0) && (i<=kModW->length()));
2079  if (i<=kModW->length())
2080  return o+(*kModW)[i-1];
2081  return o;
2082 }
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:267
long p_WDegree(poly p, const ring r)
Definition: p_polys.cc:706

◆ kNF() [1/2]

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

Definition at line 2901 of file kstd1.cc.

2902 {
2903  ideal res;
2904  if (TEST_OPT_PROT)
2905  {
2906  Print("(S:%d)",IDELEMS(p));mflush();
2907  }
2908  if (idIs0(p))
2909  return idInit(IDELEMS(p),si_max(p->rank,F->rank));
2910 
2911  ideal pp = p;
2912 #ifdef HAVE_PLURAL
2913  if(rIsSCA(currRing))
2914  {
2915  const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
2916  const unsigned int m_iLastAltVar = scaLastAltVar(currRing);
2917  pp = id_KillSquares(pp, m_iFirstAltVar, m_iLastAltVar, currRing, false);
2918 
2919  if(Q == currRing->qideal)
2920  Q = SCAQuotient(currRing);
2921  }
2922 #endif
2923 
2924  if ((idIs0(F))&&(Q==NULL))
2925  {
2926 #ifdef HAVE_PLURAL
2927  if(p != pp)
2928  return pp;
2929 #endif
2930  return idCopy(p); /*F+Q=0*/
2931  }
2932 
2933  kStrategy strat=new skStrategy;
2934  strat->syzComp = syzComp;
2936  if (strat->ak>0) // only for module case, see Tst/Short/bug_reduce.tst
2937  {
2938  strat->ak = si_max(strat->ak,(int)F->rank);
2939  }
2940 
2942  res=kNF1(F,Q,pp,strat,lazyReduce);
2943  else
2944  res=kNF2(F,Q,pp,strat,lazyReduce);
2945  delete(strat);
2946 
2947 #ifdef HAVE_PLURAL
2948  if(pp != p)
2949  id_Delete(&pp, currRing);
2950 #endif
2951 
2952  return res;
2953 }
static int si_max(const int a, const int b)
Definition: auxiliary.h:138
CanonicalForm pp(const CanonicalForm &)
CanonicalForm pp ( const CanonicalForm & f )
Definition: cf_gcd.cc:253
poly kNF1(ideal F, ideal Q, poly q, kStrategy strat, int lazyReduce)
Definition: kstd1.cc:1774
poly kNF2(ideal F, ideal Q, poly q, kStrategy strat, int lazyReduce)
Definition: kstd2.cc:3245

◆ kNF() [2/2]

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

Definition at line 2813 of file kstd1.cc.

2814 {
2815  if (p==NULL)
2816  return NULL;
2817 
2818  poly pp = p;
2819 
2820 #ifdef HAVE_PLURAL
2821  if(rIsSCA(currRing))
2822  {
2823  const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
2824  const unsigned int m_iLastAltVar = scaLastAltVar(currRing);
2825  pp = p_KillSquares(pp, m_iFirstAltVar, m_iLastAltVar, currRing);
2826 
2827  if(Q == currRing->qideal)
2828  Q = SCAQuotient(currRing);
2829  }
2830 #endif
2831 
2832  if ((idIs0(F))&&(Q==NULL))
2833  {
2834 #ifdef HAVE_PLURAL
2835  if(p != pp)
2836  return pp;
2837 #endif
2838  return pCopy(p); /*F+Q=0*/
2839  }
2840 
2841  kStrategy strat=new skStrategy;
2842  strat->syzComp = syzComp;
2843  strat->ak = si_max(id_RankFreeModule(F,currRing),pMaxComp(p));
2844  poly res;
2845 
2847  res=kNF1(F,Q,pp,strat,lazyReduce);
2848  else
2849  res=kNF2(F,Q,pp,strat,lazyReduce);
2850  delete(strat);
2851 
2852 #ifdef HAVE_PLURAL
2853  if(pp != p)
2854  p_Delete(&pp, currRing);
2855 #endif
2856  return res;
2857 }
poly p_KillSquares(const poly p, const short iFirstAltVar, const short iLastAltVar, const ring r)
Definition: sca.cc:1465
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:857
#define pMaxComp(p)
Definition: polys.h:285

◆ kNF1() [1/2]

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

Definition at line 1918 of file kstd1.cc.

1919 {
1920  assume(!idIs0(q));
1921  assume(!(idIs0(F)&&(Q==NULL)));
1922 
1923 // lazy_reduce flags: can be combined by |
1924 //#define KSTD_NF_LAZY 1
1925  // do only a reduction of the leading term
1926 //#define KSTD_NF_ECART 2
1927  // only local: recude even with bad ecart
1928  poly p;
1929  int i;
1930  int j;
1931  int o;
1932  LObject h;
1933  ideal res;
1934  BITSET save1;
1935  SI_SAVE_OPT1(save1);
1936 
1937  //if (idIs0(q)) return idInit(IDELEMS(q),si_max(q->rank,F->rank));
1938  //if ((idIs0(F))&&(Q==NULL))
1939  // return idCopy(q); /*F=0*/
1940  //strat->ak = si_max(idRankFreeModule(F),idRankFreeModule(q));
1941  /*- creating temp data structures------------------- -*/
1942  strat->kHEdgeFound = (currRing->ppNoether) != NULL;
1943  strat->kNoether=pCopy((currRing->ppNoether));
1946  && (0<Kstd1_deg)
1947  && ((!strat->kHEdgeFound)
1949  {
1950  pLmDelete(&strat->kNoether);
1951  strat->kNoether=pOne();
1952  pSetExp(strat->kNoether,1, Kstd1_deg+1);
1953  pSetm(strat->kNoether);
1954  strat->kHEdgeFound=TRUE;
1955  }
1956  initBuchMoraCrit(strat);
1958  initBuchMoraPosRing(strat);
1959  else
1960  initBuchMoraPos(strat);
1961  initMora(F,strat);
1962  strat->enterS = enterSMoraNF;
1963  /*- set T -*/
1964  strat->tl = -1;
1965  strat->tmax = setmaxT;
1966  strat->T = initT();
1967  strat->R = initR();
1968  strat->sevT = initsevT();
1969  /*- set S -*/
1970  strat->sl = -1;
1971  /*- init local data struct.-------------------------- -*/
1972  /*Shdl=*/initS(F,Q,strat);
1973  if ((strat->ak!=0)
1974  && (strat->kHEdgeFound))
1975  {
1976  if (strat->ak!=1)
1977  {
1978  pSetComp(strat->kNoether,1);
1979  pSetmComp(strat->kNoether);
1980  poly p=pHead(strat->kNoether);
1981  pSetComp(p,strat->ak);
1982  pSetmComp(p);
1983  p=pAdd(strat->kNoether,p);
1984  strat->kNoether=pNext(p);
1986  }
1987  }
1988  if (TEST_OPT_INTSTRATEGY && ((lazyReduce & KSTD_NF_LAZY)==0))
1989  {
1990  for (i=strat->sl; i>=0; i--)
1991  pNorm(strat->S[i]);
1992  }
1993  /*- compute------------------------------------------- -*/
1994  res=idInit(IDELEMS(q),strat->ak);
1995  for (i=0; i<IDELEMS(q); i++)
1996  {
1997  if (q->m[i]!=NULL)
1998  {
1999  p = pCopy(q->m[i]);
2000  deleteHC(&p,&o,&j,strat);
2001  if (p!=NULL)
2002  {
2003  /*- puts the elements of S also to T -*/
2004  for (j=0; j<=strat->sl; j++)
2005  {
2006  h.p = strat->S[j];
2007  h.ecart = strat->ecartS[j];
2008  h.pLength = h.length = pLength(h.p);
2009  if (strat->sevS[j] == 0) strat->sevS[j] = pGetShortExpVector(h.p);
2010  else assume(strat->sevS[j] == pGetShortExpVector(h.p));
2011  h.sev = strat->sevS[j];
2012  h.SetpFDeg();
2014  enterT_strong(h,strat);
2015  else
2016  enterT(h,strat);
2017  }
2018  if (TEST_OPT_PROT) { PrintS("r"); mflush(); }
2020  {
2021  p = redMoraNFRing(p,strat, lazyReduce & KSTD_NF_ECART);
2022  }
2023  else
2024  p = redMoraNF(p,strat, lazyReduce & KSTD_NF_ECART);
2025  if ((p!=NULL)&&((lazyReduce & KSTD_NF_LAZY)==0))
2026  {
2027  if (TEST_OPT_PROT) { PrintS("t"); mflush(); }
2028  p = redtail(p,strat->sl,strat);
2029  }
2030  cleanT(strat);
2031  }
2032  res->m[i]=p;
2033  }
2034  //else
2035  // res->m[i]=NULL;
2036  }
2037  /*- release temp data------------------------------- -*/
2038  assume(strat->L==NULL); /*strat->L unsed */
2039  assume(strat->B==NULL); /*strat->B unused */
2040  omFreeSize((ADDRESS)strat->T,strat->tmax*sizeof(TObject));
2041  omFreeSize((ADDRESS)strat->ecartS,IDELEMS(strat->Shdl)*sizeof(int));
2042  omFreeSize((ADDRESS)strat->sevS,IDELEMS(strat->Shdl)*sizeof(unsigned long));
2043  omFreeSize((ADDRESS)strat->NotUsedAxis,((currRing->N)+1)*sizeof(BOOLEAN));
2044  omFree(strat->sevT);
2045  omFree(strat->S_2_R);
2046  omFree(strat->R);
2047  if ((Q!=NULL)&&(strat->fromQ!=NULL))
2048  {
2050  omFreeSize((ADDRESS)strat->fromQ,i*sizeof(int));
2051  strat->fromQ=NULL;
2052  }
2053  if (strat->kHEdge!=NULL) pLmFree(&strat->kHEdge);
2054  if (strat->kNoether!=NULL) pLmDelete(&strat->kNoether);
2055 // if ((TEST_OPT_WEIGHTM)&&(F!=NULL))
2056 // {
2057 // pFDeg=strat->pOrigFDeg;
2058 // pLDeg=strat->pOrigLDeg;
2059 // if (ecartWeights)
2060 // {
2061 // omFreeSize((ADDRESS *)&ecartWeights,((currRing->N)+1)*sizeof(short));
2062 // ecartWeights=NULL;
2063 // }
2064 // }
2065  idDelete(&strat->Shdl);
2066  SI_RESTORE_OPT1(save1);
2067  if (TEST_OPT_PROT) PrintLn();
2068  return res;
2069 }
polyset S
Definition: kutil.h:297
LSet B
Definition: kutil.h:319
LSet L
Definition: kutil.h:318
void initMora(ideal F, kStrategy strat)
Definition: kstd1.cc:1461
void enterSMoraNF(LObject &p, int atS, kStrategy strat, int atR=-1)
Definition: kstd1.cc:1328
static poly redMoraNFRing(poly h, kStrategy strat, int flag)
Definition: kstd1.cc:764
static poly redMoraNF(poly h, kStrategy strat, int flag)
Definition: kstd1.cc:664
#define KSTD_NF_ECART
Definition: kstd1.h:19
poly redtail(LObject *L, int end_pos, kStrategy strat)
Definition: kutil.cc:7305
void enterT(LObject &p, kStrategy strat, int atT)
Definition: kutil.cc:9275
void initBuchMoraPos(kStrategy strat)
Definition: kutil.cc:9705
void enterT_strong(LObject &p, kStrategy strat, int atT)
Definition: kutil.cc:9356
void deleteHC(LObject *L, kStrategy strat, BOOLEAN fromNext)
Definition: kutil.cc:243
void initBuchMoraPosRing(kStrategy strat)
Definition: kutil.cc:9791
#define setmaxTinc
Definition: kutil.h:34
class sLObject LObject
Definition: kutil.h:54
#define pNext(p)
Definition: monomials.h:43
#define omFree(addr)
Definition: omAllocDecl.h:261
#define OPT_REDTAIL
Definition: options.h:90
#define TEST_OPT_STAIRCASEBOUND
Definition: options.h:114
static void p_LmDelete(poly p, const ring r)
Definition: p_polys.h:711
static unsigned pLength(poly a)
Definition: p_polys.h:192
#define pAdd(p, q)
Definition: polys.h:190
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL
Definition: polys.h:67
#define pSetm(p)
Definition: polys.h:257
#define pSetComp(p, v)
Definition: polys.h:38
#define pLmDelete(p)
assume p != NULL, deletes Lm(p)->coef and Lm(p)
Definition: polys.h:76
#define pGetShortExpVector(a)
returns the "Short Exponent Vector" – used to speed up divisibility tests (see polys-impl....
Definition: polys.h:152
#define pSetmComp(p)
TODO:
Definition: polys.h:259
void pNorm(poly p, const ring R=currRing)
Definition: polys.h:349
#define pSetExp(p, i, v)
Definition: polys.h:42
#define pWTotaldegree(p)
Definition: polys.h:269
void PrintS(const char *s)
Definition: reporter.cc:284

◆ kNF1() [2/2]

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

Definition at line 1774 of file kstd1.cc.

1775 {
1776  assume(q!=NULL);
1777  assume(!(idIs0(F)&&(Q==NULL)));
1778 
1779 // lazy_reduce flags: can be combined by |
1780 //#define KSTD_NF_LAZY 1
1781  // do only a reduction of the leading term
1782 //#define KSTD_NF_ECART 2
1783  // only local: recude even with bad ecart
1784  poly p;
1785  int i;
1786  int j;
1787  int o;
1788  LObject h;
1789  BITSET save1;
1790  SI_SAVE_OPT1(save1);
1791 
1792  //if ((idIs0(F))&&(Q==NULL))
1793  // return pCopy(q); /*F=0*/
1794  //strat->ak = si_max(idRankFreeModule(F),pMaxComp(q));
1795  /*- creating temp data structures------------------- -*/
1796  strat->kHEdgeFound = (currRing->ppNoether) != NULL;
1797  strat->kNoether = pCopy((currRing->ppNoether));
1801  && (! TEST_V_DEG_STOP)
1802  && (0<Kstd1_deg)
1803  && ((!strat->kHEdgeFound)
1805  {
1806  pLmDelete(&strat->kNoether);
1807  strat->kNoether=pOne();
1808  pSetExp(strat->kNoether,1, Kstd1_deg+1);
1809  pSetm(strat->kNoether);
1810  strat->kHEdgeFound=TRUE;
1811  }
1812  initBuchMoraCrit(strat);
1814  initBuchMoraPosRing(strat);
1815  else
1816  initBuchMoraPos(strat);
1817  initMora(F,strat);
1818  strat->enterS = enterSMoraNF;
1819  /*- set T -*/
1820  strat->tl = -1;
1821  strat->tmax = setmaxT;
1822  strat->T = initT();
1823  strat->R = initR();
1824  strat->sevT = initsevT();
1825  /*- set S -*/
1826  strat->sl = -1;
1827  /*- init local data struct.-------------------------- -*/
1828  /*Shdl=*/initS(F,Q,strat);
1829  if ((strat->ak!=0)
1830  && (strat->kHEdgeFound))
1831  {
1832  if (strat->ak!=1)
1833  {
1834  pSetComp(strat->kNoether,1);
1835  pSetmComp(strat->kNoether);
1836  poly p=pHead(strat->kNoether);
1837  pSetComp(p,strat->ak);
1838  pSetmComp(p);
1839  p=pAdd(strat->kNoether,p);
1840  strat->kNoether=pNext(p);
1842  }
1843  }
1844  if ((lazyReduce & KSTD_NF_LAZY)==0)
1845  {
1846  for (i=strat->sl; i>=0; i--)
1847  pNorm(strat->S[i]);
1848  }
1849  /*- puts the elements of S also to T -*/
1850  for (i=0; i<=strat->sl; i++)
1851  {
1852  h.p = strat->S[i];
1853  h.ecart = strat->ecartS[i];
1854  if (strat->sevS[i] == 0) strat->sevS[i] = pGetShortExpVector(h.p);
1855  else assume(strat->sevS[i] == pGetShortExpVector(h.p));
1856  h.length = pLength(h.p);
1857  h.sev = strat->sevS[i];
1858  h.SetpFDeg();
1859  enterT(h,strat);
1860  }
1861 #ifdef KDEBUG
1862 // kDebugPrint(strat);
1863 #endif
1864  /*- compute------------------------------------------- -*/
1865  p = pCopy(q);
1866  deleteHC(&p,&o,&j,strat);
1867  kTest(strat);
1868  if (TEST_OPT_PROT) { PrintS("r"); mflush(); }
1869  if (BVERBOSE(23)) kDebugPrint(strat);
1871  {
1872  if (p!=NULL) p = redMoraNFRing(p,strat, lazyReduce & KSTD_NF_ECART);
1873  }
1874  else
1875  {
1876  if (p!=NULL) p = redMoraNF(p,strat, lazyReduce & KSTD_NF_ECART);
1877  }
1878  if ((p!=NULL)&&((lazyReduce & KSTD_NF_LAZY)==0))
1879  {
1880  if (TEST_OPT_PROT) { PrintS("t"); mflush(); }
1881  p = redtail(p,strat->sl,strat);
1882  }
1883  /*- release temp data------------------------------- -*/
1884  cleanT(strat);
1885  assume(strat->L==NULL); /*strat->L unsed */
1886  assume(strat->B==NULL); /*strat->B unused */
1887  omFreeSize((ADDRESS)strat->T,strat->tmax*sizeof(TObject));
1888  omFreeSize((ADDRESS)strat->ecartS,IDELEMS(strat->Shdl)*sizeof(int));
1889  omFreeSize((ADDRESS)strat->sevS,IDELEMS(strat->Shdl)*sizeof(unsigned long));
1890  omFreeSize((ADDRESS)strat->NotUsedAxis,((currRing->N)+1)*sizeof(BOOLEAN));
1891  omFree(strat->sevT);
1892  omFree(strat->S_2_R);
1893  omFree(strat->R);
1894 
1895  if ((Q!=NULL)&&(strat->fromQ!=NULL))
1896  {
1897  i=((IDELEMS(Q)+IDELEMS(F)+15)/16)*16;
1898  omFreeSize((ADDRESS)strat->fromQ,i*sizeof(int));
1899  strat->fromQ=NULL;
1900  }
1901  if (strat->kHEdge!=NULL) pLmFree(&strat->kHEdge);
1902  if (strat->kNoether!=NULL) pLmDelete(&strat->kNoether);
1903 // if ((TEST_OPT_WEIGHTM)&&(F!=NULL))
1904 // {
1905 // pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
1906 // if (ecartWeights)
1907 // {
1908 // omFreeSize((ADDRESS *)&ecartWeights,((currRing->N)+1)*sizeof(short));
1909 // ecartWeights=NULL;
1910 // }
1911 // }
1912  idDelete(&strat->Shdl);
1913  SI_RESTORE_OPT1(save1);
1914  if (TEST_OPT_PROT) PrintLn();
1915  return p;
1916 }
void kDebugPrint(kStrategy strat)
Definition: kutil.cc:11583
BOOLEAN kTest(kStrategy strat)
Definition: kutil.cc:909
#define OPT_INTSTRATEGY
Definition: options.h:91
#define BVERBOSE(a)
Definition: options.h:35
#define TEST_V_DEG_STOP
Definition: options.h:135

◆ kNFBound() [1/2]

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

Definition at line 2955 of file kstd1.cc.

2956 {
2957  ideal res;
2958  if (TEST_OPT_PROT)
2959  {
2960  Print("(S:%d)",IDELEMS(p));mflush();
2961  }
2962  if (idIs0(p))
2963  return idInit(IDELEMS(p),si_max(p->rank,F->rank));
2964 
2965  ideal pp = p;
2966 #ifdef HAVE_PLURAL
2967  if(rIsSCA(currRing))
2968  {
2969  const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
2970  const unsigned int m_iLastAltVar = scaLastAltVar(currRing);
2971  pp = id_KillSquares(pp, m_iFirstAltVar, m_iLastAltVar, currRing, false);
2972 
2973  if(Q == currRing->qideal)
2974  Q = SCAQuotient(currRing);
2975  }
2976 #endif
2977 
2978  if ((idIs0(F))&&(Q==NULL))
2979  {
2980 #ifdef HAVE_PLURAL
2981  if(p != pp)
2982  return pp;
2983 #endif
2984  return idCopy(p); /*F+Q=0*/
2985  }
2986 
2987  kStrategy strat=new skStrategy;
2988  strat->syzComp = syzComp;
2990  if (strat->ak>0) // only for module case, see Tst/Short/bug_reduce.tst
2991  {
2992  strat->ak = si_max(strat->ak,(int)F->rank);
2993  }
2994 
2995  res=kNF2Bound(F,Q,pp,bound,strat,lazyReduce);
2996  delete(strat);
2997 
2998 #ifdef HAVE_PLURAL
2999  if(pp != p)
3000  id_Delete(&pp, currRing);
3001 #endif
3002 
3003  return res;
3004 }
static CanonicalForm bound(const CFMatrix &M)
Definition: cf_linsys.cc:460
poly kNF2Bound(ideal F, ideal Q, poly q, int bound, kStrategy strat, int lazyReduce)
Definition: kstd2.cc:3314

◆ kNFBound() [2/2]

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

Definition at line 2859 of file kstd1.cc.

2860 {
2861  if (p==NULL)
2862  return NULL;
2863 
2864  poly pp = p;
2865 
2866 #ifdef HAVE_PLURAL
2867  if(rIsSCA(currRing))
2868  {
2869  const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
2870  const unsigned int m_iLastAltVar = scaLastAltVar(currRing);
2871  pp = p_KillSquares(pp, m_iFirstAltVar, m_iLastAltVar, currRing);
2872 
2873  if(Q == currRing->qideal)
2874  Q = SCAQuotient(currRing);
2875  }
2876 #endif
2877 
2878  if ((idIs0(F))&&(Q==NULL))
2879  {
2880 #ifdef HAVE_PLURAL
2881  if(p != pp)
2882  return pp;
2883 #endif
2884  return pCopy(p); /*F+Q=0*/
2885  }
2886 
2887  kStrategy strat=new skStrategy;
2888  strat->syzComp = syzComp;
2889  strat->ak = si_max(id_RankFreeModule(F,currRing),pMaxComp(p));
2890  poly res;
2891  res=kNF2Bound(F,Q,pp,bound,strat,lazyReduce);
2892  delete(strat);
2893 
2894 #ifdef HAVE_PLURAL
2895  if(pp != p)
2896  p_Delete(&pp, currRing);
2897 #endif
2898  return res;
2899 }

◆ 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 2274 of file kstd1.cc.

2276 {
2277  if(idIs0(F))
2278  return idInit(1,F->rank);
2279  if(!rField_is_Ring(currRing))
2280  {
2281  ideal r;
2282  BOOLEAN b=currRing->pLexOrder,toReset=FALSE;
2283  BOOLEAN delete_w=(w==NULL);
2284  kStrategy strat=new skStrategy;
2285  strat->sbaOrder = sbaOrder;
2286  if (arri!=0)
2287  {
2288  strat->rewCrit1 = arriRewDummy;
2289  strat->rewCrit2 = arriRewCriterion;
2290  strat->rewCrit3 = arriRewCriterionPre;
2291  }
2292  else
2293  {
2294  strat->rewCrit1 = faugereRewCriterion;
2295  strat->rewCrit2 = faugereRewCriterion;
2296  strat->rewCrit3 = faugereRewCriterion;
2297  }
2298 
2299  if(!TEST_OPT_RETURN_SB)
2300  strat->syzComp = syzComp;
2301  if (TEST_OPT_SB_1)
2302  //if(!rField_is_Ring(currRing)) // always true here
2303  strat->newIdeal = newIdeal;
2305  strat->LazyPass=20;
2306  else
2307  strat->LazyPass=2;
2308  strat->LazyDegree = 1;
2310  strat->chainCrit=chainCritNormal;
2312  strat->ak = id_RankFreeModule(F,currRing);
2313  strat->kModW=kModW=NULL;
2314  strat->kHomW=kHomW=NULL;
2315  if (vw != NULL)
2316  {
2317  currRing->pLexOrder=FALSE;
2318  strat->kHomW=kHomW=vw;
2319  strat->pOrigFDeg = currRing->pFDeg;
2320  strat->pOrigLDeg = currRing->pLDeg;
2322  toReset = TRUE;
2323  }
2324  if (h==testHomog)
2325  {
2326  if (strat->ak == 0)
2327  {
2328  h = (tHomog)idHomIdeal(F,Q);
2329  w=NULL;
2330  }
2331  else if (!TEST_OPT_DEGBOUND)
2332  {
2333  h = (tHomog)idHomModule(F,Q,w);
2334  }
2335  }
2336  currRing->pLexOrder=b;
2337  if (h==isHomog)
2338  {
2339  if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
2340  {
2341  strat->kModW = kModW = *w;
2342  if (vw == NULL)
2343  {
2344  strat->pOrigFDeg = currRing->pFDeg;
2345  strat->pOrigLDeg = currRing->pLDeg;
2347  toReset = TRUE;
2348  }
2349  }
2350  currRing->pLexOrder = TRUE;
2351  if (hilb==NULL) strat->LazyPass*=2;
2352  }
2353  strat->homog=h;
2354  #ifdef KDEBUG
2355  idTest(F);
2356  if(Q != NULL)
2357  idTest(Q);
2358  #endif
2359  #ifdef HAVE_PLURAL
2360  if (rIsPluralRing(currRing))
2361  {
2362  const BOOLEAN bIsSCA = rIsSCA(currRing) && strat->z2homog; // for Z_2 prod-crit
2363  strat->no_prod_crit = ! bIsSCA;
2364  if (w!=NULL)
2365  r = nc_GB(F, Q, *w, hilb, strat, currRing);
2366  else
2367  r = nc_GB(F, Q, NULL, hilb, strat, currRing);
2368  }
2369  else
2370  #endif
2371  {
2373  {
2374  if (w!=NULL)
2375  r=mora(F,Q,*w,hilb,strat);
2376  else
2377  r=mora(F,Q,NULL,hilb,strat);
2378  }
2379  else
2380  {
2381  strat->sigdrop = FALSE;
2382  if (w!=NULL)
2383  r=sba(F,Q,*w,hilb,strat);
2384  else
2385  r=sba(F,Q,NULL,hilb,strat);
2386  }
2387  }
2388  #ifdef KDEBUG
2389  idTest(r);
2390  #endif
2391  if (toReset)
2392  {
2393  kModW = NULL;
2394  pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
2395  }
2396  currRing->pLexOrder = b;
2397  //Print("%d reductions canceled \n",strat->cel);
2398  HCord=strat->HCord;
2399  //delete(strat);
2400  if ((delete_w)&&(w!=NULL)&&(*w!=NULL)) delete *w;
2401  return r;
2402  }
2403  else
2404  {
2405  //--------------------------RING CASE-------------------------
2406  assume(sbaOrder == 1);
2407  assume(arri == 0);
2408  ideal r;
2409  r = idCopy(F);
2410  int sbaEnterS = -1;
2411  bool sigdrop = TRUE;
2412  //This is how we set the SBA algorithm;
2413  int totalsbaruns = 1,blockedreductions = 20,blockred = 0,loops = 0;
2414  while(sigdrop && (loops < totalsbaruns || totalsbaruns == -1)
2415  && (blockred <= blockedreductions))
2416  {
2417  loops++;
2418  if(loops == 1)
2419  sigdrop = FALSE;
2420  BOOLEAN b=currRing->pLexOrder,toReset=FALSE;
2421  BOOLEAN delete_w=(w==NULL);
2422  kStrategy strat=new skStrategy;
2423  strat->sbaEnterS = sbaEnterS;
2424  strat->sigdrop = sigdrop;
2425  #if 0
2426  strat->blockred = blockred;
2427  #else
2428  strat->blockred = 0;
2429  #endif
2430  strat->blockredmax = blockedreductions;
2431  //printf("\nsbaEnterS beginning = %i\n",strat->sbaEnterS);
2432  //printf("\nsigdrop beginning = %i\n",strat->sigdrop);
2433  strat->sbaOrder = sbaOrder;
2434  if (arri!=0)
2435  {
2436  strat->rewCrit1 = arriRewDummy;
2437  strat->rewCrit2 = arriRewCriterion;
2438  strat->rewCrit3 = arriRewCriterionPre;
2439  }
2440  else
2441  {
2442  strat->rewCrit1 = faugereRewCriterion;
2443  strat->rewCrit2 = faugereRewCriterion;
2444  strat->rewCrit3 = faugereRewCriterion;
2445  }
2446 
2447  if(!TEST_OPT_RETURN_SB)
2448  strat->syzComp = syzComp;
2449  if (TEST_OPT_SB_1)
2450  if(!rField_is_Ring(currRing))
2451  strat->newIdeal = newIdeal;
2453  strat->LazyPass=20;
2454  else
2455  strat->LazyPass=2;
2456  strat->LazyDegree = 1;
2458  strat->chainCrit=chainCritNormal;
2460  strat->ak = id_RankFreeModule(F,currRing);
2461  strat->kModW=kModW=NULL;
2462  strat->kHomW=kHomW=NULL;
2463  if (vw != NULL)
2464  {
2465  currRing->pLexOrder=FALSE;
2466  strat->kHomW=kHomW=vw;
2467  strat->pOrigFDeg = currRing->pFDeg;
2468  strat->pOrigLDeg = currRing->pLDeg;
2470  toReset = TRUE;
2471  }
2472  if (h==testHomog)
2473  {
2474  if (strat->ak == 0)
2475  {
2476  h = (tHomog)idHomIdeal(F,Q);
2477  w=NULL;
2478  }
2479  else if (!TEST_OPT_DEGBOUND)
2480  {
2481  h = (tHomog)idHomModule(F,Q,w);
2482  }
2483  }
2484  currRing->pLexOrder=b;
2485  if (h==isHomog)
2486  {
2487  if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
2488  {
2489  strat->kModW = kModW = *w;
2490  if (vw == NULL)
2491  {
2492  strat->pOrigFDeg = currRing->pFDeg;
2493  strat->pOrigLDeg = currRing->pLDeg;
2495  toReset = TRUE;
2496  }
2497  }
2498  currRing->pLexOrder = TRUE;
2499  if (hilb==NULL) strat->LazyPass*=2;
2500  }
2501  strat->homog=h;
2502  #ifdef KDEBUG
2503  idTest(F);
2504  if(Q != NULL)
2505  idTest(Q);
2506  #endif
2507  #ifdef HAVE_PLURAL
2508  if (rIsPluralRing(currRing))
2509  {
2510  const BOOLEAN bIsSCA = rIsSCA(currRing) && strat->z2homog; // for Z_2 prod-crit
2511  strat->no_prod_crit = ! bIsSCA;
2512  if (w!=NULL)
2513  r = nc_GB(F, Q, *w, hilb, strat, currRing);
2514  else
2515  r = nc_GB(F, Q, NULL, hilb, strat, currRing);
2516  }
2517  else
2518  #endif
2519  {
2521  {
2522  if (w!=NULL)
2523  r=mora(F,Q,*w,hilb,strat);
2524  else
2525  r=mora(F,Q,NULL,hilb,strat);
2526  }
2527  else
2528  {
2529  if (w!=NULL)
2530  r=sba(r,Q,*w,hilb,strat);
2531  else
2532  {
2533  r=sba(r,Q,NULL,hilb,strat);
2534  }
2535  }
2536  }
2537  #ifdef KDEBUG
2538  idTest(r);
2539  #endif
2540  if (toReset)
2541  {
2542  kModW = NULL;
2543  pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
2544  }
2545  currRing->pLexOrder = b;
2546  //Print("%d reductions canceled \n",strat->cel);
2547  HCord=strat->HCord;
2548  sigdrop = strat->sigdrop;
2549  sbaEnterS = strat->sbaEnterS;
2550  blockred = strat->blockred;
2551  delete(strat);
2552  if ((delete_w)&&(w!=NULL)&&(*w!=NULL)) delete *w;
2553  }
2554  // Go to std
2555  if(sigdrop || blockred > blockedreductions)
2556  {
2557  r = kStd(r, Q, h, w, hilb, syzComp, newIdeal, vw);
2558  }
2559  return r;
2560  }
2561 }
bool sigdrop
Definition: kutil.h:353
void(* chainCrit)(poly p, int ecart, kStrategy strat)
Definition: kutil.h:282
BOOLEAN(* rewCrit1)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.h:284
BOOLEAN(* rewCrit3)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.h:286
intvec * kHomW
Definition: kutil.h:329
int blockred
Definition: kutil.h:358
unsigned sbaOrder
Definition: kutil.h:307
int blockredmax
Definition: kutil.h:359
int newIdeal
Definition: kutil.h:350
char z2homog
Definition: kutil.h:368
char no_prod_crit
Definition: kutil.h:388
void(* enterOnePair)(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR)
Definition: kutil.h:281
BOOLEAN(* rewCrit2)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.h:285
int sbaEnterS
Definition: kutil.h:356
#define idTest(id)
Definition: ideals.h:47
KINLINE BOOLEAN arriRewDummy(poly, unsigned long, poly, kStrategy, int)
Definition: kInline.h:1140
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
intvec * kHomW
Definition: kstd1.cc:2071
long kHomModDeg(poly p, ring r)
Definition: kstd1.cc:2083
ideal sba(ideal F0, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
Definition: kstd2.cc:2272
BOOLEAN arriRewCriterionPre(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int)
Definition: kutil.cc:7113
BOOLEAN arriRewCriterion(poly, unsigned long, poly, kStrategy strat, int start=0)
Definition: kutil.cc:7088
void enterOnePairNormal(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR=-1)
Definition: kutil.cc:1861
BOOLEAN faugereRewCriterion(poly sig, unsigned long not_sevSig, poly, kStrategy strat, int start=0)
Definition: kutil.cc:7029
void chainCritOpt_1(poly, int, kStrategy strat)
Definition: kutil.cc:3337
void chainCritNormal(poly p, int ecart, kStrategy strat)
Definition: kutil.cc:3124
if(yy_init)
Definition: libparse.cc:1418
#define TEST_OPT_SB_1
Definition: options.h:117

◆ 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 2096 of file kstd1.cc.

2098 {
2099  if(idIs0(F))
2100  return idInit(1,F->rank);
2101 
2102  ideal r;
2103  BOOLEAN b=currRing->pLexOrder,toReset=FALSE;
2104  BOOLEAN delete_w=(w==NULL);
2105  kStrategy strat=new skStrategy;
2106 
2107  strat->s_poly=sp;
2108  if(!TEST_OPT_RETURN_SB)
2109  strat->syzComp = syzComp;
2110  if (TEST_OPT_SB_1
2111  &&(!rField_is_Ring(currRing))
2112  )
2113  strat->newIdeal = newIdeal;
2115  strat->LazyPass=20;
2116  else
2117  strat->LazyPass=2;
2118  strat->LazyDegree = 1;
2119  strat->ak = id_RankFreeModule(F,currRing);
2120  strat->kModW=kModW=NULL;
2121  strat->kHomW=kHomW=NULL;
2122  if (vw != NULL)
2123  {
2124  currRing->pLexOrder=FALSE;
2125  strat->kHomW=kHomW=vw;
2126  strat->pOrigFDeg = currRing->pFDeg;
2127  strat->pOrigLDeg = currRing->pLDeg;
2129  toReset = TRUE;
2130  }
2131  if (h==testHomog)
2132  {
2133  if (strat->ak == 0)
2134  {
2135  h = (tHomog)idHomIdeal(F,Q);
2136  w=NULL;
2137  }
2138  else if (!TEST_OPT_DEGBOUND)
2139  {
2140  if (w!=NULL)
2141  h = (tHomog)idHomModule(F,Q,w);
2142  else
2143  h = (tHomog)idHomIdeal(F,Q);
2144  }
2145  }
2146  currRing->pLexOrder=b;
2147  if (h==isHomog)
2148  {
2149  if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
2150  {
2151  strat->kModW = kModW = *w;
2152  if (vw == NULL)
2153  {
2154  strat->pOrigFDeg = currRing->pFDeg;
2155  strat->pOrigLDeg = currRing->pLDeg;
2157  toReset = TRUE;
2158  }
2159  }
2160  currRing->pLexOrder = TRUE;
2161  if (hilb==NULL) strat->LazyPass*=2;
2162  }
2163  strat->homog=h;
2164 #ifdef KDEBUG
2165  idTest(F);
2166  if (Q!=NULL) idTest(Q);
2167 #endif
2168 #ifdef HAVE_PLURAL
2169  if (rIsPluralRing(currRing))
2170  {
2171  const BOOLEAN bIsSCA = rIsSCA(currRing) && strat->z2homog; // for Z_2 prod-crit
2172  strat->no_prod_crit = ! bIsSCA;
2173  if (w!=NULL)
2174  r = nc_GB(F, Q, *w, hilb, strat, currRing);
2175  else
2176  r = nc_GB(F, Q, NULL, hilb, strat, currRing);
2177  }
2178  else
2179 #endif
2180  {
2181  #if PRE_INTEGER_CHECK
2182  //the preinteger check strategy is not for modules
2183  if(rField_is_Ring(currRing) && nCoeff_is_Ring_Z(currRing->cf) && strat->ak <= 0)
2184  {
2185  ideal FCopy = idCopy(F);
2186  poly pFmon = preIntegerCheck(FCopy, Q);
2187  if(pFmon != NULL)
2188  {
2189  idInsertPoly(FCopy, pFmon);
2190  strat->kModW=kModW=NULL;
2191  if (h==testHomog)
2192  {
2193  if (strat->ak == 0)
2194  {
2195  h = (tHomog)idHomIdeal(FCopy,Q);
2196  w=NULL;
2197  }
2198  else if (!TEST_OPT_DEGBOUND)
2199  {
2200  h = (tHomog)idHomModule(FCopy,Q,w);
2201  }
2202  }
2203  currRing->pLexOrder=b;
2204  if (h==isHomog)
2205  {
2206  if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
2207  {
2208  strat->kModW = kModW = *w;
2209  if (vw == NULL)
2210  {
2211  strat->pOrigFDeg = currRing->pFDeg;
2212  strat->pOrigLDeg = currRing->pLDeg;
2214  toReset = TRUE;
2215  }
2216  }
2217  currRing->pLexOrder = TRUE;
2218  if (hilb==NULL) strat->LazyPass*=2;
2219  }
2220  strat->homog=h;
2221  }
2222  omTestMemory(1);
2223  if(w == NULL)
2224  {
2226  r=mora(FCopy,Q,NULL,hilb,strat);
2227  else
2228  r=bba(FCopy,Q,NULL,hilb,strat);
2229  }
2230  else
2231  {
2233  r=mora(FCopy,Q,*w,hilb,strat);
2234  else
2235  r=bba(FCopy,Q,*w,hilb,strat);
2236  }
2237  idDelete(&FCopy);
2238  }
2239  else
2240  #endif
2241  {
2242  if(w==NULL)
2243  {
2245  r=mora(F,Q,NULL,hilb,strat);
2246  else
2247  r=bba(F,Q,NULL,hilb,strat);
2248  }
2249  else
2250  {
2252  r=mora(F,Q,*w,hilb,strat);
2253  else
2254  r=bba(F,Q,*w,hilb,strat);
2255  }
2256  }
2257  }
2258 #ifdef KDEBUG
2259  idTest(r);
2260 #endif
2261  if (toReset)
2262  {
2263  kModW = NULL;
2264  pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
2265  }
2266  currRing->pLexOrder = b;
2267 //Print("%d reductions canceled \n",strat->cel);
2268  HCord=strat->HCord;
2269  delete(strat);
2270  if ((delete_w)&&(w!=NULL)&&(*w!=NULL)) delete *w;
2271  return r;
2272 }
s_poly_proc_t s_poly
Definition: kutil.h:291
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_Z(const coeffs r)
Definition: coeffs.h:756
BOOLEAN idInsertPoly(ideal h1, poly h2)
insert h2 into h1 (if h2 is not the zero polynomial) return TRUE iff h2 was indeed inserted
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:10646
omError_t omTestMemory(int check_level)
Definition: omDebug.c:94

◆ kStdShift()

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

Definition at line 2564 of file kstd1.cc.

2566 {
2567  ideal r;
2568  BOOLEAN b=currRing->pLexOrder,toReset=FALSE;
2569  BOOLEAN delete_w=(w==NULL);
2570  kStrategy strat=new skStrategy;
2571 
2572  if(!TEST_OPT_RETURN_SB)
2573  strat->syzComp = syzComp;
2574  if (TEST_OPT_SB_1)
2575  if(!rField_is_Ring(currRing))
2576  strat->newIdeal = newIdeal;
2578  strat->LazyPass=20;
2579  else
2580  strat->LazyPass=2;
2581  strat->LazyDegree = 1;
2582  strat->ak = id_RankFreeModule(F,currRing);
2583  strat->kModW=kModW=NULL;
2584  strat->kHomW=kHomW=NULL;
2585  if (vw != NULL)
2586  {
2587  currRing->pLexOrder=FALSE;
2588  strat->kHomW=kHomW=vw;
2589  strat->pOrigFDeg = currRing->pFDeg;
2590  strat->pOrigLDeg = currRing->pLDeg;
2592  toReset = TRUE;
2593  }
2594  if (h==testHomog)
2595  {
2596  if (strat->ak == 0)
2597  {
2598  h = (tHomog)idHomIdeal(F,Q);
2599  w=NULL;
2600  }
2601  else if (!TEST_OPT_DEGBOUND)
2602  {
2603  h = (tHomog)idHomModule(F,Q,w);
2604  }
2605  }
2606  currRing->pLexOrder=b;
2607  if (h==isHomog)
2608  {
2609  if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
2610  {
2611  strat->kModW = kModW = *w;
2612  if (vw == NULL)
2613  {
2614  strat->pOrigFDeg = currRing->pFDeg;
2615  strat->pOrigLDeg = currRing->pLDeg;
2617  toReset = TRUE;
2618  }
2619  }
2620  currRing->pLexOrder = TRUE;
2621  if (hilb==NULL) strat->LazyPass*=2;
2622  }
2623  strat->homog=h;
2624 #ifdef KDEBUG
2625  idTest(F);
2626 #endif
2628  {
2629  /* error: no local ord yet with shifts */
2630  WerrorS("No local ordering possible for shift algebra");
2631  return(NULL);
2632  }
2633  else
2634  {
2635  /* global ordering */
2636  if (w!=NULL)
2637  r=bbaShift(F,Q,*w,hilb,strat,uptodeg,lV);
2638  else
2639  r=bbaShift(F,Q,NULL,hilb,strat,uptodeg,lV);
2640  }
2641 #ifdef KDEBUG
2642  idTest(r);
2643 #endif
2644  if (toReset)
2645  {
2646  kModW = NULL;
2647  pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
2648  }
2649  currRing->pLexOrder = b;
2650 //Print("%d reductions canceled \n",strat->cel);
2651  HCord=strat->HCord;
2652  delete(strat);
2653  if ((delete_w)&&(w!=NULL)&&(*w!=NULL)) delete *w;
2654  return r;
2655 }
void WerrorS(const char *s)
Definition: feFopen.cc:24
ideal bbaShift(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat, int uptodeg, int lV)
Definition: kstd2.cc:3862

◆ mora()

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

Definition at line 1518 of file kstd1.cc.

1519 {
1520  int olddeg = 0;
1521  int reduc = 0;
1522  int red_result = 1;
1523  int hilbeledeg=1,hilbcount=0;
1524  BITSET save1;
1525  SI_SAVE_OPT1(save1);
1527  {
1528  si_opt_1 &= ~Sy_bit(OPT_REDSB);
1530  }
1531 
1532  strat->update = TRUE;
1533  /*- setting global variables ------------------- -*/
1534  initBuchMoraCrit(strat);
1535  initHilbCrit(F,Q,&hilb,strat);
1536  initMora(F,strat);
1538  initBuchMoraPosRing(strat);
1539  else
1540  initBuchMoraPos(strat);
1541  /*Shdl=*/initBuchMora(F,Q,strat);
1542  if (TEST_OPT_FASTHC) missingAxis(&strat->lastAxis,strat);
1543  /*updateS in initBuchMora has Hecketest
1544  * and could have put strat->kHEdgdeFound FALSE*/
1545  if ((currRing->ppNoether)!=NULL)
1546  {
1547  strat->kHEdgeFound = TRUE;
1548  }
1549  if (strat->kHEdgeFound && strat->update)
1550  {
1551  firstUpdate(strat);
1552  updateLHC(strat);
1553  reorderL(strat);
1554  }
1555  if (TEST_OPT_FASTHC && (strat->lastAxis) && strat->posInLOldFlag)
1556  {
1557  strat->posInLOld = strat->posInL;
1558  strat->posInLOldFlag = FALSE;
1559  strat->posInL = posInL10;
1560  updateL(strat);
1561  reorderL(strat);
1562  }
1563  kTest_TS(strat);
1564  strat->use_buckets = kMoraUseBucket(strat);
1565 
1566 #ifdef HAVE_TAIL_RING
1567  if (strat->homog && strat->red == redFirst)
1568  if(!idIs0(F) &&(!rField_is_Ring(currRing)))
1569  kStratInitChangeTailRing(strat);
1570 #endif
1571 
1572  if (BVERBOSE(23))
1573  {
1574  kDebugPrint(strat);
1575  }
1576 //deleteInL(strat->L,&strat->Ll,1,strat);
1577 //deleteInL(strat->L,&strat->Ll,0,strat);
1578 
1579  /*- compute-------------------------------------------*/
1580  while (strat->Ll >= 0)
1581  {
1582  #ifdef KDEBUG
1583  if (TEST_OPT_DEBUG) messageSets(strat);
1584  #endif
1585  if (siCntrlc)
1586  {
1587  while (strat->Ll >= 0)
1588  deleteInL(strat->L,&strat->Ll,strat->Ll,strat);
1589  strat->noClearS=TRUE;
1590  }
1591  if (TEST_OPT_DEGBOUND
1592  && (strat->L[strat->Ll].ecart+strat->L[strat->Ll].GetpFDeg()> Kstd1_deg))
1593  {
1594  /*
1595  * stops computation if
1596  * - 24 (degBound)
1597  * && upper degree is bigger than Kstd1_deg
1598  */
1599  while ((strat->Ll >= 0)
1600  && (strat->L[strat->Ll].p1!=NULL) && (strat->L[strat->Ll].p2!=NULL)
1601  && (strat->L[strat->Ll].ecart+strat->L[strat->Ll].GetpFDeg()> Kstd1_deg)
1602  )
1603  {
1604  deleteInL(strat->L,&strat->Ll,strat->Ll,strat);
1605  //if (TEST_OPT_PROT)
1606  //{
1607  // PrintS("D"); mflush();
1608  //}
1609  }
1610  if (strat->Ll<0) break;
1611  else strat->noClearS=TRUE;
1612  }
1613  strat->P = strat->L[strat->Ll];/*- picks the last element from the lazyset L -*/
1614  if (strat->Ll==0) strat->interpt=TRUE;
1615  strat->Ll--;
1616  // create the real Spoly
1617  if (pNext(strat->P.p) == strat->tail)
1618  {
1619  /*- deletes the short spoly and computes -*/
1620  if (rField_is_Ring(currRing))
1621  pLmDelete(strat->P.p);
1622  else
1623  pLmFree(strat->P.p);
1624  strat->P.p = NULL;
1625  poly m1 = NULL, m2 = NULL;
1626  // check that spoly creation is ok
1627  while (strat->tailRing != currRing &&
1628  !kCheckSpolyCreation(&(strat->P), strat, m1, m2))
1629  {
1630  assume(m1 == NULL && m2 == NULL);
1631  // if not, change to a ring where exponents are large enough
1632  kStratChangeTailRing(strat);
1633  }
1634  /* create the real one */
1635  ksCreateSpoly(&(strat->P), strat->kNoetherTail(), strat->use_buckets,
1636  strat->tailRing, m1, m2, strat->R);
1637  if (!strat->use_buckets)
1638  strat->P.SetLength(strat->length_pLength);
1639  }
1640  else if (strat->P.p1 == NULL)
1641  {
1642  // for input polys, prepare reduction (buckets !)
1643  strat->P.SetLength(strat->length_pLength);
1644  strat->P.PrepareRed(strat->use_buckets);
1645  }
1646 
1647  // the s-poly
1648  if (!strat->P.IsNull())
1649  {
1650  // might be NULL from noether !!!
1651  if (TEST_OPT_PROT)
1652  message(strat->P.ecart+strat->P.GetpFDeg(),&olddeg,&reduc,strat, red_result);
1653  // reduce
1654  red_result = strat->red(&strat->P,strat);
1655  }
1656 
1657  // the reduced s-poly
1658  if (! strat->P.IsNull())
1659  {
1660  strat->P.GetP();
1661  // statistics
1662  if (TEST_OPT_PROT) PrintS("s");
1663  // normalization
1665  strat->P.pCleardenom();
1666  else
1667  strat->P.pNorm();
1668  // tailreduction
1669  strat->P.p = redtail(&(strat->P),strat->sl,strat);
1670  if (strat->P.p==NULL)
1671  {
1672  WerrorS("expoent overflow - wrong ordering");
1673  return(idInit(1,1));
1674  }
1675  // set ecart -- might have changed because of tail reductions
1676  if ((!strat->noTailReduction) && (!strat->honey))
1677  strat->initEcart(&strat->P);
1678  // cancel unit
1679  cancelunit(&strat->P);
1680  // for char 0, clear denominators
1681  if ((strat->P.p->next==NULL) /* i.e. cancelunit did something*/
1683  strat->P.pCleardenom();
1684 
1685  enterT(strat->P,strat);
1686  // build new pairs
1687  if (rField_is_Ring(currRing))
1688  superenterpairs(strat->P.p,strat->sl,strat->P.ecart,0,strat, strat->tl);
1689  else
1690  enterpairs(strat->P.p,strat->sl,strat->P.ecart,0,strat, strat->tl);
1691  // put in S
1692  strat->enterS(strat->P,
1693  posInS(strat,strat->sl,strat->P.p, strat->P.ecart),
1694  strat, strat->tl);
1695  // apply hilbert criterion
1696  if (hilb!=NULL)
1697  {
1698  if (strat->homog==isHomog)
1699  khCheck(Q,w,hilb,hilbeledeg,hilbcount,strat);
1700  else
1701  khCheckLocInhom(Q,w,hilb,hilbcount,strat);
1702  }
1703 
1704  // clear strat->P
1705  if (strat->P.lcm!=NULL)
1706  {
1707  if (rField_is_Ring(currRing))
1708  pLmDelete(strat->P.lcm);
1709  else
1710  pLmFree(strat->P.lcm);
1711  strat->P.lcm=NULL;
1712  }
1713 
1714 #ifdef KDEBUG
1715  // make sure kTest_TS does not complain about strat->P
1716  memset(&strat->P,0,sizeof(strat->P));
1717 #endif
1718  }
1719  if (strat->kHEdgeFound)
1720  {
1721  if ((TEST_OPT_FINDET)
1722  || ((TEST_OPT_MULTBOUND) && (scMult0Int(strat->Shdl,NULL,strat->tailRing) < Kstd1_mu)))
1723  {
1724  // obachman: is this still used ???
1725  /*
1726  * stops computation if strat->kHEdgeFound and
1727  * - 27 (finiteDeterminacyTest)
1728  * or
1729  * - 23
1730  * (multBound)
1731  * && multiplicity of the ideal is smaller then a predefined number mu
1732  */
1733  while (strat->Ll >= 0) deleteInL(strat->L,&strat->Ll,strat->Ll,strat);
1734  }
1735  }
1736  kTest_TS(strat);
1737  }
1738  /*- complete reduction of the standard basis------------------------ -*/
1739  if (TEST_OPT_REDSB) completeReduce(strat);
1740  else if (TEST_OPT_PROT) PrintLn();
1741  /*- release temp data------------------------------- -*/
1742  exitBuchMora(strat);
1743  /*- polynomials used for HECKE: HC, noether -*/
1744  if (TEST_OPT_FINDET)
1745  {
1746  if (strat->kHEdge!=NULL)
1747  Kstd1_mu=currRing->pFDeg(strat->kHEdge,currRing);
1748  else
1749  Kstd1_mu=-1;
1750  }
1751  if (strat->kHEdge!=NULL) pLmFree(&strat->kHEdge);
1752  strat->update = TRUE; //???
1753  strat->lastAxis = 0; //???
1754  if (strat->kNoether!=NULL) pLmDelete(&strat->kNoether);
1755  omFreeSize((ADDRESS)strat->NotUsedAxis,((currRing->N)+1)*sizeof(BOOLEAN));
1756  if ((TEST_OPT_PROT)||(TEST_OPT_DEBUG)) messageStat(hilbcount,strat);
1757 // if (TEST_OPT_WEIGHTM)
1758 // {
1759 // pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
1760 // if (ecartWeights)
1761 // {
1762 // omFreeSize((ADDRESS)ecartWeights,((currRing->N)+1)*sizeof(short));
1763 // ecartWeights=NULL;
1764 // }
1765 // }
1766  if(nCoeff_is_Ring_Z(currRing->cf))
1767  finalReduceByMon(strat);
1768  if (Q!=NULL) updateResult(strat->Shdl,Q,strat);
1769  SI_RESTORE_OPT1(save1);
1770  idTest(strat->Shdl);
1771  return (strat->Shdl);
1772 }
KINLINE poly kNoetherTail()
Definition: kInline.h:63
ring tailRing
Definition: kutil.h:336
int Ll
Definition: kutil.h:344
int lastAxis
Definition: kutil.h:349
poly tail
Definition: kutil.h:327
char use_buckets
Definition: kutil.h:377
char interpt
Definition: kutil.h:365
LObject P
Definition: kutil.h:293
char noClearS
Definition: kutil.h:396
char length_pLength
Definition: kutil.h:381
char update
Definition: kutil.h:375
int scMult0Int(ideal S, ideal Q, const ring tailRing)
Definition: hdegree.cc:919
void khCheckLocInhom(ideal Q, intvec *w, intvec *hilb, int &count, kStrategy strat)
Definition: khstd.cc:133
void khCheck(ideal Q, intvec *w, intvec *hilb, int &eledeg, int &count, kStrategy strat)
Definition: khstd.cc:28
void ksCreateSpoly(LObject *Pair, poly spNoether, int use_buckets, ring tailRing, poly m1, poly m2, TObject **R)
Definition: kspoly.cc:759
void firstUpdate(kStrategy strat)
Definition: kstd1.cc:1207
void updateLHC(kStrategy strat)
Definition: kstd1.cc:1114
void missingAxis(int *last, kStrategy strat)
Definition: kstd1.cc:927
void reorderL(kStrategy strat)
Definition: kstd1.cc:869
int posInL10(const LSet set, const int length, LObject *p, const kStrategy strat)
Definition: kstd1.cc:1010
static BOOLEAN kMoraUseBucket(kStrategy strat)
Definition: kstd1.cc:3463
void updateL(kStrategy strat)
Definition: kstd1.cc:1043
int Kstd1_mu
Definition: kstd1.h:47
void message(int i, int *reduc, int *olddeg, kStrategy strat, int red_result)
Definition: kutil.cc:7729
void initBuchMora(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:9878
BOOLEAN kTest_TS(kStrategy strat)
Definition: kutil.cc:982
void enterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
Definition: kutil.cc:4759
void initHilbCrit(ideal, ideal, intvec **hilb, kStrategy strat)
Definition: kutil.cc:9536
BOOLEAN kStratChangeTailRing(kStrategy strat, LObject *L, TObject *T, unsigned long expbound)
Definition: kutil.cc:11037
void exitBuchMora(kStrategy strat)
Definition: kutil.cc:9954
int posInS(const kStrategy strat, const int length, const poly p, const int ecart_p)
Definition: kutil.cc:4935
BOOLEAN kCheckSpolyCreation(LObject *L, kStrategy strat, poly &m1, poly &m2)
Definition: kutil.cc:10585
void updateResult(ideal r, ideal Q, kStrategy strat)
Definition: kutil.cc:10187
void superenterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
Definition: kutil.cc:4731
void deleteInL(LSet set, int *length, int j, kStrategy strat)
Definition: kutil.cc:1152
void kStratInitChangeTailRing(kStrategy strat)
Definition: kutil.cc:11136
void messageSets(kStrategy strat)
Definition: kutil.cc:7800
void messageStat(int hilbcount, kStrategy strat)
Definition: kutil.cc:7770
void finalReduceByMon(kStrategy strat)
used for GB over ZZ: final reduction by constant elements background: any known constant element of i...
Definition: kutil.cc:10971
void cancelunit(LObject *L, BOOLEAN inNF)
Definition: kutil.cc:332
BOOLEAN siCntrlc
Definition: options.c:14
#define TEST_OPT_FINDET
Definition: options.h:110
#define OPT_REDSB
Definition: options.h:75
#define TEST_OPT_MULTBOUND
Definition: options.h:113
#define TEST_OPT_FASTHC
Definition: options.h:108
BOOLEAN rHasMixedOrdering(const ring r)
Definition: ring.h:753

◆ stdred()

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

Variable Documentation

◆ kHomW

intvec* kHomW
extern

Definition at line 2071 of file kstd1.cc.

◆ kModW

intvec* kModW
extern

Definition at line 2071 of file kstd1.cc.

◆ kOptions

BITSET kOptions
extern

Definition at line 44 of file kstd1.cc.

◆ Kstd1_deg

int Kstd1_deg

Definition at line 47 of file kstd1.h.

◆ Kstd1_mu

int Kstd1_mu

Definition at line 47 of file kstd1.h.

◆ LazyDegree

int LazyDegree

Definition at line 47 of file kstd1.h.

◆ LazyPass

int LazyPass
extern

◆ validOpts

BITSET validOpts
extern

Definition at line 59 of file kstd1.cc.