Typedefs | Functions | Variables
gb_hack.h File Reference
#include <polys/nc/nc.h>

Go to the source code of this file.

Typedefs

typedef polyrec * poly
 

Functions

ideal k_gnc_gr_bba (const ideal, const ideal, const intvec *, const intvec *, kStrategy, const ring _currRing)
 
ideal k_gnc_gr_mora (const ideal, const ideal, const intvec *, const intvec *, kStrategy, const ring _currRing)
 
ideal k_sca_gr_bba (const ideal, const ideal, const intvec *, const intvec *, kStrategy, const ring _currRing)
 Modified Plural's Buchberger's algorithmus. More...
 
ideal k_sca_bba (const ideal, const ideal, const intvec *, const intvec *, kStrategy, const ring _currRing)
 Modified modern Sinuglar Buchberger's algorithm. More...
 
ideal k_sca_mora (const ideal, const ideal, const intvec *, const intvec *, kStrategy, const ring _currRing)
 Modified modern Sinuglar Mora's algorithm. More...
 

Variables

NF_Proc nc_NF
 
BBA_Proc gnc_gr_bba
 
BBA_Proc gnc_gr_mora
 
BBA_Proc sca_bba
 
BBA_Proc sca_mora
 
BBA_Proc sca_gr_bba
 

Typedef Documentation

§ poly

typedef polyrec* poly

Definition at line 9 of file gb_hack.h.

Function Documentation

§ k_gnc_gr_bba()

ideal k_gnc_gr_bba ( const ideal  ,
const ideal  ,
const intvec ,
const intvec ,
kStrategy  ,
const ring  _currRing 
)

Definition at line 1055 of file gr_kstd2.cc.

1056 {
1057  const ring save = currRing; if( currRing != _currRing ) rChangeCurrRing(_currRing);
1058 
1059 #if MYTEST
1060  PrintS("<gnc_gr_bba>\n");
1061 #endif
1062 
1063 #ifdef HAVE_PLURAL
1064 #if MYTEST
1065  PrintS("currRing: \n");
1066  rWrite(currRing);
1067 #ifdef RDEBUG
1069 #endif
1070 
1071  PrintS("F: \n");
1072  idPrint(F);
1073  PrintS("Q: \n");
1074  idPrint(Q);
1075 #endif
1076 #endif
1077 
1078  assume(currRing->OrdSgn != -1); // no mora!!! it terminates only for global ordering!!! (?)
1079 
1080  // intvec *w=NULL;
1081  // intvec *hilb=NULL;
1082  int olddeg,reduc;
1083  int red_result=1;
1084  int /*hilbeledeg=1,*/hilbcount=0/*,minimcnt=0*/;
1085 
1086  initBuchMoraCrit(strat); /*set Gebauer, honey, sugarCrit*/
1087  // initHilbCrit(F,Q,&hilb,strat);
1088  /* in plural we don't need Hilb yet */
1089  nc_gr_initBba(F,strat);
1091  if (rIsRatGRing(currRing))
1092  {
1093  strat->posInL=posInL0; // by pCmp of lcm
1094  }
1095  /*set enterS, spSpolyShort, reduce, red, initEcart, initEcartPair*/
1096  /*Shdl=*/initBuchMora(F, Q,strat);
1098  reduc = olddeg = 0;
1099 
1100  /* compute------------------------------------------------------- */
1101  while (strat->Ll >= 0)
1102  {
1104 
1105  if (strat->Ll== 0) strat->interpt=TRUE;
1106  if (TEST_OPT_DEGBOUND
1107  && ((strat->honey
1108  && (strat->L[strat->Ll].ecart+currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg))
1109  || ((!strat->honey) && (currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg))))
1110  {
1111  /*
1112  *stops computation if
1113  * 24 IN test and the degree +ecart of L[strat->Ll] is bigger then
1114  *a predefined number Kstd1_deg
1115  */
1116  while (strat->Ll >= 0) deleteInL(strat->L,&strat->Ll,strat->Ll,strat);
1117  break;
1118  }
1119  /* picks the last element from the lazyset L */
1120  strat->P = strat->L[strat->Ll];
1121  strat->Ll--;
1122  //kTest(strat);
1123 
1124  if (strat->P.p != NULL)
1125  if (pNext(strat->P.p) == strat->tail)
1126  {
1127  /* deletes the short spoly and computes */
1128  pLmFree(strat->P.p);
1129  /* the real one */
1130 // if (ncRingType(currRing)==nc_lie) /* prod crit */
1131 // if(pHasNotCF(strat->P.p1,strat->P.p2))
1132 // {
1133 // strat->cp++;
1134 // /* prod.crit itself in nc_CreateSpoly */
1135 // }
1136 
1137 
1138  if( ! rIsRatGRing(currRing) )
1139  {
1140  strat->P.p = nc_CreateSpoly(strat->P.p1,strat->P.p2,currRing);
1141  }
1142 #ifdef HAVE_RATGRING
1143  else
1144  {
1145  /* rational case */
1146  strat->P.p = nc_rat_CreateSpoly(strat->P.p1,strat->P.p2,currRing->real_var_start-1,currRing);
1147  }
1148 #endif
1149 
1150 
1151 #ifdef PDEBUG
1152  p_Test(strat->P.p, currRing);
1153 #endif
1154 
1155 #if MYTEST
1156  if (TEST_OPT_DEBUG)
1157  {
1158  PrintS("p1: "); pWrite(strat->P.p1);
1159  PrintS("p2: "); pWrite(strat->P.p2);
1160  PrintS("SPoly: "); pWrite(strat->P.p);
1161  }
1162 #endif
1163  }
1164 
1165 
1166  if (strat->P.p != NULL)
1167  {
1168  if (TEST_OPT_PROT)
1169  message((strat->honey ? strat->P.ecart : 0) + strat->P.pFDeg(),
1170  &olddeg,&reduc,strat, red_result);
1171 
1172 #if MYTEST
1173  if (TEST_OPT_DEBUG)
1174  {
1175  PrintS("p1: "); pWrite(strat->P.p1);
1176  PrintS("p2: "); pWrite(strat->P.p2);
1177  PrintS("SPoly before: "); pWrite(strat->P.p);
1178  }
1179 #endif
1180 
1181  /* reduction of the element chosen from L */
1182  strat->red(&strat->P,strat);
1183 
1184 #if MYTEST
1185  if (TEST_OPT_DEBUG)
1186  {
1187  PrintS("red SPoly: "); pWrite(strat->P.p);
1188  }
1189 #endif
1190  }
1191  if (strat->P.p != NULL)
1192  {
1193  if (TEST_OPT_PROT)
1194  {
1195  PrintS("s\n");
1196  }
1197  /* enter P.p into s and L */
1198  {
1199 /* quick unit detection in the rational case */
1200 #ifdef HAVE_RATGRING
1201  if( rIsRatGRing(currRing) )
1202  {
1203  if ( p_LmIsConstantRat(strat->P.p, currRing) )
1204  {
1205 #ifdef PDEBUG
1206  PrintS("unit element detected:");
1207  p_wrp(strat->P.p,currRing);
1208 #endif
1209  p_Delete(&strat->P.p,currRing, strat->tailRing);
1210  strat->P.p = pOne();
1211  }
1212  }
1213 #endif
1214  strat->P.sev=0;
1215  int pos=posInS(strat,strat->sl,strat->P.p, strat->P.ecart);
1216  {
1218  {
1219  if ((strat->syzComp==0)||(!strat->homog))
1220  {
1221  #ifdef HAVE_RATGRING
1222  if(!rIsRatGRing(currRing))
1223  #endif
1224  strat->P.p = redtailBba(strat->P.p,pos-1,strat);
1225  }
1226 
1227  strat->P.p=p_Cleardenom(strat->P.p, currRing);
1228  }
1229  else
1230  {
1231  pNorm(strat->P.p);
1232  if ((strat->syzComp==0)||(!strat->homog))
1233  {
1234  strat->P.p = redtailBba(strat->P.p,pos-1,strat);
1235  }
1236  }
1237  if (TEST_OPT_DEBUG)
1238  {
1239  PrintS("new s:"); wrp(strat->P.p);
1240  PrintLn();
1241 #if MYTEST
1242  PrintS("s: "); pWrite(strat->P.p);
1243 #endif
1244 
1245  }
1246  // kTest(strat);
1247  //
1248  enterpairs(strat->P.p,strat->sl,strat->P.ecart,pos,strat);
1249 
1250  if (strat->sl==-1) pos=0;
1251  else pos=posInS(strat,strat->sl,strat->P.p,strat->P.ecart);
1252 
1253  strat->enterS(strat->P,pos,strat,-1);
1254  }
1255 // if (hilb!=NULL) khCheck(Q,w,hilb,hilbeledeg,hilbcount,strat);
1256  }
1257  if (strat->P.lcm!=NULL) pLmFree(strat->P.lcm);
1258  }
1259 #ifdef KDEBUG
1260  strat->P.lcm=NULL;
1261 #endif
1262  //kTest(strat);
1263  }
1264  if (TEST_OPT_DEBUG) messageSets(strat);
1265 
1266  /* complete reduction of the standard basis--------- */
1267  if (TEST_OPT_SB_1)
1268  {
1269  int k=1;
1270  int j;
1271  while(k<=strat->sl)
1272  {
1273  j=0;
1274  loop
1275  {
1276  if (j>=k) break;
1277  clearS(strat->S[j],strat->sevS[j],&k,&j,strat);
1278  j++;
1279  }
1280  k++;
1281  }
1282  }
1283 
1284  if (TEST_OPT_REDSB)
1285  completeReduce(strat);
1286  /* release temp data-------------------------------- */
1287  exitBuchMora(strat);
1288 // if (TEST_OPT_WEIGHTM)
1289 // {
1290 // currRing->pFDeg=pFDegOld;
1291 // currRing->pLDeg=pLDegOld;
1292 // if (ecartWeights)
1293 // {
1294 // omFreeSize((ADDRESS)ecartWeights,((currRing->N)+1)*sizeof(short));
1295 // ecartWeights=NULL;
1296 // }
1297 // }
1298  if (TEST_OPT_PROT) messageStat(hilbcount,strat);
1299  if (Q!=NULL) updateResult(strat->Shdl,Q,strat);
1300 
1301 
1302 #ifdef PDEBUG
1303 /* for counting number of pairs [enterL] in Plural */
1304 /* extern int zaehler; */
1305 /* Print("Total pairs considered:%d\n",zaehler); zaehler=0; */
1306 #endif /*PDEBUG*/
1307 
1308 #if MYTEST
1309  PrintS("</gnc_gr_bba>\n");
1310 #endif
1311 
1312  if( currRing != save ) rChangeCurrRing(save);
1313 
1314  return (strat->Shdl);
1315 }
int(* posInL)(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.h:280
void nc_gr_initBba(ideal F, kStrategy strat)
nc_gr_initBba is needed for sca_gr_bba and gr_bba.
Definition: gr_kstd2.cc:975
BOOLEAN honey
Definition: kutil.h:376
void PrintLn()
Definition: reporter.cc:310
#define TEST_OPT_DEGBOUND
Definition: options.h:108
void initBuchMoraPos(kStrategy strat)
Definition: kutil.cc:9814
void message(int i, int *reduc, int *olddeg, kStrategy strat, int red_result)
Definition: kutil.cc:7810
void messageStat(int hilbcount, kStrategy strat)
Definition: kutil.cc:7851
#define TEST_OPT_PROT
Definition: options.h:98
loop
Definition: myNF.cc:98
int Ll
Definition: kutil.h:349
void initBuchMora(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:9987
static BOOLEAN rIsRatGRing(const ring r)
Definition: ring.h:415
void enterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
Definition: kutil.cc:4936
#define TRUE
Definition: auxiliary.h:101
#define TEST_OPT_REDSB
Definition: options.h:99
void pWrite(poly p)
Definition: polys.h:291
int k
Definition: cfEzgcd.cc:93
#define TEST_OPT_DEBUG
Definition: options.h:103
#define Q
Definition: sirandom.c:25
KINLINE poly redtailBba(poly p, int pos, kStrategy strat, BOOLEAN normalize)
Definition: kInline.h:1116
int(* posInT)(const TSet T, const int tl, LObject &h)
Definition: kutil.h:277
void deleteInL(LSet set, int *length, int j, kStrategy strat)
Definition: kutil.cc:1148
BOOLEAN interpt
Definition: kutil.h:370
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:10
#define idPrint(id)
Definition: ideals.h:48
#define TEST_OPT_INTSTRATEGY
Definition: options.h:105
int j
Definition: myNF.cc:70
#define assume(x)
Definition: mod2.h:403
#define messageSets(s)
Definition: kutil.h:538
int posInL0(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:6143
LObject P
Definition: kutil.h:298
poly nc_rat_CreateSpoly(poly pp1, poly pp2, int ishift, const ring r)
Definition: ratgring.cc:341
void initBuchMoraCrit(kStrategy strat)
Definition: kutil.cc:9663
void rDebugPrint(const ring r)
Definition: ring.cc:4033
void PrintS(const char *s)
Definition: reporter.cc:284
poly tail
Definition: kutil.h:332
#define pOne()
Definition: polys.h:298
void rWrite(ring r, BOOLEAN details)
Definition: ring.cc:236
#define p_Test(p, r)
Definition: p_polys.h:160
void rChangeCurrRing(ring r)
Definition: polys.cc:12
int int kStrategy strat
Definition: myNF.cc:68
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:843
BOOLEAN p_LmIsConstantRat(const poly p, const ring r)
Definition: ratgring.cc:643
LSet L
Definition: kutil.h:323
#define NULL
Definition: omList.c:10
int posInT110(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5557
void pNorm(poly p, const ring R=currRing)
Definition: polys.h:346
#define TEST_OPT_SB_1
Definition: options.h:113
int posInS(const kStrategy strat, const int length, const poly p, const int ecart_p)
Definition: kutil.cc:5112
void completeReduce(kStrategy strat, BOOLEAN withT)
Definition: kutil.cc:10508
#define pNext(p)
Definition: monomials.h:43
void updateResult(ideal r, ideal Q, kStrategy strat)
Definition: kutil.cc:10296
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
KINLINE void clearS(poly p, unsigned long p_sev, int *at, int *k, kStrategy strat)
Definition: kInline.h:1141
static poly nc_CreateSpoly(const poly p1, const poly p2, const ring r)
Definition: nc.h:258
void p_wrp(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:237
void wrp(poly p)
Definition: polys.h:293
int Kstd1_deg
Definition: kutil.cc:236
poly p_Cleardenom(poly p, const ring r)
Definition: p_polys.cc:2716
void exitBuchMora(kStrategy strat)
Definition: kutil.cc:10063

§ k_gnc_gr_mora()

ideal k_gnc_gr_mora ( const ideal  ,
const ideal  ,
const intvec ,
const intvec ,
kStrategy  ,
const ring  _currRing 
)

Definition at line 1317 of file gr_kstd2.cc.

1318 {
1319 #ifndef SING_NDEBUG
1320  // Not yet!
1321  WarnS("Sorry, non-commutative mora is not yet implemented!");
1322 #endif
1323 
1324  return gnc_gr_bba(F, Q, NULL, NULL, strat, _currRing);
1325 }
#define Q
Definition: sirandom.c:25
#define WarnS
Definition: emacs.cc:81
BBA_Proc gnc_gr_bba
Definition: old.gring.cc:73
int int kStrategy strat
Definition: myNF.cc:68
#define NULL
Definition: omList.c:10

§ k_sca_bba()

ideal k_sca_bba ( const ideal  ,
const ideal  ,
const intvec ,
const intvec ,
kStrategy  ,
const ring  _currRing 
)

Modified modern Sinuglar Buchberger's algorithm.

Definition at line 374 of file sca.cc.

375 {
376  const ring save = currRing;
377  if( currRing != _currRing ) rChangeCurrRing(_currRing);
378  assume( currRing == _currRing );
379 
380 #if MYTEST
381  PrintS("\n\n<sca_bba>\n\n");
382 #endif
383 
385 
386 #ifndef SING_NDEBUG
387  idTest(F);
388  idTest(Q);
389 #endif
390 
391 #if MYTEST
392  PrintS("\ncurrRing: \n");
393  rWrite(currRing);
394 #ifdef RDEBUG
395 // rDebugPrint(currRing);
396 #endif
397 
398  PrintS("\n\nF: \n");
399  idPrint(F);
400  PrintS("\n\nQ: \n");
401  idPrint(Q);
402 
403  PrintLn();
404 #endif
405 
406 
407  const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
408  const unsigned int m_iLastAltVar = scaLastAltVar(currRing);
409 
410  ideal tempF = id_KillSquares(F, m_iFirstAltVar, m_iLastAltVar, currRing);
411 
412  ideal tempQ = Q;
413 
414  if(Q == currRing->qideal)
415  tempQ = SCAQuotient(currRing);
416 
417  // Q or tempQ will not be used below :(((
418 
419 
420 #if MYTEST
421 
422  PrintS("tempF: \n");
423  idPrint(tempF);
424  PrintS("tempQ: \n");
425  idPrint(tempQ);
426 #endif
427 
428  strat->z2homog = id_IsSCAHomogeneous(tempF, NULL, NULL, currRing); // wCx == wCy == NULL!
429  // redo no_prod_crit:
430  const BOOLEAN bIsSCA = rIsSCA(currRing) && strat->z2homog; // for Z_2 prod-crit
431  strat->no_prod_crit = ! bIsSCA;
432 
433 // strat->homog = strat->homog && strat->z2homog; // ?
434 
435  int red_result = 1;
436  int olddeg, reduc;
437 
438 // int hilbeledeg = 1, minimcnt = 0;
439  int hilbcount = 0;
440 
441  BOOLEAN withT = FALSE;
442 
443  initBuchMoraCrit(strat); // sets Gebauer, honey, sugarCrit // sca - ok???
444  initBuchMoraPos(strat); // sets strat->posInL, strat->posInT // check!! (Plural's: )
445 
446 // initHilbCrit(F, Q, &hilb, strat);
447 
448 // nc_gr_initBba(F,strat);
449  initBba(strat); // set enterS, red, initEcart, initEcartPair
450 
451  // set enterS, spSpolyShort, reduce, red, initEcart, initEcartPair
452  // ?? set spSpolyShort, reduce ???
453  initBuchMora(tempF, tempQ, strat); // tempQ = Q without squares!!!
454 
455 // if (strat->minim>0) strat->M = idInit(IDELEMS(F),F->rank);
456 
457  reduc = olddeg = 0;
458 
459 #define NO_BUCKETS
460 
461 #ifndef NO_BUCKETS
463  strat->use_buckets = 1;
464 #endif
465 
466  // redtailBBa against T for inhomogenous input
467  if (!TEST_OPT_OLDSTD)
468  withT = ! strat->homog;
469 
470  // strat->posInT = posInT_pLength;
471  kTest_TS(strat);
472 
473 #undef HAVE_TAIL_RING
474 
475 #ifdef HAVE_TAIL_RING
476  if(!idIs0(F) &&(!rField_is_Ring())) // create strong gcd poly computes with tailring and S[i] ->to be fixed
478 #endif
479  if (BVERBOSE(23))
480  {
484  }
485 
486 
487  ///////////////////////////////////////////////////////////////
488  // SCA:
489 
490  // due to std( SB, p).
491  // Note that after initBuchMora :: initSSpecial all these additional
492  // elements are in S and T (and some pairs are in L, which also has no initiall
493  // elements!!!)
494  if(TEST_OPT_SB_1)
495  {
496  // For all additional elements...
497  for (int iNewElement = strat->newIdeal; iNewElement < IDELEMS(tempF); iNewElement++)
498  {
499  const poly pSave = tempF->m[iNewElement];
500 
501  if( pSave != NULL )
502  {
503 // tempF->m[iNewElement] = NULL;
504 
505  const poly p_next = pNext(pSave);
506 
507  if(p_next != NULL)
508  for( unsigned int i = m_iFirstAltVar; i <= m_iLastAltVar; i++ )
509  if( p_GetExp(pSave, i, currRing) != 0 )
510  {
511  assume(p_GetExp(pSave, i, currRing) == 1);
512 
513  const poly p_new = sca_pp_Mult_xi_pp(i, p_next, currRing);
514 
515 #ifdef PDEBUG
516  p_Test(p_new, currRing);
517 #endif
518 
519  if( p_new == NULL) continue;
520 
521  LObject h(p_new); // h = x_i * strat->P
522  h.is_special = TRUE;
523 
525  h.pCleardenom(); // also does a p_Content
526  else
527  h.pNorm();
528 
529  strat->initEcart(&h);
530  h.sev = pGetShortExpVector(h.p);
531 
532  int pos = 0;
533 
534  if (strat->Ll != -1)
535  pos = strat->posInL(strat->L,strat->Ll,&h,strat);
536 
537  enterL(&strat->L,&strat->Ll,&strat->Lmax,h,pos);
538  }
539  }
540  }
541  }
542 
543  // compute-------------------------------------------------------
544  while (strat->Ll >= 0)
545  {
546 #ifdef KDEBUG
548 #endif
549 
550  if (strat->Ll== 0) strat->interpt=TRUE;
551 
553  && ((strat->honey && (strat->L[strat->Ll].ecart+currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg))
554  || ((!strat->honey) && (currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg))))
555  {
556 
557 #ifdef KDEBUG
558 // if (TEST_OPT_DEBUG){PrintS("^^^^?");}
559 #endif
560 
561  // *stops computation if
562  // * 24 IN test and the degree +ecart of L[strat->Ll] is bigger then
563  // *a predefined number Kstd1_deg
564  while ((strat->Ll >= 0)
565  && ( (strat->homog==isHomog) || strat->L[strat->Ll].is_special || ((strat->L[strat->Ll].p1!=NULL) && (strat->L[strat->Ll].p2!=NULL)) )
566  && ((strat->honey && (strat->L[strat->Ll].ecart+currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg))
567  || ((!strat->honey) && (currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg)))
568  )
569  {
570 #ifdef KDEBUG
571 // if (TEST_OPT_DEBUG){PrintS("^^^^^^^^^^^^!!!!");}
572 #endif
574 // if (TEST_OPT_PROT) PrintS("^!");
575  }
576  if (strat->Ll<0) break;
577  else strat->noClearS=TRUE;
578  }
579 
580  // picks the last element from the lazyset L
581  strat->P = strat->L[strat->Ll];
582  strat->Ll--;
583 
584 
585 // assume(pNext(strat->P.p) != strat->tail);
586 
587  if(strat->P.IsNull()) continue;
588 
589  if (pNext(strat->P.p) == strat->tail)
590  {
591  // deletes the short spoly
592  pLmFree(strat->P.p);
593 
594  strat->P.p = nc_CreateSpoly(strat->P.p1, strat->P.p2, currRing);
595  if (strat->P.p!=NULL) strat->initEcart(&strat->P);
596  }// else
597 
598 
599  if(strat->P.IsNull()) continue;
600 
601  if (strat->P.p1 == NULL)
602  {
603 // if (strat->minim > 0)
604 // strat->P.p2=p_Copy(strat->P.p, currRing, strat->tailRing);
605 
606 
607  // for input polys, prepare reduction
608  strat->P.PrepareRed(strat->use_buckets);
609  }
610 
611  if (TEST_OPT_PROT)
612  message((strat->honey ? strat->P.ecart : 0) + strat->P.pFDeg(),
613  &olddeg,&reduc,strat, red_result);
614 
615  // reduction of the element chosen from L
616  red_result = strat->red(&strat->P,strat);
617 
618 
619  // reduction to non-zero new poly
620  if (red_result == 1)
621  {
622  // statistic
623  if (TEST_OPT_PROT) PrintS("s");
624 
625  // get the polynomial (canonicalize bucket, make sure P.p is set)
626  strat->P.GetP(strat->lmBin);
627 
628  int pos = posInS(strat,strat->sl,strat->P.p,strat->P.ecart);
629 
630  // reduce the tail and normalize poly
632  {
633  strat->P.pCleardenom();
635  {
636  strat->P.p = redtailBba(&(strat->P),pos-1,strat, withT); // !!!
637  strat->P.pCleardenom();
638  }
639  }
640  else
641  {
642  strat->P.pNorm();
644  strat->P.p = redtailBba(&(strat->P),pos-1,strat, withT);
645  }
646  strat->P.is_normalized=nIsOne(pGetCoeff(strat->P.p));
647 
648 #ifdef KDEBUG
649  if (TEST_OPT_DEBUG){PrintS(" ns:");p_wrp(strat->P.p,currRing);PrintLn();}
650 #endif
651 
652 // // min_std stuff
653 // if ((strat->P.p1==NULL) && (strat->minim>0))
654 // {
655 // if (strat->minim==1)
656 // {
657 // strat->M->m[minimcnt]=p_Copy(strat->P.p,currRing,strat->tailRing);
658 // p_Delete(&strat->P.p2, currRing, strat->tailRing);
659 // }
660 // else
661 // {
662 // strat->M->m[minimcnt]=strat->P.p2;
663 // strat->P.p2=NULL;
664 // }
665 // if (strat->tailRing!=currRing && pNext(strat->M->m[minimcnt])!=NULL)
666 // pNext(strat->M->m[minimcnt])
667 // = strat->p_shallow_copy_delete(pNext(strat->M->m[minimcnt]),
668 // strat->tailRing, currRing,
669 // currRing->PolyBin);
670 // minimcnt++;
671 // }
672 
673  // enter into S, L, and T
674  //if(withT)
675  {
676  strat->P.SetpFDeg();
677  enterT(strat->P, strat);
678  }
679 
680  // L
681  enterpairs(strat->P.p,strat->sl,strat->P.ecart,pos,strat, strat->tl);
682 
683  // posInS only depends on the leading term
684  strat->enterS(strat->P, pos, strat, strat->tl);
685 
686 // if (hilb!=NULL) khCheck(Q,w,hilb,hilbeledeg,hilbcount,strat);
687 
688 // Print("[%d]",hilbeledeg);
689  if (strat->P.lcm!=NULL) pLmFree(strat->P.lcm);
690 
691  // //////////////////////////////////////////////////////////
692  // SCA:
693  const poly pSave = strat->P.p;
694  const poly p_next = pNext(pSave);
695 
696 // if(0)
697  if( p_next != NULL )
698  for( unsigned int i = m_iFirstAltVar; i <= m_iLastAltVar; i++ )
699  if( p_GetExp(pSave, i, currRing) != 0 )
700  {
701  assume(p_GetExp(pSave, i, currRing) == 1);
702  const poly p_new = sca_pp_Mult_xi_pp(i, p_next, currRing);
703 
704 #ifdef PDEBUG
705  p_Test(p_new, currRing);
706 #endif
707 
708  if( p_new == NULL) continue;
709 
710  LObject h(p_new); // h = x_i * strat->P
711 
712  h.is_special = TRUE;
713 
715  {
716 // p_Content(h.p);
717  h.pCleardenom(); // also does a p_Content
718  }
719  else
720  {
721  h.pNorm();
722  }
723 
724  strat->initEcart(&h);
725  h.sev = pGetShortExpVector(h.p);
726 
727  int pos = 0;
728 
729  if (strat->Ll != -1)
730  pos = strat->posInL(strat->L,strat->Ll,&h,strat);
731 
732  enterL(&strat->L,&strat->Ll,&strat->Lmax,h,pos);
733 
734 
735 
736 
737 #if 0
738  h.sev = pGetShortExpVector(h.p);
739  strat->initEcart(&h);
740 
741  h.PrepareRed(strat->use_buckets);
742 
743  // reduction of the element chosen from L(?)
744  red_result = strat->red(&h,strat);
745 
746  // reduction to non-zero new poly
747  if (red_result != 1) continue;
748 
749 
750  int pos = posInS(strat,strat->sl,h.p,h.ecart);
751 
752  // reduce the tail and normalize poly
754  {
755  h.pCleardenom();
757  {
758  h.p = redtailBba(&(h),pos-1,strat, withT); // !!!
759  h.pCleardenom();
760  }
761  }
762  else
763  {
764  h.pNorm();
766  h.p = redtailBba(&(h),pos-1,strat, withT);
767  }
768 
769 #ifdef KDEBUG
770  if (TEST_OPT_DEBUG){PrintS(" N:");h.wrp();PrintLn();}
771 #endif
772 
773 // h.PrepareRed(strat->use_buckets); // ???
774 
775  h.sev = pGetShortExpVector(h.p);
776  strat->initEcart(&h);
777 
778  if (strat->Ll==-1)
779  pos = 0;
780  else
781  pos = strat->posInL(strat->L,strat->Ll,&h,strat);
782 
783  enterL(&strat->L,&strat->Ll,&strat->Lmax,h,pos);
784 // the end of "#if 0" (comment)
785 #endif
786 
787  } // for all x_i \in Ann(lm(P))
788  } // if red(P) != NULL
789 
790 // else if (strat->P.p1 == NULL && strat->minim > 0)
791 // {
792 // p_Delete(&strat->P.p2, currRing, strat->tailRing);
793 // }
794 
795 #ifdef KDEBUG
796 // memset(&(strat->P), 0, sizeof(strat->P));
797 #endif
798 
799  kTest_TS(strat); // even of T is not used!
800 
801 // Print("\n$\n");
802 
803  }
804 
805 #ifdef KDEBUG
806  if (TEST_OPT_DEBUG) messageSets(strat);
807 #endif
808 
809  // complete reduction of the standard basis---------
810 
811  if (TEST_OPT_REDSB)
812  {
813  completeReduce(strat);
814  }
815 
816  //release temp data--------------------------------
817 
818  exitBuchMora(strat); // cleanT!
819 
820  id_Delete(&tempF, currRing);
821 
822 // if (TEST_OPT_WEIGHTM)
823 // {
824 // pRestoreDegProcs(currRing, pFDegOld, pLDegOld);
825 // if (ecartWeights)
826 // {
827 // omFreeSize((ADDRESS)ecartWeights,(rVar(currRing)+1)*sizeof(short));
828 // ecartWeights=NULL;
829 // }
830 // }
831 
832  if (TEST_OPT_PROT) messageStat(hilbcount,strat);
833 
834 
835 
836  if (tempQ!=NULL) updateResult(strat->Shdl,tempQ,strat);
837 
838 
839  if (TEST_OPT_REDSB) // ???
840  {
841  // must be at the very end (after exitBuchMora) as it changes the S set!!!
842  ideal I = strat->Shdl;
843  ideal erg = kInterRedOld(I,tempQ);
844  assume(I!=erg);
845  id_Delete(&I, currRing);
846  strat->Shdl = erg;
847  }
848 
849 #if MYTEST
850  PrintS("\n\n</sca_bba>\n\n");
851 #endif
852 
853  if( currRing != save ) rChangeCurrRing(save);
854 
855  return (strat->Shdl);
856 }
#define TEST_OPT_REDTAIL
Definition: options.h:111
int(* posInL)(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.h:280
ideal SCAQuotient(const ring r)
Definition: sca.h:10
BOOLEAN honey
Definition: kutil.h:376
void PrintLn()
Definition: reporter.cc:310
#define TEST_OPT_DEGBOUND
Definition: options.h:108
void initBuchMoraPos(kStrategy strat)
Definition: kutil.cc:9814
void message(int i, int *reduc, int *olddeg, kStrategy strat, int red_result)
Definition: kutil.cc:7810
class sLObject LObject
Definition: kutil.h:60
void messageStat(int hilbcount, kStrategy strat)
Definition: kutil.cc:7851
#define TEST_OPT_PROT
Definition: options.h:98
int Ll
Definition: kutil.h:349
#define FALSE
Definition: auxiliary.h:97
void initBuchMora(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:9987
static bool id_IsSCAHomogeneous(const ideal id, const intvec *wCx, const intvec *wCy, const ring r)
Definition: sca.h:115
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
BOOLEAN z2homog
Definition: kutil.h:373
void enterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
Definition: kutil.cc:4936
char noClearS
Definition: kutil.h:401
#define TRUE
Definition: auxiliary.h:101
#define nIsOne(n)
Definition: numbers.h:25
#define TEST_OPT_REDSB
Definition: options.h:99
void initBba(kStrategy strat)
Definition: kstd1.cc:1426
#define TEST_OPT_DEBUG
Definition: options.h:103
void enterL(LSet *set, int *length, int *LSetmax, LObject p, int at)
Definition: kutil.cc:1210
#define Q
Definition: sirandom.c:25
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
KINLINE poly redtailBba(poly p, int pos, kStrategy strat, BOOLEAN normalize)
Definition: kInline.h:1116
int(* posInT)(const TSet T, const int tl, LObject &h)
Definition: kutil.h:277
void kStratInitChangeTailRing(kStrategy strat)
Definition: kutil.cc:11245
#define TEST_OPT_NOT_BUCKETS
Definition: options.h:100
void enterT(LObject &p, kStrategy strat, int atT)
Definition: kutil.cc:9364
void deleteInL(LSet set, int *length, int j, kStrategy strat)
Definition: kutil.cc:1148
BOOLEAN interpt
Definition: kutil.h:370
void(* initEcart)(TObject *L)
Definition: kutil.h:276
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:10
#define idPrint(id)
Definition: ideals.h:48
BOOLEAN homog
Definition: kutil.h:371
#define TEST_OPT_INTSTRATEGY
Definition: options.h:105
#define kTest_TS(A)
Definition: kutil.h:654
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:464
#define TEST_OPT_OLDSTD
Definition: options.h:117
#define assume(x)
Definition: mod2.h:403
#define messageSets(s)
Definition: kutil.h:538
#define pGetShortExpVector(a)
returns the "Short Exponent Vector" – used to speed up divisibility tests (see polys-impl.cc )
Definition: polys.h:152
poly sca_pp_Mult_xi_pp(short i, const poly pPoly, const ring rRing)
Definition: sca.cc:1217
LObject P
Definition: kutil.h:298
void initBuchMoraCrit(kStrategy strat)
Definition: kutil.cc:9663
int i
Definition: cfEzgcd.cc:123
ideal kInterRedOld(ideal F, ideal Q)
Definition: kstd1.cc:3084
void PrintS(const char *s)
Definition: reporter.cc:284
poly tail
Definition: kutil.h:332
void rWrite(ring r, BOOLEAN details)
Definition: ring.cc:236
#define IDELEMS(i)
Definition: simpleideals.h:24
static short scaFirstAltVar(ring r)
Definition: sca.h:18
#define p_Test(p, r)
Definition: p_polys.h:160
void rChangeCurrRing(ring r)
Definition: polys.cc:12
#define BVERBOSE(a)
Definition: options.h:33
int int kStrategy strat
Definition: myNF.cc:68
LSet L
Definition: kutil.h:323
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:477
#define NULL
Definition: omList.c:10
ideal id_KillSquares(const ideal id, const short iFirstAltVar, const short iLastAltVar, const ring r, const bool bSkipZeroes)
Definition: sca.cc:1534
int Lmax
Definition: kutil.h:349
#define TEST_OPT_SB_1
Definition: options.h:113
int posInS(const kStrategy strat, const int length, const poly p, const int ecart_p)
Definition: kutil.cc:5112
static short scaLastAltVar(ring r)
Definition: sca.h:25
BOOLEAN no_prod_crit
Definition: kutil.h:393
static bool rIsSCA(const ring r)
Definition: nc.h:206
void completeReduce(kStrategy strat, BOOLEAN withT)
Definition: kutil.cc:10508
#define pNext(p)
Definition: monomials.h:43
void updateResult(ideal r, ideal Q, kStrategy strat)
Definition: kutil.cc:10296
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(* test_PosInT)(const TSet T, const int tl, LObject &h)
Definition: kstd2.cc:82
static poly nc_CreateSpoly(const poly p1, const poly p2, const ring r)
Definition: nc.h:258
BOOLEAN use_buckets
Definition: kutil.h:382
void p_wrp(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:237
int(* test_PosInL)(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kstd2.cc:83
polyrec * poly
Definition: hilb.h:10
int Kstd1_deg
Definition: kutil.cc:236
int newIdeal
Definition: kutil.h:355
static Poly * h
Definition: janet.cc:978
int BOOLEAN
Definition: auxiliary.h:88
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
void exitBuchMora(kStrategy strat)
Definition: kutil.cc:10063
void kDebugPrint(kStrategy strat)
Definition: kutil.cc:11692
#define idTest(id)
Definition: ideals.h:49

§ k_sca_gr_bba()

ideal k_sca_gr_bba ( const ideal  ,
const ideal  ,
const intvec ,
const intvec ,
kStrategy  ,
const ring  _currRing 
)

Modified Plural's Buchberger's algorithmus.

Definition at line 100 of file sca.cc.

101 {
102  const ring save = currRing;
103  if( currRing != _currRing ) rChangeCurrRing(_currRing);
104  assume( currRing == _currRing );
105 
106 
107 #if MYTEST
108  PrintS("<sca_gr_bba>\n");
109 #endif
110 
112 
113 #ifndef SING_NDEBUG
114  idTest(F);
115  idTest(Q);
116 #endif
117 
118 #ifdef HAVE_PLURAL
119 #if MYTEST
120  PrintS("currRing: \n");
121  rWrite(currRing);
122 #ifdef RDEBUG
124 #endif
125 
126  PrintS("F: \n");
127  idPrint(F);
128  PrintS("Q: \n");
129  idPrint(Q);
130 #endif
131 #endif
132 
133 
134  const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
135  const unsigned int m_iLastAltVar = scaLastAltVar(currRing);
136 
137  ideal tempF = id_KillSquares(F, m_iFirstAltVar, m_iLastAltVar, currRing);
138  ideal tempQ = Q;
139 
140  if(Q == currRing->qideal)
141  tempQ = SCAQuotient(currRing);
142 
143  strat->z2homog = id_IsSCAHomogeneous(tempF, NULL, NULL, currRing); // wCx == wCy == NULL!
144  // redo: no_prod_crit
145  const BOOLEAN bIsSCA = rIsSCA(currRing) && strat->z2homog; // for Z_2 prod-crit
146  strat->no_prod_crit = ! bIsSCA;
147 
148 // strat->homog = strat->homog && strat->z2homog; // ?
149 
150 #if MYTEST
151  {
152  PrintS("ideal tempF: \n");
153  idPrint(tempF);
154  PrintS("ideal tempQ: \n");
155  idPrint(tempQ);
156  }
157 #endif
158 
159  int olddeg, reduc;
160  int red_result = 1;
161 // int hilbeledeg = 1, minimcnt = 0;
162  int hilbcount = 0;
163 
164  initBuchMoraCrit(strat); // set Gebauer, honey, sugarCrit
165 
166  nc_gr_initBba(tempF,strat); // set enterS, red, initEcart, initEcartPair
167 
169 
170 
171  // ?? set spSpolyShort, reduce ???
172 
173  initBuchMora(tempF, tempQ, strat); // SCAQuotient(currRing) instead of Q == squares!!!!!!!
174 
175  strat->posInT=posInT110; // !!!
176 
177  reduc = olddeg = 0;
178 
179 
180  // compute-------------------------------------------------------
181  for(; strat->Ll >= 0;
182 #ifdef KDEBUG
183  strat->P.lcm = NULL,
184 #endif
185  kTest(strat)
186  )
187  {
188 #ifdef KDEBUG
190 #endif
191 
192  if (strat->Ll== 0) strat->interpt=TRUE;
193 
195  && ((strat->honey
196  && (strat->L[strat->Ll].ecart+ currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg))
197  || ((!strat->honey) && (currRing->pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg))))
198  {
199  // stops computation if
200  // 24 IN test and the degree +ecart of L[strat->Ll] is bigger then
201  // a predefined number Kstd1_deg
202  while (strat->Ll >= 0) deleteInL(strat->L,&strat->Ll,strat->Ll,strat);
203  break;
204  }
205 
206  // picks the last element from the lazyset L
207  strat->P = strat->L[strat->Ll];
208  strat->Ll--;
209 
210  //kTest(strat);
211 
212 // assume(pNext(strat->P.p) != strat->tail); // !???
213  if(strat->P.IsNull()) continue;
214 
215 
216  if( pNext(strat->P.p) == strat->tail )
217  {
218  // deletes the int spoly and computes SPoly
219  pLmFree(strat->P.p); // ???
220  strat->P.p = nc_CreateSpoly(strat->P.p1, strat->P.p2, currRing);
221  }
222 
223  if(strat->P.IsNull()) continue;
224 
225 // poly save = NULL;
226 //
227 // if(pNext(strat->P.p) != NULL)
228 // save = p_Copy(strat->P.p, currRing);
229 
230  strat->initEcart(&strat->P); // remove it?
231 
232  if (TEST_OPT_PROT)
233  message((strat->honey ? strat->P.ecart : 0) + strat->P.pFDeg(), &olddeg,&reduc,strat, red_result);
234 
235  // reduction of the element chosen from L wrt S
236  strat->red(&strat->P,strat);
237 
238  if(strat->P.IsNull()) continue;
239 
240  addLObject(strat->P, strat);
241 
242  const poly save = strat->P.p;
243 
244 #ifdef PDEBUG
245  p_Test(save, currRing);
246 #endif
247  assume( save != NULL );
248 
249  // SCA Specials:
250 
251  {
252  const poly p_next = pNext(save);
253 
254  if( p_next != NULL )
255  for( unsigned int i = m_iFirstAltVar; i <= m_iLastAltVar; i++ )
256  if( p_GetExp(save, i, currRing) != 0 )
257  {
258  assume(p_GetExp(save, i, currRing) == 1);
259 
260  const poly tt = sca_pp_Mult_xi_pp(i, p_next, currRing);
261 
262 #ifdef PDEBUG
263  p_Test(tt, currRing);
264 #endif
265 
266  if( tt == NULL) continue;
267 
268  LObject h(tt); // h = x_i * P
269 
271  {
272 // h.pCleardenom(); // also does a p_Content
273  p_Content(h.p,currRing);
274  }
275  else
276  {
277  h.pNorm();
278  }
279 
280  strat->initEcart(&h);
281 
282 
283 // if (pOrdSgn==-1)
284 // {
285 // cancelunit(&h); // tries to cancel a unit
286 // deleteHC(&h, strat);
287 // }
288 
289 // if(h.IsNull()) continue;
290 
291 // if (TEST_OPT_PROT)
292 // message((strat->honey ? h.ecart : 0) + h.pFDeg(), &olddeg, &reduc, strat, red_result);
293 
294 // strat->red(&h, strat); // wrt S
295 // if(h.IsNull()) continue;
296 
297 // poly save = p_Copy(h.p, currRing);
298 
299  int pos;
300 
301  if (strat->Ll==-1)
302  pos =0;
303  else
304  pos = strat->posInL(strat->L,strat->Ll,&h,strat);
305 
306  h.sev = pGetShortExpVector(h.p);
307  enterL(&strat->L,&strat->Ll,&strat->Lmax,h,pos);
308 
309  // h.p = save;
310  // addLObject(h, strat);
311  }
312 
313  // p_Delete( &save, currRing );
314  }
315 
316 
317  } // for(;;)
318 
319 
320 #ifdef KDEBUG
321  if (TEST_OPT_DEBUG) messageSets(strat);
322 #endif
323 
324  if (TEST_OPT_REDSB){
325  completeReduce(strat); // ???
326  }
327 
328  // release temp data--------------------------------
329  exitBuchMora(strat);
330 
331 // if (TEST_OPT_WEIGHTM)
332 // {
333 // pRestoreDegProcs(currRing,pFDegOld, pLDegOld);
334 // if (ecartWeights)
335 // {
336 // omFreeSize((ADDRESS)ecartWeights,(rVar(currRing)+1)*sizeof(int));
337 // ecartWeights=NULL;
338 // }
339 // }
340 
341  if (TEST_OPT_PROT) messageStat(hilbcount,strat);
342 
343  if (tempQ!=NULL) updateResult(strat->Shdl,tempQ,strat);
344 
345  id_Delete(&tempF, currRing);
346 
347 
348  // complete reduction of the standard basis---------
349  if (TEST_OPT_REDSB){
350  ideal I = strat->Shdl;
351  ideal erg = kInterRedOld(I,tempQ);
352  assume(I!=erg);
353  id_Delete(&I, currRing);
354  strat->Shdl = erg;
355  }
356 
357 
358 #if MYTEST
359 // PrintS("</sca_gr_bba>\n");
360 #endif
361 
362  if( currRing != save ) rChangeCurrRing(save);
363 
364  return (strat->Shdl);
365 }
ideal SCAQuotient(const ring r)
Definition: sca.h:10
BOOLEAN honey
Definition: kutil.h:376
#define TEST_OPT_DEGBOUND
Definition: options.h:108
void initBuchMoraPos(kStrategy strat)
Definition: kutil.cc:9814
void message(int i, int *reduc, int *olddeg, kStrategy strat, int red_result)
Definition: kutil.cc:7810
class sLObject LObject
Definition: kutil.h:60
void messageStat(int hilbcount, kStrategy strat)
Definition: kutil.cc:7851
#define TEST_OPT_PROT
Definition: options.h:98
int Ll
Definition: kutil.h:349
void initBuchMora(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:9987
void addLObject(LObject &h, kStrategy &strat)
Definition: sca.cc:26
static bool id_IsSCAHomogeneous(const ideal id, const intvec *wCx, const intvec *wCy, const ring r)
Definition: sca.h:115
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
BOOLEAN z2homog
Definition: kutil.h:373
#define TRUE
Definition: auxiliary.h:101
#define TEST_OPT_REDSB
Definition: options.h:99
#define kTest(A)
Definition: kutil.h:653
#define TEST_OPT_DEBUG
Definition: options.h:103
void enterL(LSet *set, int *length, int *LSetmax, LObject p, int at)
Definition: kutil.cc:1210
#define Q
Definition: sirandom.c:25
int(* posInT)(const TSet T, const int tl, LObject &h)
Definition: kutil.h:277
void deleteInL(LSet set, int *length, int j, kStrategy strat)
Definition: kutil.cc:1148
BOOLEAN interpt
Definition: kutil.h:370
void(* initEcart)(TObject *L)
Definition: kutil.h:276
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:10
#define idPrint(id)
Definition: ideals.h:48
#define TEST_OPT_INTSTRATEGY
Definition: options.h:105
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:464
#define assume(x)
Definition: mod2.h:403
#define messageSets(s)
Definition: kutil.h:538
#define pGetShortExpVector(a)
returns the "Short Exponent Vector" – used to speed up divisibility tests (see polys-impl.cc )
Definition: polys.h:152
poly sca_pp_Mult_xi_pp(short i, const poly pPoly, const ring rRing)
Definition: sca.cc:1217
LObject P
Definition: kutil.h:298
void initBuchMoraCrit(kStrategy strat)
Definition: kutil.cc:9663
void rDebugPrint(const ring r)
Definition: ring.cc:4033
int i
Definition: cfEzgcd.cc:123
ideal kInterRedOld(ideal F, ideal Q)
Definition: kstd1.cc:3084
void PrintS(const char *s)
Definition: reporter.cc:284
poly tail
Definition: kutil.h:332
void rWrite(ring r, BOOLEAN details)
Definition: ring.cc:236
void p_Content(poly ph, const ring r)
Definition: p_polys.cc:2216
static short scaFirstAltVar(ring r)
Definition: sca.h:18
#define p_Test(p, r)
Definition: p_polys.h:160
void rChangeCurrRing(ring r)
Definition: polys.cc:12
int int kStrategy strat
Definition: myNF.cc:68
LSet L
Definition: kutil.h:323
#define NULL
Definition: omList.c:10
ideal id_KillSquares(const ideal id, const short iFirstAltVar, const short iLastAltVar, const ring r, const bool bSkipZeroes)
Definition: sca.cc:1534
int posInT110(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5557
static short scaLastAltVar(ring r)
Definition: sca.h:25
BOOLEAN no_prod_crit
Definition: kutil.h:393
void nc_gr_initBba(ideal F, kStrategy strat)
nc_gr_initBba is needed for sca_gr_bba and gr_bba.
Definition: gr_kstd2.cc:975
static bool rIsSCA(const ring r)
Definition: nc.h:206
void completeReduce(kStrategy strat, BOOLEAN withT)
Definition: kutil.cc:10508
#define pNext(p)
Definition: monomials.h:43
void updateResult(ideal r, ideal Q, kStrategy strat)
Definition: kutil.cc:10296
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
static poly nc_CreateSpoly(const poly p1, const poly p2, const ring r)
Definition: nc.h:258
polyrec * poly
Definition: hilb.h:10
int Kstd1_deg
Definition: kutil.cc:236
static Poly * h
Definition: janet.cc:978
int BOOLEAN
Definition: auxiliary.h:88
void exitBuchMora(kStrategy strat)
Definition: kutil.cc:10063
#define idTest(id)
Definition: ideals.h:49

§ k_sca_mora()

ideal k_sca_mora ( const ideal  ,
const ideal  ,
const intvec ,
const intvec ,
kStrategy  ,
const ring  _currRing 
)

Modified modern Sinuglar Mora's algorithm.

Definition at line 896 of file sca.cc.

897 {
898  const ring save = currRing;
899  if( currRing != _currRing ) rChangeCurrRing(_currRing);
900  assume( currRing == _currRing );
901 
903 
904  const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
905  const unsigned int m_iLastAltVar = scaLastAltVar(currRing);
906 
907  ideal tempF = id_KillSquares(F, m_iFirstAltVar, m_iLastAltVar, currRing);
908 
909  ideal tempQ = Q;
910 
911  if(Q == currRing->qideal)
912  tempQ = SCAQuotient(currRing);
913 
914  bool bIdHomog = id_IsSCAHomogeneous(tempF, NULL, NULL, currRing); // wCx == wCy == NULL!
915 
916  assume( !bIdHomog || strat->homog ); // bIdHomog =====[implies]>>>>> strat->homog
917 
918  strat->homog = strat->homog && bIdHomog;
919 
920 #ifdef PDEBUG
921  assume( strat->homog == bIdHomog );
922 #endif
923 
924 #ifdef HAVE_ASSUME
925  sca_mora_count++;
926 #endif
927 
928  strat->update = TRUE;
929  //- setting global variables ------------------- -
931 // initHilbCrit(F,NULL,&hilb,strat); // no Q!
932  initMora(tempF, strat);
934  //Shdl=
935  initBuchMora(tempF, tempQ, strat); // temp Q, F!
936 // if (TEST_OPT_FASTHC) missingAxis(&strat->lastAxis,strat);
937  // updateS in initBuchMora has Hecketest
938  // * and could have put strat->kHEdgdeFound FALSE
939 #if 0
940  if (ppNoether!=NULL)
941  {
943  }
944  if (strat->kHEdgeFound && strat->update)
945  {
947  updateLHC(strat);
948  reorderL(strat);
949  }
951  {
954  strat->posInL = posInL10;
955  updateL(strat);
956  reorderL(strat);
957  }
958 #endif
960 
961  kTest_TS(strat);
962 
963 
964  int olddeg = 0;
965  int reduc = 0;
966  int red_result = 1;
967 // int hilbeledeg=1;
968  int hilbcount=0;
969 
970 
971  //- compute-------------------------------------------
972 
973 #undef HAVE_TAIL_RING
974 
975 #ifdef HAVE_TAIL_RING
976 // if (strat->homog && strat->red == redFirst)
977 // kStratInitChangeTailRing(strat);
978 #endif
979 
980 
981 
982 
983 
984 // due to std( SB, p)
985  if(TEST_OPT_SB_1)
986  {
987  for (int iNewElement = strat->newIdeal; iNewElement < IDELEMS(tempF); iNewElement++)
988  {
989 
990  const poly pSave = tempF->m[iNewElement];
991 
992  if( pSave != NULL )
993  {
994 // tempF->m[iNewElement] = NULL;
995 
996  const poly p_next = pNext(pSave);
997 
998  if(p_next != NULL)
999  for( unsigned int i = m_iFirstAltVar; i <= m_iLastAltVar; i++ )
1000  if( p_GetExp(pSave, i, currRing) != 0 )
1001  {
1002 
1003  assume(p_GetExp(pSave, i, currRing) == 1);
1004 
1005  const poly p_new = sca_pp_Mult_xi_pp(i, p_next, currRing);
1006 
1007 #ifdef PDEBUG
1008  p_Test(p_new, currRing);
1009 #endif
1010 
1011  if( p_new == NULL) continue;
1012 
1013  LObject h(p_new); // h = x_i * strat->P
1014 
1016  h.pCleardenom(); // also does a p_Content
1017  else
1018  h.pNorm();
1019 
1020  strat->initEcart(&h);
1021  h.sev = pGetShortExpVector(h.p);
1022 
1023  int pos = 0;
1024 
1025  if (strat->Ll != -1)
1026  pos = strat->posInL(strat->L,strat->Ll,&h,strat);
1027 
1028  enterL(&strat->L,&strat->Ll,&strat->Lmax,h,pos);
1029  }
1030  }
1031 
1032  }
1033  }
1034 
1035  while (strat->Ll >= 0)
1036  {
1037  //test_int_std(strat->kIdeal);
1038 #ifdef KDEBUG
1040 #endif
1041  if (TEST_OPT_DEGBOUND
1042  && (strat->L[strat->Ll].ecart+strat->L[strat->Ll].GetpFDeg()> Kstd1_deg))
1043  {
1044  // * stops computation if
1045  // * - 24 (degBound)
1046  // * && upper degree is bigger than Kstd1_deg
1047  while ((strat->Ll >= 0)
1048  && (strat->L[strat->Ll].p1!=NULL) && (strat->L[strat->Ll].p2!=NULL)
1049  && (strat->L[strat->Ll].ecart+strat->L[strat->Ll].GetpFDeg()> Kstd1_deg)
1050  )
1051  {
1053  //if (TEST_OPT_PROT)
1054  //{
1055  // PrintS("D"); mflush();
1056  //}
1057  }
1058  if (strat->Ll<0) break;
1059  else strat->noClearS=TRUE;
1060  }
1061  strat->P = strat->L[strat->Ll];// - picks the last element from the lazyset L -
1062  if (strat->Ll==0) strat->interpt=TRUE;
1063  strat->Ll--;
1064 
1065  // create the real Spoly
1066 // assume(pNext(strat->P.p) != strat->tail);
1067 
1068  if(strat->P.IsNull()) continue;
1069 
1070 
1071  if( pNext(strat->P.p) == strat->tail )
1072  {
1073  // deletes the int spoly and computes SPoly
1074  pLmFree(strat->P.p); // ???
1075  strat->P.p = nc_CreateSpoly(strat->P.p1, strat->P.p2, currRing);
1076  }
1077 
1078 
1079 
1080  if (strat->P.p1 == NULL)
1081  {
1082  // for input polys, prepare reduction (buckets !)
1083  strat->P.SetLength(strat->length_pLength);
1084  strat->P.PrepareRed(strat->use_buckets);
1085  }
1086 
1087  if (!strat->P.IsNull())
1088  {
1089  // might be NULL from noether !!!
1090  if (TEST_OPT_PROT)
1091  message(strat->P.ecart+strat->P.GetpFDeg(),&olddeg,&reduc,strat, red_result);
1092  // reduce
1093  red_result = strat->red(&strat->P,strat);
1094  }
1095 
1096  if (! strat->P.IsNull())
1097  {
1098  strat->P.GetP();
1099  // statistics
1100  if (TEST_OPT_PROT) PrintS("s");
1101  // normalization
1102  if (!TEST_OPT_INTSTRATEGY)
1103  strat->P.pNorm();
1104  // tailreduction
1105  strat->P.p = redtail(&(strat->P),strat->sl,strat);
1106  // set ecart -- might have changed because of tail reductions
1107  if ((!strat->noTailReduction) && (!strat->honey))
1108  strat->initEcart(&strat->P);
1109  // cancel unit
1110  cancelunit(&strat->P);
1111  // for char 0, clear denominators
1113  strat->P.pCleardenom();
1114 
1115  // put in T
1116  enterT(strat->P,strat);
1117  // build new pairs
1118  enterpairs(strat->P.p,strat->sl,strat->P.ecart,0,strat, strat->tl);
1119  // put in S
1120  strat->enterS(strat->P,
1121  posInS(strat,strat->sl,strat->P.p, strat->P.ecart),
1122  strat, strat->tl);
1123 
1124 
1125  // clear strat->P
1126  if (strat->P.lcm!=NULL) pLmFree(strat->P.lcm);
1127  strat->P.lcm=NULL;
1128 
1129  // //////////////////////////////////////////////////////////
1130  // SCA:
1131  const poly pSave = strat->P.p;
1132  const poly p_next = pNext(pSave);
1133 
1134  if(p_next != NULL)
1135  for( unsigned int i = m_iFirstAltVar; i <= m_iLastAltVar; i++ )
1136  if( p_GetExp(pSave, i, currRing) != 0 )
1137  {
1138 
1139  assume(p_GetExp(pSave, i, currRing) == 1);
1140 
1141  const poly p_new = sca_pp_Mult_xi_pp(i, p_next, currRing);
1142 
1143 #ifdef PDEBUG
1144  p_Test(p_new, currRing);
1145 #endif
1146 
1147  if( p_new == NULL) continue;
1148 
1149  LObject h(p_new); // h = x_i * strat->P
1150 
1152  h.pCleardenom(); // also does a p_Content
1153  else
1154  h.pNorm();
1155 
1156  strat->initEcart(&h);
1157  h.sev = pGetShortExpVector(h.p);
1158 
1159  int pos = 0;
1160 
1161  if (strat->Ll != -1)
1162  pos = strat->posInL(strat->L,strat->Ll,&h,strat);
1163 
1164  enterL(&strat->L,&strat->Ll,&strat->Lmax,h,pos);
1165  }
1166 
1167 #ifdef KDEBUG
1168  // make sure kTest_TS does not complain about strat->P
1169  memset(&strat->P,0,sizeof(strat->P));
1170 #endif
1171  }
1172 #if 0
1173  if (strat->kHEdgeFound)
1174  {
1175  if ((TEST_OPT_FINDET)
1176  || ((TEST_OPT_MULTBOUND) && (scMult0Int((strat->Shdl)) < mu)))
1177  {
1178  // obachman: is this still used ???
1179  // * stops computation if strat->kHEdgeFound and
1180  // * - 27 (finiteDeterminacyTest)
1181  // * or
1182  // * - 23
1183  // * (multBound)
1184  // * && multiplicity of the ideal is smaller then a predefined number mu
1185  while (strat->Ll >= 0) deleteInL(strat->L,&strat->Ll,strat->Ll,strat);
1186  }
1187  }
1188 #endif
1189  kTest_TS(strat);
1190  }
1191  // - complete reduction of the standard basis------------------------ -
1192  if (TEST_OPT_REDSB) completeReduce(strat);
1193  // - release temp data------------------------------- -
1194  exitBuchMora(strat);
1195  // - polynomials used for HECKE: HC, noether -
1196  if (TEST_OPT_FINDET)
1197  {
1198  if (strat->kHEdge!=NULL)
1199  Kstd1_mu=currRing->pFDeg(strat->kHEdge,currRing);
1200  else
1201  Kstd1_mu=-1;
1202  }
1203  pDelete(&strat->kHEdge);
1204  strat->update = TRUE; //???
1205  strat->lastAxis = 0; //???
1206  pDelete(&strat->kNoether);
1207  omFreeSize((ADDRESS)strat->NotUsedAxis,(rVar(currRing)+1)*sizeof(BOOLEAN));
1208  if (TEST_OPT_PROT) messageStat(hilbcount,strat);
1209 // if (TEST_OPT_WEIGHTM)
1210 // {
1211 // pRestoreDegProcs(currRing, pFDegOld, pLDegOld);
1212 // if (ecartWeights)
1213 // {
1214 // omFreeSize((ADDRESS)ecartWeights,(rVar(currRing)+1)*sizeof(short));
1215 // ecartWeights=NULL;
1216 // }
1217 // }
1218  if (tempQ!=NULL) updateResult(strat->Shdl,tempQ,strat);
1219  idTest(strat->Shdl);
1220 
1221  id_Delete( &tempF, currRing);
1222 
1223  if( currRing != save ) rChangeCurrRing(save);
1224 
1225  return (strat->Shdl);
1226 }
int(* posInL)(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.h:280
ideal SCAQuotient(const ring r)
Definition: sca.h:10
poly redtail(LObject *L, int pos, kStrategy strat)
Definition: kutil.cc:7507
void mu(int **points, int sizePoints)
#define TEST_OPT_DEGBOUND
Definition: options.h:108
void initBuchMoraPos(kStrategy strat)
Definition: kutil.cc:9814
void message(int i, int *reduc, int *olddeg, kStrategy strat, int red_result)
Definition: kutil.cc:7810
void initMora(ideal F, kStrategy strat)
Definition: kstd1.cc:1549
class sLObject LObject
Definition: kutil.h:60
BOOLEAN length_pLength
Definition: kutil.h:386
void messageStat(int hilbcount, kStrategy strat)
Definition: kutil.cc:7851
#define TEST_OPT_PROT
Definition: options.h:98
int Ll
Definition: kutil.h:349
#define FALSE
Definition: auxiliary.h:97
void initBuchMora(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:9987
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
static bool id_IsSCAHomogeneous(const ideal id, const intvec *wCx, const intvec *wCy, const ring r)
Definition: sca.h:115
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:580
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
void enterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
Definition: kutil.cc:4936
#define TEST_OPT_MULTBOUND
Definition: options.h:109
char noClearS
Definition: kutil.h:401
#define TRUE
Definition: auxiliary.h:101
#define TEST_OPT_REDSB
Definition: options.h:99
void * ADDRESS
Definition: auxiliary.h:118
void cancelunit(LObject *L, BOOLEAN inNF)
Definition: kutil.cc:332
#define TEST_OPT_DEBUG
Definition: options.h:103
void enterL(LSet *set, int *length, int *LSetmax, LObject p, int at)
Definition: kutil.cc:1210
#define Q
Definition: sirandom.c:25
void updateL(kStrategy strat)
Definition: kstd1.cc:1131
int lastAxis
Definition: kutil.h:354
int Kstd1_mu
Definition: kutil.cc:237
#define TEST_OPT_FINDET
Definition: options.h:106
void enterT(LObject &p, kStrategy strat, int atT)
Definition: kutil.cc:9364
void deleteInL(LSet set, int *length, int j, kStrategy strat)
Definition: kutil.cc:1148
BOOLEAN interpt
Definition: kutil.h:370
void(* initEcart)(TObject *L)
Definition: kutil.h:276
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:10
static int sca_mora_count
Definition: sca.cc:892
BOOLEAN homog
Definition: kutil.h:371
#define TEST_OPT_INTSTRATEGY
Definition: options.h:105
#define kTest_TS(A)
Definition: kutil.h:654
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:464
int scMult0Int(ideal S, ideal Q, const ring tailRing)
Definition: hdegree.cc:919
#define assume(x)
Definition: mod2.h:403
#define messageSets(s)
Definition: kutil.h:538
void updateLHC(kStrategy strat)
Definition: kstd1.cc:1202
#define pGetShortExpVector(a)
returns the "Short Exponent Vector" – used to speed up divisibility tests (see polys-impl.cc )
Definition: polys.h:152
poly sca_pp_Mult_xi_pp(short i, const poly pPoly, const ring rRing)
Definition: sca.cc:1217
LObject P
Definition: kutil.h:298
void initBuchMoraCrit(kStrategy strat)
Definition: kutil.cc:9663
void reorderL(kStrategy strat)
Definition: kstd1.cc:957
BOOLEAN update
Definition: kutil.h:380
int i
Definition: cfEzgcd.cc:123
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
#define IDELEMS(i)
Definition: simpleideals.h:24
static short scaFirstAltVar(ring r)
Definition: sca.h:18
#define p_Test(p, r)
Definition: p_polys.h:160
void rChangeCurrRing(ring r)
Definition: polys.cc:12
int int kStrategy strat
Definition: myNF.cc:68
BOOLEAN kHEdgeFound
Definition: kutil.h:375
LSet L
Definition: kutil.h:323
#define NULL
Definition: omList.c:10
ideal id_KillSquares(const ideal id, const short iFirstAltVar, const short iLastAltVar, const ring r, const bool bSkipZeroes)
Definition: sca.cc:1534
int Lmax
Definition: kutil.h:349
void firstUpdate(kStrategy strat)
Definition: kstd1.cc:1295
#define TEST_OPT_SB_1
Definition: options.h:113
int posInS(const kStrategy strat, const int length, const poly p, const int ecart_p)
Definition: kutil.cc:5112
static BOOLEAN kMoraUseBucket(kStrategy)
Definition: sca.cc:865
#define pDelete(p_ptr)
Definition: polys.h:169
static short scaLastAltVar(ring r)
Definition: sca.h:25
static bool rIsSCA(const ring r)
Definition: nc.h:206
BOOLEAN posInLOldFlag
Definition: kutil.h:381
void completeReduce(kStrategy strat, BOOLEAN withT)
Definition: kutil.cc:10508
#define pNext(p)
Definition: monomials.h:43
void updateResult(ideal r, ideal Q, kStrategy strat)
Definition: kutil.cc:10296
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
static poly nc_CreateSpoly(const poly p1, const poly p2, const ring r)
Definition: nc.h:258
BOOLEAN use_buckets
Definition: kutil.h:382
#define TEST_OPT_FASTHC
Definition: options.h:104
polyrec * poly
Definition: hilb.h:10
int Kstd1_deg
Definition: kutil.cc:236
int newIdeal
Definition: kutil.h:355
static Poly * h
Definition: janet.cc:978
int BOOLEAN
Definition: auxiliary.h:88
void exitBuchMora(kStrategy strat)
Definition: kutil.cc:10063
int posInL10(const LSet set, const int length, LObject *p, const kStrategy strat)
Definition: kstd1.cc:1098
#define idTest(id)
Definition: ideals.h:49

Variable Documentation

§ gnc_gr_bba

BBA_Proc gnc_gr_bba

Definition at line 73 of file old.gring.cc.

§ gnc_gr_mora

BBA_Proc gnc_gr_mora

Definition at line 74 of file old.gring.cc.

§ nc_NF

NF_Proc nc_NF

Definition at line 72 of file old.gring.cc.

§ sca_bba

BBA_Proc sca_bba

Definition at line 75 of file old.gring.cc.

§ sca_gr_bba

BBA_Proc sca_gr_bba

Definition at line 77 of file old.gring.cc.

§ sca_mora

BBA_Proc sca_mora

Definition at line 76 of file old.gring.cc.