My Project  UNKNOWN_GIT_VERSION
Public Member Functions | Data Fields
slimgb_alg Class Reference

#include <tgb_internal.h>

Public Member Functions

 slimgb_alg (ideal I, int syz_comp, BOOLEAN F4, int deg_pos)
 
void introduceDelayedPairs (poly *pa, int s)
 
virtual ~slimgb_alg ()
 
void cleanDegs (int lower, int upper)
 
unsigned long pTotaldegree (poly p)
 
int pTotaldegree_full (poly p)
 

Data Fields

char ** states
 
ideal add_later
 
ideal S
 
ring r
 
int * lengths
 
wlen_typeweighted_lengths
 
long * short_Exps
 
kStrategy strat
 
int * T_deg
 
int * T_deg_full
 
poly tmp_lm
 
poly * tmp_pair_lm
 
sorted_pair_node ** tmp_spn
 
poly * expandS
 
poly * gcd_of_terms
 
int_pair_nodesoon_free
 
sorted_pair_node ** apairs
 
poly_list_nodeto_destroy
 
mp_array_listF
 
poly_array_listF_minus
 
unsigned int reduction_steps
 
int n
 
int syz_comp
 array_lengths should be greater equal n; More...
 
int array_lengths
 
int normal_forms
 
int current_degree
 
int Rcounter
 
int last_index
 
int max_pairs
 
int pair_top
 
int easy_product_crit
 
int extended_product_crit
 
int average_length
 
int lastDpBlockStart
 
int lastCleanedDeg
 
int deg_pos
 
BOOLEAN use_noro
 
BOOLEAN use_noro_last_block
 
BOOLEAN isDifficultField
 
BOOLEAN completed
 
BOOLEAN is_homog
 
BOOLEAN tailReductions
 
BOOLEAN eliminationProblem
 
BOOLEAN F4_mode
 
BOOLEAN nc
 

Detailed Description

Definition at line 213 of file tgb_internal.h.

Constructor & Destructor Documentation

◆ slimgb_alg()

slimgb_alg::slimgb_alg ( ideal  I,
int  syz_comp,
BOOLEAN  F4,
int  deg_pos 
)

Definition at line 3138 of file tgb.cc.

3139 {
3140  this->deg_pos = deg_pos;
3141  lastCleanedDeg = -1;
3142  completed = FALSE;
3143  this->syz_comp = syz_comp;
3144  r = currRing;
3145  nc = rIsPluralRing (r);
3147  //Print("last dp Block start: %i\n", this->lastDpBlockStart);
3148  is_homog = TRUE;
3149  {
3150  int hzz;
3151  for(hzz = 0; hzz < IDELEMS (I); hzz++)
3152  {
3153  assume (I->m[hzz] != NULL);
3154  int d = this->pTotaldegree (I->m[hzz]);
3155  poly t = I->m[hzz]->next;
3156  while(t)
3157  {
3158  if(d != this->pTotaldegree (t))
3159  {
3160  is_homog = FALSE;
3161  break;
3162  }
3163  t = t->next;
3164  }
3165  if(!(is_homog))
3166  break;
3167  }
3168  }
3169  eliminationProblem = ((!(is_homog)) && ((currRing->pLexOrder) || (I->rank > 1)));
3170  tailReductions = ((is_homog) || ((TEST_OPT_REDTAIL) && (!(I->rank > 1))));
3171  // Print("is homog:%d",c->is_homog);
3172  void *h;
3173  int i;
3174  to_destroy = NULL;
3175  easy_product_crit = 0;
3177  if(rField_is_Zp (r))
3179  else
3181  //not fully correct
3182  //(rChar()==0);
3183  F4_mode = F4;
3184 
3185  reduction_steps = 0;
3186  last_index = -1;
3187 
3188  F = NULL;
3189  F_minus = NULL;
3190 
3191  Rcounter = 0;
3192 
3193  soon_free = NULL;
3194 
3195  tmp_lm = pOne ();
3196 
3197  normal_forms = 0;
3198  current_degree = 1;
3199 
3200  max_pairs = 5 * IDELEMS (I);
3201 
3202  apairs =
3203  (sorted_pair_node **) omAlloc (sizeof (sorted_pair_node *) * max_pairs);
3204  pair_top = -1;
3205 
3206  int n = IDELEMS (I);
3207  array_lengths = n;
3208 
3209 
3210  i = 0;
3211  this->n = 0;
3212  T_deg = (int *) omAlloc (n * sizeof (int));
3213  if(eliminationProblem)
3214  T_deg_full = (int *) omAlloc (n * sizeof (int));
3215  else
3216  T_deg_full = NULL;
3217  tmp_pair_lm = (poly *) omAlloc (n * sizeof (poly));
3218  tmp_spn = (sorted_pair_node **) omAlloc (n * sizeof (sorted_pair_node *));
3219  lm_bin = omGetSpecBin (POLYSIZE + (r->ExpL_Size) * sizeof (long));
3220 #ifdef HEAD_BIN
3221  HeadBin = omGetSpecBin (POLYSIZE + (currRing->ExpL_Size) * sizeof (long));
3222 #endif
3223  /* omUnGetSpecBin(&(c->HeadBin)); */
3224 #ifndef HAVE_BOOST
3225 #ifdef USE_STDVECBOOL
3226 #else
3227  h = omAlloc (n * sizeof (char *));
3228 
3229  states = (char **) h;
3230 #endif
3231 #endif
3232  h = omAlloc (n * sizeof (int));
3233  lengths = (int *) h;
3235  gcd_of_terms = (poly *) omAlloc (n * sizeof (poly));
3236 
3237  short_Exps = (long *) omAlloc (n * sizeof (long));
3238  if(F4_mode)
3239  S = idInit (n, I->rank);
3240  else
3241  S = idInit (1, I->rank);
3242  strat = new skStrategy;
3243  if(eliminationProblem)
3244  strat->honey = TRUE;
3245  strat->syzComp = syz_comp;
3249  strat->tailRing = r;
3250  strat->enterS = enterSBba;
3251  strat->sl = -1;
3252  i = n;
3253  i = 1; //some strange bug else
3254  /* initS(c->S,NULL,c->strat); */
3255  /* intS start: */
3256  // i=((i+IDELEMS(c->S)+15)/16)*16;
3257  strat->ecartS = (intset) omAlloc (i * sizeof (int)); /*initec(i); */
3258  strat->sevS = (unsigned long *) omAlloc0 (i * sizeof (unsigned long));
3259  /*initsevS(i); */
3260  strat->S_2_R = (int *) omAlloc0 (i * sizeof (int)); /*initS_2_R(i); */
3261  strat->fromQ = NULL;
3262  strat->Shdl = idInit (1, 1);
3263  strat->S = strat->Shdl->m;
3264  strat->lenS = (int *) omAlloc0 (i * sizeof (int));
3266  strat->lenSw = (wlen_type *) omAlloc0 (i * sizeof (wlen_type));
3267  else
3268  strat->lenSw = NULL;
3269  assume (n > 0);
3270  add_to_basis_ideal_quotient (I->m[0], this, NULL);
3271 
3272  assume (strat->sl == IDELEMS (strat->Shdl) - 1);
3273  if(!(F4_mode))
3274  {
3275  poly *array_arg = I->m;
3276  array_arg++;
3277  introduceDelayedPairs (array_arg, n - 1);
3278  /*
3279  for (i=1;i<n;i++)//the 1 is wanted, because first element is added to basis
3280  {
3281  // add_to_basis(I->m[i],-1,-1,c);
3282  si=(sorted_pair_node*) omalloc(sizeof(sorted_pair_node));
3283  si->i=-1;
3284  si->j=-2;
3285  si->expected_length=pQuality(I->m[i],this,pLength(I->m[i]));
3286  si->deg=pTotaldegree(I->m[i]);
3287  if (!rField_is_Zp(r))
3288  {
3289  p_Cleardenom(I->m[i], r);
3290  }
3291  si->lcm_of_lm=I->m[i];
3292 
3293  // c->apairs[n-1-i]=si;
3294  apairs[n-i-1]=si;
3295  ++(pair_top);
3296  } */
3297  }
3298  else
3299  {
3300  for(i = 1; i < n; i++) //the 1 is wanted, because first element is added to basis
3301  add_to_basis_ideal_quotient (I->m[i], this, NULL);
3302  }
3303  for(i = 0; i < IDELEMS (I); i++)
3304  {
3305  I->m[i] = NULL;
3306  }
3307  idDelete (&I);
3308  add_later = idInit (ADD_LATER_SIZE, S->rank);
3309 #ifdef USE_NORO
3310  use_noro = ((!(nc)) && (S->rank <= 1) && (rField_is_Zp (r))
3311  && (!(eliminationProblem)) && (n_GetChar(currRing->cf) <= 32003));
3312  use_noro_last_block = false;
3313  if((!(use_noro)) && (lastDpBlockStart <= (currRing->N)))
3314  {
3315  use_noro_last_block = ((!(nc)) && (S->rank <= 1) && (rField_is_Zp (r))
3316  && (n_GetChar(currRing->cf) <= 32003));
3317  }
3318 #else
3319  use_noro = false;
3320  use_noro_last_block = false;
3321 #endif
3322  //Print("NORO last block %i",use_noro_last_block);
3323  memset (add_later->m, 0, ADD_LATER_SIZE * sizeof (poly));
3324 }

◆ ~slimgb_alg()

slimgb_alg::~slimgb_alg ( )
virtual

Definition at line 3326 of file tgb.cc.

3327 {
3328 
3329  if(!(completed))
3330  {
3331  poly *add = (poly *) omAlloc ((pair_top + 2) * sizeof (poly));
3332  int piter;
3333  int pos = 0;
3334  for(piter = 0; piter <= pair_top; piter++)
3335  {
3336  sorted_pair_node *s = apairs[piter];
3337  if(s->i < 0)
3338  {
3339  //delayed element
3340  if(s->lcm_of_lm != NULL)
3341  {
3342  add[pos] = s->lcm_of_lm;
3343  pos++;
3344  }
3345  }
3347  apairs[piter] = NULL;
3348  }
3349  pair_top = -1;
3350  add[pos] = NULL;
3351  pos = 0;
3352  while(add[pos] != NULL)
3353  {
3354  add_to_basis_ideal_quotient (add[pos], this, NULL);
3355  pos++;
3356  }
3357  for(piter = 0; piter <= pair_top; piter++)
3358  {
3359  sorted_pair_node *s = apairs[piter];
3360  assume (s->i >= 0);
3362  apairs[piter] = NULL;
3363  }
3364  pair_top = -1;
3365  }
3366  id_Delete (&add_later, r);
3367  int i, j;
3368  slimgb_alg *c = this;
3369  while(c->to_destroy)
3370  {
3371  pDelete (&(c->to_destroy->p));
3372  poly_list_node *old = c->to_destroy;
3373  c->to_destroy = c->to_destroy->next;
3374  omFree (old);
3375  }
3376  while(c->F)
3377  {
3378  for(i = 0; i < c->F->size; i++)
3379  {
3380  pDelete (&(c->F->mp[i].m));
3381  }
3382  omFree (c->F->mp);
3383  c->F->mp = NULL;
3384  mp_array_list *old = c->F;
3385  c->F = c->F->next;
3386  omFree (old);
3387  }
3388  while(c->F_minus)
3389  {
3390  for(i = 0; i < c->F_minus->size; i++)
3391  {
3392  pDelete (&(c->F_minus->p[i]));
3393  }
3394  omFree (c->F_minus->p);
3395  c->F_minus->p = NULL;
3396  poly_array_list *old = c->F_minus;
3397  c->F_minus = c->F_minus->next;
3398  omFree (old);
3399  }
3400 #ifndef HAVE_BOOST
3401 #ifndef USE_STDVECBOOL
3402  for(int z = 1 /* zero length at 0 */ ; z < c->n; z++)
3403  {
3404  omFree (c->states[z]);
3405  }
3406  omFree (c->states);
3407 #endif
3408 #endif
3409 
3410  omFree (c->lengths);
3411  omFree (c->weighted_lengths);
3412  for(int z = 0; z < c->n; z++)
3413  {
3414  pDelete (&c->tmp_pair_lm[z]);
3415  omFree (c->tmp_spn[z]);
3416  }
3417  omFree (c->tmp_pair_lm);
3418  omFree (c->tmp_spn);
3419 
3420  omFree (c->T_deg);
3421  omfree (c->T_deg_full); /*c->T_deg_full my be NULL*/
3422 
3423  omFree (c->strat->ecartS);
3424  omFree (c->strat->sevS);
3425 // initsevS(i);
3426  omFree (c->strat->S_2_R);
3427 
3428 
3429  omFree (c->strat->lenS);
3430 
3431  if(c->strat->lenSw)
3432  omFree (c->strat->lenSw);
3433 
3434  for(i = 0; i < c->n; i++)
3435  {
3436  if(c->gcd_of_terms[i])
3437  pDelete (&(c->gcd_of_terms[i]));
3438  }
3439  omFree (c->gcd_of_terms);
3440 
3441  omFree (c->apairs);
3442  if(TEST_OPT_PROT)
3443  {
3444  //Print("calculated %d NFs\n",c->normal_forms);
3445  Print ("\nNF:%i product criterion:%i, ext_product criterion:%i \n",
3447  }
3448 
3449  for(i = 0; i <= c->strat->sl; i++)
3450  {
3451  if(!c->strat->S[i])
3452  continue;
3453  BOOLEAN found = FALSE;
3454  for(j = 0; j < c->n; j++)
3455  {
3456  if(c->S->m[j] == c->strat->S[i])
3457  {
3458  found = TRUE;
3459  break;
3460  }
3461  }
3462  if(!found)
3463  pDelete (&c->strat->S[i]);
3464  }
3465 // for(i=0;i<c->n;i++)
3466 // {
3467 // if (c->rep[i]!=i)
3468 // {
3469 // // for(j=0;j<=c->strat->sl;j++)
3470 // {
3471 // // if(c->strat->S[j]==c->S->m[i])
3472 // {
3473 // // c->strat->S[j]=NULL;
3474 // // break;
3475 // // }
3476 // // }
3477 // // PrintS("R_delete");
3478 // pDelete(&c->S->m[i]);
3479 // }
3480 // }
3481 
3482  if(completed)
3483  {
3484  for(i = 0; i < c->n; i++)
3485  {
3486  assume (c->S->m[i] != NULL);
3487  if(p_GetComp (c->S->m[i], currRing) > this->syz_comp)
3488  continue;
3489  for(j = 0; j < c->n; j++)
3490  {
3491  if((c->S->m[j] == NULL) || (i == j))
3492  continue;
3493  assume (p_LmShortDivisibleBy (c->S->m[j], c->short_Exps[j],
3494  c->S->m[i], ~c->short_Exps[i],
3495  c->r) == p_LmDivisibleBy (c->S->m[j],
3496  c->S->m[i],
3497  c->r));
3498  if(p_LmShortDivisibleBy (c->S->m[j], c->short_Exps[j],
3499  c->S->m[i], ~c->short_Exps[i], c->r))
3500  {
3501  pDelete (&c->S->m[i]);
3502  break;
3503  }
3504  }
3505  }
3506  }
3507  omFree (c->short_Exps);
3508 
3509  ideal I = c->S;
3510  IDELEMS (I) = c->n;
3511  idSkipZeroes (I);
3512  for(i = 0; i <= c->strat->sl; i++)
3513  c->strat->S[i] = NULL;
3514  id_Delete (&c->strat->Shdl, c->r);
3515  pDelete (&c->tmp_lm);
3517  delete c->strat;
3518 }

Member Function Documentation

◆ cleanDegs()

void slimgb_alg::cleanDegs ( int  lower,
int  upper 
)

Definition at line 3756 of file tgb.cc.

3757 {
3758  assume (is_homog);
3759  int deg;
3760  if(TEST_OPT_PROT)
3761  {
3762  PrintS ("C");
3763  }
3764  for(deg = lower; deg <= upper; deg++)
3765  {
3766  int i;
3767  for(i = 0; i < n; i++)
3768  {
3769  if(T_deg[i] == deg)
3770  {
3771  poly h;
3772  h = S->m[i];
3773  h = redNFTail (h, strat->sl, strat, lengths[i]);
3775  {
3776  p_Cleardenom (h, r); //includes p_Content(h,r);
3777  }
3778  else
3779  pNorm (h);
3780  //TODO:GCD of TERMS
3781  poly got =::gcd_of_terms (h, r);
3782  p_Delete (&gcd_of_terms[i], r);
3783  gcd_of_terms[i] = got;
3784  int len = pLength (h);
3785  wlen_type wlen = pQuality (h, this, len);
3786  if(weighted_lengths)
3787  weighted_lengths[i] = wlen;
3788  lengths[i] = len;
3789  assume (h == S->m[i]);
3790  int j;
3791  for(j = 0; j <= strat->sl; j++)
3792  {
3793  if(h == strat->S[j])
3794  {
3795  int new_pos = simple_posInS (strat, h, len, wlen);
3796  if(strat->lenS)
3797  {
3798  strat->lenS[j] = len;
3799  }
3800  if(strat->lenSw)
3801  {
3802  strat->lenSw[j] = wlen;
3803  }
3804  if(new_pos < j)
3805  {
3806  move_forward_in_S (j, new_pos, strat);
3807  }
3808  else
3809  {
3810  if(new_pos > j)
3811  new_pos = new_pos - 1; //is identical with one element
3812  if(new_pos > j)
3813  move_backward_in_S (j, new_pos, strat);
3814  }
3815  break;
3816  }
3817  }
3818  }
3819  }
3820  }
3821  {
3822  int i, j;
3823  for(i = 0; i < this->n; i++)
3824  {
3825  for(j = 0; j < i; j++)
3826  {
3827  if(T_deg[i] + T_deg[j] <= upper)
3828  {
3829  now_t_rep (i, j, this);
3830  }
3831  }
3832  }
3833  }
3834  //TODO resort and update strat->S,strat->lenSw
3835  //TODO mark pairs
3836 }

◆ introduceDelayedPairs()

void slimgb_alg::introduceDelayedPairs ( poly *  pa,
int  s 
)

Definition at line 3102 of file tgb.cc.

3103 {
3104  if(s == 0)
3105  return;
3106  sorted_pair_node **si_array =
3107  (sorted_pair_node **) omAlloc (s * sizeof (sorted_pair_node *));
3108 
3109  for(int i = 0; i < s; i++)
3110  {
3111  sorted_pair_node *si =
3112  (sorted_pair_node *) omAlloc (sizeof (sorted_pair_node));
3113  si->i = -1;
3114  si->j = -2;
3115  poly p = pa[i];
3116  simplify_poly (p, r);
3117  si->expected_length = pQuality (p, this, pLength (p));
3118  p_Test (p, r);
3119  si->deg = this->pTotaldegree_full (p);
3120  /*if (!rField_is_Zp(r))
3121  {
3122  p_Content(p,r);
3123  p_Cleardenom(p,r);
3124  } */
3125 
3126  si->lcm_of_lm = p;
3127 
3128  // c->apairs[n-1-i]=si;
3129  si_array[i] = si;
3130  }
3131 
3132  qsort (si_array, s, sizeof (sorted_pair_node *), tgb_pair_better_gen2);
3133  apairs = spn_merge (apairs, pair_top + 1, si_array, s, this);
3134  pair_top += s;
3135  omFree (si_array);
3136 }

◆ pTotaldegree()

unsigned long slimgb_alg::pTotaldegree ( poly  p)
inline

Definition at line 289 of file tgb_internal.h.

290  {
291  pTest(p);
292  //assume(pDeg(p,r)==::p_Totaldegree(p,r));
293  assume(((unsigned long)::p_Totaldegree(p,r))==p->exp[deg_pos]);
294  return p->exp[deg_pos];
295  //return ::pTotaldegree(p,this->r);
296  }

◆ pTotaldegree_full()

int slimgb_alg::pTotaldegree_full ( poly  p)
inline

Definition at line 297 of file tgb_internal.h.

298  {
299  int rr=0;
300  while(p)
301  {
302  int d=this->pTotaldegree(p);
303  rr=si_max(rr,d);
304  pIter(p);
305  }
306  return rr;
307  }

Field Documentation

◆ add_later

ideal slimgb_alg::add_later

Definition at line 229 of file tgb_internal.h.

◆ apairs

sorted_pair_node** slimgb_alg::apairs

Definition at line 244 of file tgb_internal.h.

◆ array_lengths

int slimgb_alg::array_lengths

Definition at line 264 of file tgb_internal.h.

◆ average_length

int slimgb_alg::average_length

Definition at line 273 of file tgb_internal.h.

◆ completed

BOOLEAN slimgb_alg::completed

Definition at line 280 of file tgb_internal.h.

◆ current_degree

int slimgb_alg::current_degree

Definition at line 266 of file tgb_internal.h.

◆ deg_pos

int slimgb_alg::deg_pos

Definition at line 276 of file tgb_internal.h.

◆ easy_product_crit

int slimgb_alg::easy_product_crit

Definition at line 271 of file tgb_internal.h.

◆ eliminationProblem

BOOLEAN slimgb_alg::eliminationProblem

Definition at line 283 of file tgb_internal.h.

◆ expandS

poly* slimgb_alg::expandS

Definition at line 241 of file tgb_internal.h.

◆ extended_product_crit

int slimgb_alg::extended_product_crit

Definition at line 272 of file tgb_internal.h.

◆ F

mp_array_list* slimgb_alg::F

Definition at line 253 of file tgb_internal.h.

◆ F4_mode

BOOLEAN slimgb_alg::F4_mode

Definition at line 284 of file tgb_internal.h.

◆ F_minus

poly_array_list* slimgb_alg::F_minus

Definition at line 254 of file tgb_internal.h.

◆ gcd_of_terms

poly* slimgb_alg::gcd_of_terms

Definition at line 242 of file tgb_internal.h.

◆ is_homog

BOOLEAN slimgb_alg::is_homog

Definition at line 281 of file tgb_internal.h.

◆ isDifficultField

BOOLEAN slimgb_alg::isDifficultField

Definition at line 279 of file tgb_internal.h.

◆ last_index

int slimgb_alg::last_index

Definition at line 268 of file tgb_internal.h.

◆ lastCleanedDeg

int slimgb_alg::lastCleanedDeg

Definition at line 275 of file tgb_internal.h.

◆ lastDpBlockStart

int slimgb_alg::lastDpBlockStart

Definition at line 274 of file tgb_internal.h.

◆ lengths

int* slimgb_alg::lengths

Definition at line 232 of file tgb_internal.h.

◆ max_pairs

int slimgb_alg::max_pairs

Definition at line 269 of file tgb_internal.h.

◆ n

int slimgb_alg::n

Definition at line 261 of file tgb_internal.h.

◆ nc

BOOLEAN slimgb_alg::nc

Definition at line 285 of file tgb_internal.h.

◆ normal_forms

int slimgb_alg::normal_forms

Definition at line 265 of file tgb_internal.h.

◆ pair_top

int slimgb_alg::pair_top

Definition at line 270 of file tgb_internal.h.

◆ r

ring slimgb_alg::r

Definition at line 231 of file tgb_internal.h.

◆ Rcounter

int slimgb_alg::Rcounter

Definition at line 267 of file tgb_internal.h.

◆ reduction_steps

unsigned int slimgb_alg::reduction_steps

Definition at line 260 of file tgb_internal.h.

◆ S

ideal slimgb_alg::S

Definition at line 230 of file tgb_internal.h.

◆ short_Exps

long* slimgb_alg::short_Exps

Definition at line 234 of file tgb_internal.h.

◆ soon_free

int_pair_node* slimgb_alg::soon_free

Definition at line 243 of file tgb_internal.h.

◆ states

char** slimgb_alg::states

Definition at line 224 of file tgb_internal.h.

◆ strat

kStrategy slimgb_alg::strat

Definition at line 235 of file tgb_internal.h.

◆ syz_comp

int slimgb_alg::syz_comp

array_lengths should be greater equal n;

Definition at line 263 of file tgb_internal.h.

◆ T_deg

int* slimgb_alg::T_deg

Definition at line 236 of file tgb_internal.h.

◆ T_deg_full

int* slimgb_alg::T_deg_full

Definition at line 237 of file tgb_internal.h.

◆ tailReductions

BOOLEAN slimgb_alg::tailReductions

Definition at line 282 of file tgb_internal.h.

◆ tmp_lm

poly slimgb_alg::tmp_lm

Definition at line 238 of file tgb_internal.h.

◆ tmp_pair_lm

poly* slimgb_alg::tmp_pair_lm

Definition at line 239 of file tgb_internal.h.

◆ tmp_spn

sorted_pair_node** slimgb_alg::tmp_spn

Definition at line 240 of file tgb_internal.h.

◆ to_destroy

poly_list_node* slimgb_alg::to_destroy

Definition at line 251 of file tgb_internal.h.

◆ use_noro

BOOLEAN slimgb_alg::use_noro

Definition at line 277 of file tgb_internal.h.

◆ use_noro_last_block

BOOLEAN slimgb_alg::use_noro_last_block

Definition at line 278 of file tgb_internal.h.

◆ weighted_lengths

wlen_type* slimgb_alg::weighted_lengths

Definition at line 233 of file tgb_internal.h.


The documentation for this class was generated from the following files:
FALSE
#define FALSE
Definition: auxiliary.h:94
poly_list_node::next
poly_list_node * next
Definition: tgb_internal.h:185
skStrategy
Definition: kutil.h:266
slimgb_alg::pTotaldegree
unsigned long pTotaldegree(poly p)
Definition: tgb_internal.h:289
skStrategy::fromQ
intset fromQ
Definition: kutil.h:312
initBuchMoraCrit
void initBuchMoraCrit(kStrategy strat)
Definition: kutil.cc:9570
p_GetComp
#define p_GetComp(p, r)
Definition: monomials.h:65
slimgb_alg::reduction_steps
unsigned int reduction_steps
Definition: tgb_internal.h:260
sorted_pair_node::lcm_of_lm
poly lcm_of_lm
Definition: tgb_internal.h:162
simplify_poly
static void simplify_poly(poly p, ring r)
Definition: tgb.cc:59
j
int j
Definition: facHensel.cc:105
pNorm
void pNorm(poly p, const ring R=currRing)
Definition: polys.h:357
omFree
#define omFree(addr)
Definition: omAllocDecl.h:261
slimgb_alg::introduceDelayedPairs
void introduceDelayedPairs(poly *pa, int s)
Definition: tgb.cc:3102
skStrategy::enterS
void(* enterS)(LObject &h, int pos, kStrategy strat, int atR)
Definition: kutil.h:277
TEST_OPT_PROT
#define TEST_OPT_PROT
Definition: options.h:102
idDelete
#define idDelete(H)
delete an ideal
Definition: ideals.h:29
TEST_OPT_REDTAIL
#define TEST_OPT_REDTAIL
Definition: options.h:115
slimgb_alg::apairs
sorted_pair_node ** apairs
Definition: tgb_internal.h:244
free_sorted_pair_node
void free_sorted_pair_node(sorted_pair_node *s, const ring r)
Definition: tgb.cc:3916
sorted_pair_node::deg
int deg
Definition: tgb_internal.h:165
n_GetChar
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:444
omGetSpecBin
#define omGetSpecBin(size)
Definition: omBin.h:11
skStrategy::ecartS
intset ecartS
Definition: kutil.h:300
slimgb_alg::tailReductions
BOOLEAN tailReductions
Definition: tgb_internal.h:282
slimgb_alg::tmp_lm
poly tmp_lm
Definition: tgb_internal.h:238
slimgb_alg::tmp_spn
sorted_pair_node ** tmp_spn
Definition: tgb_internal.h:240
skStrategy::S
polyset S
Definition: kutil.h:297
skStrategy::lenS
intset lenS
Definition: kutil.h:310
sorted_pair_node::i
int i
Definition: tgb_internal.h:163
omAllocAligned
#define omAllocAligned
Definition: omAllocDecl.h:273
slimgb_alg::use_noro_last_block
BOOLEAN use_noro_last_block
Definition: tgb_internal.h:278
skStrategy::tailRing
ring tailRing
Definition: kutil.h:336
slimgb_alg::weighted_lengths
wlen_type * weighted_lengths
Definition: tgb_internal.h:233
slimgb_alg::T_deg_full
int * T_deg_full
Definition: tgb_internal.h:237
now_t_rep
void now_t_rep(const int &arg_i, const int &arg_j, slimgb_alg *c)
Definition: tgb.cc:3623
slimgb_alg::pTotaldegree_full
int pTotaldegree_full(poly p)
Definition: tgb_internal.h:297
mp_array_list::mp
monom_poly * mp
Definition: tgb_internal.h:201
sorted_pair_node
Definition: tgb_internal.h:159
p_Test
#define p_Test(p, r)
Definition: p_polys.h:164
slimgb_alg::r
ring r
Definition: tgb_internal.h:231
ADD_LATER_SIZE
#define ADD_LATER_SIZE
Definition: tgb.cc:39
skStrategy::sevS
unsigned long * sevS
Definition: kutil.h:313
redNFTail
static poly redNFTail(poly h, const int sl, kStrategy strat, int len)
Definition: tgb.cc:2937
pDelete
#define pDelete(p_ptr)
Definition: polys.h:181
skStrategy::honey
char honey
Definition: kutil.h:371
slimgb_alg::normal_forms
int normal_forms
Definition: tgb_internal.h:265
slimgb_alg::n
int n
Definition: tgb_internal.h:261
slimgb_alg::soon_free
int_pair_node * soon_free
Definition: tgb_internal.h:243
p_LmDivisibleBy
static BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
Definition: p_polys.h:1821
monom_poly::m
poly m
Definition: tgb_internal.h:196
slimgb_alg::Rcounter
int Rcounter
Definition: tgb_internal.h:267
found
bool found
Definition: facFactorize.cc:56
rIsPluralRing
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition: ring.h:398
pLength
static unsigned pLength(poly a)
Definition: p_polys.h:193
move_backward_in_S
static void move_backward_in_S(int old_pos, int new_pos, kStrategy strat)
Definition: tgb.cc:1064
slimgb_alg::F4_mode
BOOLEAN F4_mode
Definition: tgb_internal.h:284
currRing
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
slimgb_alg::add_later
ideal add_later
Definition: tgb_internal.h:229
TRUE
#define TRUE
Definition: auxiliary.h:98
TEST_OPT_INTSTRATEGY
#define TEST_OPT_INTSTRATEGY
Definition: options.h:109
i
int i
Definition: cfEzgcd.cc:125
id_Delete
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
Definition: simpleideals.cc:114
tgb_pair_better_gen2
int tgb_pair_better_gen2(const void *ap, const void *bp)
Definition: tgb.cc:680
poly_array_list::size
int size
Definition: tgb_internal.h:210
skStrategy::sl
int sl
Definition: kutil.h:341
poly_list_node::p
poly p
Definition: tgb_internal.h:184
add
static unsigned add[]
Definition: misc_ip.cc:122
enterSBba
void enterSBba(LObject &p, int atS, kStrategy strat, int atR)
Definition: kutil.cc:9050
slimgb_alg::nc
BOOLEAN nc
Definition: tgb_internal.h:285
PrintS
void PrintS(const char *s)
Definition: reporter.cc:284
sorted_pair_node::j
int j
Definition: tgb_internal.h:164
BOOLEAN
int BOOLEAN
Definition: auxiliary.h:85
pTest
#define pTest(p)
Definition: polys.h:409
slimgb_alg::short_Exps
long * short_Exps
Definition: tgb_internal.h:234
skStrategy::Shdl
ideal Shdl
Definition: kutil.h:294
idSkipZeroes
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
Definition: simpleideals.cc:172
slimgb_alg::T_deg
int * T_deg
Definition: tgb_internal.h:236
get_last_dp_block_start
static int get_last_dp_block_start(ring r)
Definition: tgb.cc:427
h
static Poly * h
Definition: janet.cc:972
intset
int * intset
Definition: kutil.h:49
pOne
#define pOne()
Definition: polys.h:309
pIter
#define pIter(p)
Definition: monomials.h:38
p_Cleardenom
poly p_Cleardenom(poly p, const ring r)
Definition: p_polys.cc:2782
omAlloc
#define omAlloc(size)
Definition: omAllocDecl.h:210
slimgb_alg::extended_product_crit
int extended_product_crit
Definition: tgb_internal.h:272
slimgb_alg::isDifficultField
BOOLEAN isDifficultField
Definition: tgb_internal.h:279
mp_array_list::size
int size
Definition: tgb_internal.h:202
initBuchMoraPos
void initBuchMoraPos(kStrategy strat)
Definition: kutil.cc:9721
slimgb_alg::pair_top
int pair_top
Definition: tgb_internal.h:270
slimgb_alg::strat
kStrategy strat
Definition: tgb_internal.h:235
skStrategy::lenSw
wlen_set lenSw
Definition: kutil.h:311
poly_array_list::p
poly * p
Definition: tgb_internal.h:209
skStrategy::S_2_R
int * S_2_R
Definition: kutil.h:335
skStrategy::syzComp
int syzComp
Definition: kutil.h:347
wlen_type
int64 wlen_type
Definition: kutil.h:50
slimgb_alg::F
mp_array_list * F
Definition: tgb_internal.h:253
simple_posInS
static int simple_posInS(kStrategy strat, poly p, int len, wlen_type wlen)
Definition: tgb.cc:1308
slimgb_alg::current_degree
int current_degree
Definition: tgb_internal.h:266
mp_array_list::next
mp_array_list * next
Definition: tgb_internal.h:203
slimgb_alg::deg_pos
int deg_pos
Definition: tgb_internal.h:276
slimgb_alg::lastDpBlockStart
int lastDpBlockStart
Definition: tgb_internal.h:274
slimgb_alg::is_homog
BOOLEAN is_homog
Definition: tgb_internal.h:281
slimgb_alg::S
ideal S
Definition: tgb_internal.h:230
p_Delete
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:858
lm_bin
static omBin lm_bin
Definition: tgb.cc:41
spn_merge
sorted_pair_node ** spn_merge(sorted_pair_node **p, int pn, sorted_pair_node **q, int qn, slimgb_alg *c)
Definition: tgb.cc:751
poly_array_list::next
poly_array_list * next
Definition: tgb_internal.h:211
slimgb_alg::lastCleanedDeg
int lastCleanedDeg
Definition: tgb_internal.h:275
poly_array_list
Definition: tgb_internal.h:208
si_max
static int si_max(const int a, const int b)
Definition: auxiliary.h:138
omUnGetSpecBin
#define omUnGetSpecBin(bin_ptr)
Definition: omBin.h:14
mp_array_list
Definition: tgb_internal.h:200
slimgb_alg::use_noro
BOOLEAN use_noro
Definition: tgb_internal.h:277
Print
#define Print
Definition: emacs.cc:80
slimgb_alg
Definition: tgb_internal.h:214
pQuality
static wlen_type pQuality(poly p, slimgb_alg *c, int l=-1)
Definition: tgb.cc:544
add_to_basis_ideal_quotient
sorted_pair_node ** add_to_basis_ideal_quotient(poly h, slimgb_alg *c, int *ip)
Definition: tgb.cc:1426
idInit
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:37
slimgb_alg::states
char ** states
Definition: tgb_internal.h:224
slimgb_alg::tmp_pair_lm
poly * tmp_pair_lm
Definition: tgb_internal.h:239
assume
#define assume(x)
Definition: mod2.h:390
NULL
#define NULL
Definition: omList.c:10
slimgb_alg::array_lengths
int array_lengths
Definition: tgb_internal.h:264
slimgb_alg::lengths
int * lengths
Definition: tgb_internal.h:232
slimgb_alg::completed
BOOLEAN completed
Definition: tgb_internal.h:280
slimgb_alg::eliminationProblem
BOOLEAN eliminationProblem
Definition: tgb_internal.h:283
p_Totaldegree
static long p_Totaldegree(poly p, const ring r)
Definition: p_polys.h:1444
p
int p
Definition: cfModGcd.cc:4019
skStrategy::initEcart
void(* initEcart)(TObject *L)
Definition: kutil.h:271
s
const CanonicalForm int s
Definition: facAbsFact.cc:55
slimgb_alg::syz_comp
int syz_comp
array_lengths should be greater equal n;
Definition: tgb_internal.h:263
slimgb_alg::gcd_of_terms
poly * gcd_of_terms
Definition: tgb_internal.h:242
initEcartBBA
void initEcartBBA(TObject *h)
Definition: kutil.cc:1265
IDELEMS
#define IDELEMS(i)
Definition: simpleideals.h:24
slimgb_alg::easy_product_crit
int easy_product_crit
Definition: tgb_internal.h:271
slimgb_alg::F_minus
poly_array_list * F_minus
Definition: tgb_internal.h:254
poly_list_node
Definition: tgb_internal.h:183
sorted_pair_node::expected_length
wlen_type expected_length
Definition: tgb_internal.h:161
rField_is_Zp
static BOOLEAN rField_is_Zp(const ring r)
Definition: ring.h:491
POLYSIZE
#define POLYSIZE
Definition: monomials.h:234
omAlloc0
#define omAlloc0(size)
Definition: omAllocDecl.h:211
p_LmShortDivisibleBy
static BOOLEAN p_LmShortDivisibleBy(poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, const ring r)
Definition: p_polys.h:1855
slimgb_alg::last_index
int last_index
Definition: tgb_internal.h:268
move_forward_in_S
static void move_forward_in_S(int old_pos, int new_pos, kStrategy strat)
Definition: tgb.cc:1027
omfree
#define omfree(addr)
Definition: omAllocDecl.h:237
slimgb_alg::max_pairs
int max_pairs
Definition: tgb_internal.h:269
slimgb_alg::to_destroy
poly_list_node * to_destroy
Definition: tgb_internal.h:251