My Project
Loading...
Searching...
No Matches
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;
 
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 198 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 3202 of file tgb.cc.

3203{
3204 this->deg_pos = deg_pos;
3205 lastCleanedDeg = -1;
3206 completed = FALSE;
3207 this->syz_comp = syz_comp;
3208 r = currRing;
3209 nc = rIsPluralRing (r);
3211 //Print("last dp Block start: %i\n", this->lastDpBlockStart);
3212 is_homog = TRUE;
3213 {
3214 int hzz;
3215 for(hzz = 0; hzz < IDELEMS (I); hzz++)
3216 {
3217 assume (I->m[hzz] != NULL);
3218 int d = this->pTotaldegree (I->m[hzz]);
3219 poly t = I->m[hzz]->next;
3220 while(t)
3221 {
3222 if(d != (int)this->pTotaldegree (t))
3223 {
3224 is_homog = FALSE;
3225 break;
3226 }
3227 t = t->next;
3228 }
3229 if(!(is_homog))
3230 break;
3231 }
3232 }
3233 eliminationProblem = ((!(is_homog)) && ((currRing->pLexOrder) || (I->rank > 1)));
3234 tailReductions = ((is_homog) || ((TEST_OPT_REDTAIL) && (!(I->rank > 1))));
3235 // Print("is homog:%d",c->is_homog);
3236 void *h;
3237 int i;
3238 to_destroy = NULL;
3241 if(rField_is_Zp (r))
3243 else
3245 //not fully correct
3246 //(rChar()==0);
3247 F4_mode = F4;
3248
3249 reduction_steps = 0;
3250 last_index = -1;
3251
3252 F = NULL;
3253 F_minus = NULL;
3254
3255 Rcounter = 0;
3256
3257 soon_free = NULL;
3258
3259 tmp_lm = pOne ();
3260
3261 normal_forms = 0;
3262 current_degree = 1;
3263
3264 max_pairs = 5 * IDELEMS (I);
3265
3266 apairs =
3267 (sorted_pair_node **) omAlloc (sizeof (sorted_pair_node *) * max_pairs);
3268 pair_top = -1;
3269
3270 int n = IDELEMS (I);
3271 array_lengths = n;
3272
3273
3274 i = 0;
3275 this->n = 0;
3276 T_deg = (int *) omAlloc (n * sizeof (int));
3278 T_deg_full = (int *) omAlloc (n * sizeof (int));
3279 else
3280 T_deg_full = NULL;
3281 tmp_pair_lm = (poly *) omAlloc (n * sizeof (poly));
3282 tmp_spn = (sorted_pair_node **) omAlloc (n * sizeof (sorted_pair_node *));
3283 lm_bin = omGetSpecBin (POLYSIZE + (r->ExpL_Size) * sizeof (long));
3284 /* omUnGetSpecBin(&(c->HeadBin)); */
3285#ifndef HAVE_BOOST
3286#ifdef USE_STDVECBOOL
3287#else
3288 h = omAlloc (n * sizeof (char *));
3289
3290 states = (char **) h;
3291#endif
3292#endif
3293 h = omAlloc (n * sizeof (int));
3294 lengths = (int *) h;
3296 gcd_of_terms = (poly *) omAlloc (n * sizeof (poly));
3297
3298 short_Exps = (long *) omAlloc (n * sizeof (long));
3299 if(F4_mode)
3300 S = idInit (n, I->rank);
3301 else
3302 S = idInit (1, I->rank);
3303 strat = new skStrategy;
3305 strat->honey = TRUE;
3306 strat->syzComp = syz_comp;
3309 strat->initEcart = initEcartBBA;
3310 strat->tailRing = r;
3311 strat->enterS = enterSBba;
3312 strat->sl = -1;
3313 i = n;
3314 i = 1; //some strange bug else
3315 /* initS(c->S,NULL,c->strat); */
3316 /* intS start: */
3317 // i=((i+IDELEMS(c->S)+15)/16)*16;
3318 strat->ecartS = (intset) omAlloc (i * sizeof (int)); /*initec(i); */
3319 strat->sevS = (unsigned long *) omAlloc0 (i * sizeof (unsigned long));
3320 /*initsevS(i); */
3321 strat->S_2_R = (int *) omAlloc0 (i * sizeof (int)); /*initS_2_R(i); */
3322 strat->fromQ = NULL;
3323 strat->Shdl = idInit (1, 1);
3324 strat->S = strat->Shdl->m;
3325 strat->lenS = (int *) omAlloc0 (i * sizeof (int));
3327 strat->lenSw = (wlen_type *) omAlloc0 (i * sizeof (wlen_type));
3328 else
3329 strat->lenSw = NULL;
3330 assume (n > 0);
3331 add_to_basis_ideal_quotient (I->m[0], this, NULL);
3332
3333 assume (strat->sl == IDELEMS (strat->Shdl) - 1);
3334 if(!(F4_mode))
3335 {
3336 poly *array_arg = I->m;
3337 array_arg++;
3338 introduceDelayedPairs (array_arg, n - 1);
3339 /*
3340 for (i=1;i<n;i++)//the 1 is wanted, because first element is added to basis
3341 {
3342 // add_to_basis(I->m[i],-1,-1,c);
3343 si=(sorted_pair_node*) omalloc(sizeof(sorted_pair_node));
3344 si->i=-1;
3345 si->j=-2;
3346 si->expected_length=pQuality(I->m[i],this,pLength(I->m[i]));
3347 si->deg=pTotaldegree(I->m[i]);
3348 if (!rField_is_Zp(r))
3349 {
3350 p_Cleardenom(I->m[i], r);
3351 }
3352 si->lcm_of_lm=I->m[i];
3353
3354 // c->apairs[n-1-i]=si;
3355 apairs[n-i-1]=si;
3356 ++(pair_top);
3357 } */
3358 }
3359 else
3360 {
3361 for(i = 1; i < n; i++) //the 1 is wanted, because first element is added to basis
3362 add_to_basis_ideal_quotient (I->m[i], this, NULL);
3363 }
3364 for(i = 0; i < IDELEMS (I); i++)
3365 {
3366 I->m[i] = NULL;
3367 }
3368 idDelete (&I);
3369 add_later = idInit (ADD_LATER_SIZE, S->rank);
3370#ifdef USE_NORO
3371 use_noro = ((!(nc)) && (S->rank <= 1) && (rField_is_Zp (r))
3372 && (!(eliminationProblem)) && (n_GetChar(currRing->cf) <= NV_MAX_PRIME));
3373 use_noro_last_block = false;
3374 if((!(use_noro)) && (lastDpBlockStart <= (currRing->N)))
3375 {
3376 use_noro_last_block = ((!(nc)) && (S->rank <= 1) && (rField_is_Zp (r))
3377 && (n_GetChar(currRing->cf) <= NV_MAX_PRIME));
3378 }
3379#else
3380 use_noro = false;
3381 use_noro_last_block = false;
3382#endif
3383 //Print("NORO last block %i",use_noro_last_block);
3384 memset (add_later->m, 0, ADD_LATER_SIZE * sizeof (poly));
3385}
#define TRUE
Definition auxiliary.h:101
#define FALSE
Definition auxiliary.h:97
int i
Definition cfEzgcd.cc:132
unsigned long pTotaldegree(poly p)
mp_array_list * F
BOOLEAN completed
int_pair_node * soon_free
sorted_pair_node ** apairs
kStrategy strat
int * T_deg_full
BOOLEAN use_noro_last_block
int easy_product_crit
int lastDpBlockStart
ideal add_later
int extended_product_crit
sorted_pair_node ** tmp_spn
void introduceDelayedPairs(poly *pa, int s)
Definition tgb.cc:3166
char ** states
BOOLEAN isDifficultField
unsigned int reduction_steps
poly_array_list * F_minus
poly * gcd_of_terms
poly * tmp_pair_lm
long * short_Exps
BOOLEAN tailReductions
BOOLEAN is_homog
int syz_comp
array_lengths should be greater equal n;
BOOLEAN use_noro
BOOLEAN eliminationProblem
wlen_type * weighted_lengths
BOOLEAN F4_mode
poly_list_node * to_destroy
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition coeffs.h:448
STATIC_VAR omBin lm_bin
Definition fast_mult.cc:429
#define idDelete(H)
delete an ideal
Definition ideals.h:29
STATIC_VAR Poly * h
Definition janet.cc:971
void initBuchMoraPos(kStrategy strat)
Definition kutil.cc:9580
void initBuchMoraCrit(kStrategy strat)
Definition kutil.cc:9435
void initEcartBBA(TObject *h)
Definition kutil.cc:1308
void enterSBba(LObject &p, int atS, kStrategy strat, int atR)
Definition kutil.cc:8794
int64 wlen_type
Definition kutil.h:55
int * intset
Definition kutil.h:54
#define assume(x)
Definition mod2.h:389
#define NV_MAX_PRIME
Definition modulop.h:37
#define POLYSIZE
Definition monomials.h:233
#define omAlloc(size)
#define omAlloc0(size)
#define omAllocAligned
#define omGetSpecBin(size)
Definition omBin.h:11
#define NULL
Definition omList.c:12
#define TEST_OPT_REDTAIL
Definition options.h:118
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition polys.cc:13
#define pOne()
Definition polys.h:316
static BOOLEAN rField_is_Zp(const ring r)
Definition ring.h:506
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition ring.h:406
ideal idInit(int idsize, int rank)
initialise an ideal / module
#define IDELEMS(i)
#define ADD_LATER_SIZE
Definition tgb.cc:39
static int get_last_dp_block_start(ring r)
Definition tgb.cc:427
sorted_pair_node ** add_to_basis_ideal_quotient(poly h, slimgb_alg *c, int *ip)
Definition tgb.cc:1378

◆ ~slimgb_alg()

slimgb_alg::~slimgb_alg ( )
virtual

Definition at line 3387 of file tgb.cc.

3388{
3389
3390 if(!(completed))
3391 {
3392 poly *add = (poly *) omAlloc ((pair_top + 2) * sizeof (poly));
3393 int piter;
3394 int pos = 0;
3395 for(piter = 0; piter <= pair_top; piter++)
3396 {
3397 sorted_pair_node *s = apairs[piter];
3398 if(s->i < 0)
3399 {
3400 //delayed element
3401 if(s->lcm_of_lm != NULL)
3402 {
3403 add[pos] = s->lcm_of_lm;
3404 pos++;
3405 }
3406 }
3408 apairs[piter] = NULL;
3409 }
3410 pair_top = -1;
3411 add[pos] = NULL;
3412 pos = 0;
3413 while(add[pos] != NULL)
3414 {
3415 add_to_basis_ideal_quotient (add[pos], this, NULL);
3416 pos++;
3417 }
3418 for(piter = 0; piter <= pair_top; piter++)
3419 {
3420 sorted_pair_node *s = apairs[piter];
3421 assume (s->i >= 0);
3423 apairs[piter] = NULL;
3424 }
3425 pair_top = -1;
3426 }
3427 id_Delete (&add_later, r);
3428 int i, j;
3429 slimgb_alg *c = this;
3430 while(c->to_destroy)
3431 {
3432 pDelete (&(c->to_destroy->p));
3433 poly_list_node *old = c->to_destroy;
3434 c->to_destroy = c->to_destroy->next;
3435 omFree (old);
3436 }
3437 while(c->F)
3438 {
3439 for(i = 0; i < c->F->size; i++)
3440 {
3441 pDelete (&(c->F->mp[i].m));
3442 }
3443 omFree (c->F->mp);
3444 c->F->mp = NULL;
3445 mp_array_list *old = c->F;
3446 c->F = c->F->next;
3447 omFree (old);
3448 }
3449 while(c->F_minus)
3450 {
3451 for(i = 0; i < c->F_minus->size; i++)
3452 {
3453 pDelete (&(c->F_minus->p[i]));
3454 }
3455 omFree (c->F_minus->p);
3456 c->F_minus->p = NULL;
3457 poly_array_list *old = c->F_minus;
3458 c->F_minus = c->F_minus->next;
3459 omFree (old);
3460 }
3461#ifndef HAVE_BOOST
3462#ifndef USE_STDVECBOOL
3463 for(int z = 1 /* zero length at 0 */ ; z < c->n; z++)
3464 {
3465 omFree (c->states[z]);
3466 }
3467 omFree (c->states);
3468#endif
3469#endif
3470
3471 omFree (c->lengths);
3473 for(int z = 0; z < c->n; z++)
3474 {
3475 pDelete (&c->tmp_pair_lm[z]);
3476 omFree (c->tmp_spn[z]);
3477 }
3478 omFree (c->tmp_pair_lm);
3479 omFree (c->tmp_spn);
3480
3481 omFree (c->T_deg);
3482 omfree (c->T_deg_full); /*c->T_deg_full my be NULL*/
3483
3484 omFree (c->strat->ecartS);
3485 omFree (c->strat->sevS);
3486// initsevS(i);
3487 omFree (c->strat->S_2_R);
3488
3489
3490 omFree (c->strat->lenS);
3491
3492 if(c->strat->lenSw)
3493 omFree (c->strat->lenSw);
3494
3495 for(i = 0; i < c->n; i++)
3496 {
3497 if(c->gcd_of_terms[i])
3498 pDelete (&(c->gcd_of_terms[i]));
3499 }
3500 omFree (c->gcd_of_terms);
3501
3502 omFree (c->apairs);
3503 if(TEST_OPT_PROT)
3504 {
3505 //Print("calculated %d NFs\n",c->normal_forms);
3506 Print ("\nNF:%i product criterion:%i, ext_product criterion:%i \n",
3508 }
3509
3510 for(i = 0; i <= c->strat->sl; i++)
3511 {
3512 if(!c->strat->S[i])
3513 continue;
3515 for(j = 0; j < c->n; j++)
3516 {
3517 if(c->S->m[j] == c->strat->S[i])
3518 {
3519 found = TRUE;
3520 break;
3521 }
3522 }
3523 if(!found)
3524 pDelete (&c->strat->S[i]);
3525 }
3526// for(i=0;i<c->n;i++)
3527// {
3528// if (c->rep[i]!=i)
3529// {
3530// // for(j=0;j<=c->strat->sl;j++)
3531// {
3532// // if(c->strat->S[j]==c->S->m[i])
3533// {
3534// // c->strat->S[j]=NULL;
3535// // break;
3536// // }
3537// // }
3538// // PrintS("R_delete");
3539// pDelete(&c->S->m[i]);
3540// }
3541// }
3542
3543 if(completed)
3544 {
3545 for(i = 0; i < c->n; i++)
3546 {
3547 assume (c->S->m[i] != NULL);
3548 if(p_GetComp (c->S->m[i], currRing) > this->syz_comp)
3549 continue;
3550 for(j = 0; j < c->n; j++)
3551 {
3552 if((c->S->m[j] == NULL) || (i == j))
3553 continue;
3554 assume (p_LmShortDivisibleBy (c->S->m[j], c->short_Exps[j],
3555 c->S->m[i], ~c->short_Exps[i],
3556 c->r) == p_LmDivisibleBy (c->S->m[j],
3557 c->S->m[i],
3558 c->r));
3559 if(p_LmShortDivisibleBy (c->S->m[j], c->short_Exps[j],
3560 c->S->m[i], ~c->short_Exps[i], c->r))
3561 {
3562 pDelete (&c->S->m[i]);
3563 break;
3564 }
3565 }
3566 }
3567 }
3568 omFree (c->short_Exps);
3569
3570 ideal I = c->S;
3571 IDELEMS (I) = c->n;
3572 idSkipZeroes (I);
3573 for(i = 0; i <= c->strat->sl; i++)
3574 c->strat->S[i] = NULL;
3575 id_Delete (&c->strat->Shdl, c->r);
3576 pDelete (&c->tmp_lm);
3578 delete c->strat;
3579}
int BOOLEAN
Definition auxiliary.h:88
int * S_2_R
Definition kutil.h:343
intset lenS
Definition kutil.h:320
intset ecartS
Definition kutil.h:310
polyset S
Definition kutil.h:307
ideal Shdl
Definition kutil.h:304
wlen_set lenSw
Definition kutil.h:321
int sl
Definition kutil.h:349
unsigned long * sevS
Definition kutil.h:323
slimgb_alg(ideal I, int syz_comp, BOOLEAN F4, int deg_pos)
Definition tgb.cc:3202
#define Print
Definition emacs.cc:80
const CanonicalForm int s
Definition facAbsFact.cc:51
bool found
int j
Definition facHensel.cc:110
STATIC_VAR unsigned add[]
Definition misc_ip.cc:108
#define p_GetComp(p, r)
Definition monomials.h:64
#define omfree(addr)
#define omFree(addr)
#define omUnGetSpecBin(bin_ptr)
Definition omBin.h:14
#define TEST_OPT_PROT
Definition options.h:105
static BOOLEAN p_LmShortDivisibleBy(poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, const ring r)
Definition p_polys.h:1926
static BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
Definition p_polys.h:1907
#define pDelete(p_ptr)
Definition polys.h:187
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
poly_array_list * next
mp_array_list * next
poly_list_node * next
void free_sorted_pair_node(sorted_pair_node *s, const ring r)
Definition tgb.cc:3964
monom_poly * mp

Member Function Documentation

◆ cleanDegs()

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

Definition at line 3804 of file tgb.cc.

3805{
3806 assume (is_homog);
3807 int deg;
3808 if(TEST_OPT_PROT)
3809 {
3810 PrintS ("C");
3811 }
3812 for(deg = lower; deg <= upper; deg++)
3813 {
3814 int i;
3815 for(i = 0; i < n; i++)
3816 {
3817 if(T_deg[i] == deg)
3818 {
3819 poly h;
3820 h = S->m[i];
3821 h = redNFTail (h, strat->sl, strat, lengths[i]);
3823 {
3824 p_Cleardenom (h, r); //includes p_Content(h,r);
3825 }
3826 else
3827 pNorm (h);
3828 //TODO:GCD of TERMS
3829 poly got =::gcd_of_terms (h, r);
3830 p_Delete (&gcd_of_terms[i], r);
3831 gcd_of_terms[i] = got;
3832 int len = pLength (h);
3833 wlen_type wlen = pQuality (h, this, len);
3835 weighted_lengths[i] = wlen;
3836 lengths[i] = len;
3837 assume (h == S->m[i]);
3838 int j;
3839 for(j = 0; j <= strat->sl; j++)
3840 {
3841 if(h == strat->S[j])
3842 {
3843 int new_pos = simple_posInS (strat, h, len, wlen);
3844 if(strat->lenS)
3845 {
3846 strat->lenS[j] = len;
3847 }
3848 if(strat->lenSw)
3849 {
3850 strat->lenSw[j] = wlen;
3851 }
3852 if(new_pos < j)
3853 {
3854 move_forward_in_S (j, new_pos, strat);
3855 }
3856 else
3857 {
3858 if(new_pos > j)
3859 new_pos = new_pos - 1; //is identical with one element
3860 if(new_pos > j)
3861 move_backward_in_S (j, new_pos, strat);
3862 }
3863 break;
3864 }
3865 }
3866 }
3867 }
3868 }
3869 {
3870 int i, j;
3871 for(i = 0; i < this->n; i++)
3872 {
3873 for(j = 0; j < i; j++)
3874 {
3875 if(T_deg[i] + T_deg[j] <= upper)
3876 {
3877 now_t_rep (i, j, this);
3878 }
3879 }
3880 }
3881 }
3882 //TODO resort and update strat->S,strat->lenSw
3883 //TODO mark pairs
3884}
poly redNFTail(poly h, const int sl, kStrategy strat)
#define TEST_OPT_INTSTRATEGY
Definition options.h:112
poly p_Cleardenom(poly p, const ring r)
Definition p_polys.cc:2849
static int pLength(poly a)
Definition p_polys.h:190
static void p_Delete(poly *p, const ring r)
Definition p_polys.h:903
void pNorm(poly p)
Definition polys.h:363
void PrintS(const char *s)
Definition reporter.cc:284
static void move_forward_in_S(int old_pos, int new_pos, kStrategy strat)
Definition tgb.cc:990
static int simple_posInS(kStrategy strat, poly p, int len, wlen_type wlen)
Definition tgb.cc:1260
static wlen_type pQuality(poly p, slimgb_alg *c, int l=-1)
Definition tgb.cc:521
static void move_backward_in_S(int old_pos, int new_pos, kStrategy strat)
Definition tgb.cc:1027
void now_t_rep(const int &arg_i, const int &arg_j, slimgb_alg *c)
Definition tgb.cc:3684

◆ introduceDelayedPairs()

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

Definition at line 3166 of file tgb.cc.

3167{
3168 if(s == 0)
3169 return;
3170 sorted_pair_node **si_array =
3171 (sorted_pair_node **) omAlloc (s * sizeof (sorted_pair_node *));
3172
3173 for(int i = 0; i < s; i++)
3174 {
3175 sorted_pair_node *si =
3176 (sorted_pair_node *) omAlloc (sizeof (sorted_pair_node));
3177 si->i = -1;
3178 si->j = -2;
3179 poly p = pa[i];
3180 simplify_poly (p, r);
3181 si->expected_length = pQuality (p, this, pLength (p));
3182 p_Test (p, r);
3183 si->deg = this->pTotaldegree_full (p);
3184 /*if (!rField_is_Zp(r))
3185 {
3186 p_Content(p,r);
3187 p_Cleardenom(p,r);
3188 } */
3189
3190 si->lcm_of_lm = p;
3191
3192 // c->apairs[n-1-i]=si;
3193 si_array[i] = si;
3194 }
3195
3196 qsort (si_array, s, sizeof (sorted_pair_node *), tgb_pair_better_gen2);
3197 apairs = spn_merge (apairs, pair_top + 1, si_array, s, this);
3198 pair_top += s;
3199 omFree (si_array);
3200}
int p
Definition cfModGcd.cc:4086
int pTotaldegree_full(poly p)
static BOOLEAN pa(leftv res, leftv args)
Definition cohomo.cc:3770
#define p_Test(p, r)
Definition p_polys.h:161
static void simplify_poly(poly p, ring r)
Definition tgb.cc:59
int tgb_pair_better_gen2(const void *ap, const void *bp)
Definition tgb.cc:645
sorted_pair_node ** spn_merge(sorted_pair_node **p, int pn, sorted_pair_node **q, int qn, slimgb_alg *c)
Definition tgb.cc:716
wlen_type expected_length

◆ pTotaldegree()

unsigned long slimgb_alg::pTotaldegree ( poly p)
inline

Definition at line 271 of file tgb_internal.h.

272 {
273 pTest(p);
274 //assume(pDeg(p,r)==::p_Totaldegree(p,r));
275 assume(((unsigned long)::p_Totaldegree(p,r))==p->exp[deg_pos]);
276 return p->exp[deg_pos];
277 //return ::pTotaldegree(p,this->r);
278 }
static long p_Totaldegree(poly p, const ring r)
Definition p_polys.h:1523
#define pTest(p)
Definition polys.h:415

◆ pTotaldegree_full()

int slimgb_alg::pTotaldegree_full ( poly p)
inline

Definition at line 279 of file tgb_internal.h.

280 {
281 int rr=0;
282 while(p!=NULL)
283 {
284 int d=this->pTotaldegree(p);
285 if (d>rr) rr=d;
286 pIter(p);
287 }
288 return rr;
289 }
#define pIter(p)
Definition monomials.h:37

Field Documentation

◆ add_later

ideal slimgb_alg::add_later

Definition at line 214 of file tgb_internal.h.

◆ apairs

sorted_pair_node** slimgb_alg::apairs

Definition at line 229 of file tgb_internal.h.

◆ array_lengths

int slimgb_alg::array_lengths

Definition at line 246 of file tgb_internal.h.

◆ average_length

int slimgb_alg::average_length

Definition at line 255 of file tgb_internal.h.

◆ completed

BOOLEAN slimgb_alg::completed

Definition at line 262 of file tgb_internal.h.

◆ current_degree

int slimgb_alg::current_degree

Definition at line 248 of file tgb_internal.h.

◆ deg_pos

int slimgb_alg::deg_pos

Definition at line 258 of file tgb_internal.h.

◆ easy_product_crit

int slimgb_alg::easy_product_crit

Definition at line 253 of file tgb_internal.h.

◆ eliminationProblem

BOOLEAN slimgb_alg::eliminationProblem

Definition at line 265 of file tgb_internal.h.

◆ expandS

poly* slimgb_alg::expandS

Definition at line 226 of file tgb_internal.h.

◆ extended_product_crit

int slimgb_alg::extended_product_crit

Definition at line 254 of file tgb_internal.h.

◆ F

mp_array_list* slimgb_alg::F

Definition at line 238 of file tgb_internal.h.

◆ F4_mode

BOOLEAN slimgb_alg::F4_mode

Definition at line 266 of file tgb_internal.h.

◆ F_minus

poly_array_list* slimgb_alg::F_minus

Definition at line 239 of file tgb_internal.h.

◆ gcd_of_terms

poly* slimgb_alg::gcd_of_terms

Definition at line 227 of file tgb_internal.h.

◆ is_homog

BOOLEAN slimgb_alg::is_homog

Definition at line 263 of file tgb_internal.h.

◆ isDifficultField

BOOLEAN slimgb_alg::isDifficultField

Definition at line 261 of file tgb_internal.h.

◆ last_index

int slimgb_alg::last_index

Definition at line 250 of file tgb_internal.h.

◆ lastCleanedDeg

int slimgb_alg::lastCleanedDeg

Definition at line 257 of file tgb_internal.h.

◆ lastDpBlockStart

int slimgb_alg::lastDpBlockStart

Definition at line 256 of file tgb_internal.h.

◆ lengths

int* slimgb_alg::lengths

Definition at line 217 of file tgb_internal.h.

◆ max_pairs

int slimgb_alg::max_pairs

Definition at line 251 of file tgb_internal.h.

◆ n

int slimgb_alg::n

Definition at line 243 of file tgb_internal.h.

◆ nc

BOOLEAN slimgb_alg::nc

Definition at line 267 of file tgb_internal.h.

◆ normal_forms

int slimgb_alg::normal_forms

Definition at line 247 of file tgb_internal.h.

◆ pair_top

int slimgb_alg::pair_top

Definition at line 252 of file tgb_internal.h.

◆ r

ring slimgb_alg::r

Definition at line 216 of file tgb_internal.h.

◆ Rcounter

int slimgb_alg::Rcounter

Definition at line 249 of file tgb_internal.h.

◆ reduction_steps

unsigned int slimgb_alg::reduction_steps

Definition at line 242 of file tgb_internal.h.

◆ S

ideal slimgb_alg::S

Definition at line 215 of file tgb_internal.h.

◆ short_Exps

long* slimgb_alg::short_Exps

Definition at line 219 of file tgb_internal.h.

◆ soon_free

int_pair_node* slimgb_alg::soon_free

Definition at line 228 of file tgb_internal.h.

◆ states

char** slimgb_alg::states

Definition at line 209 of file tgb_internal.h.

◆ strat

kStrategy slimgb_alg::strat

Definition at line 220 of file tgb_internal.h.

◆ syz_comp

int slimgb_alg::syz_comp

array_lengths should be greater equal n;

Definition at line 245 of file tgb_internal.h.

◆ T_deg

int* slimgb_alg::T_deg

Definition at line 221 of file tgb_internal.h.

◆ T_deg_full

int* slimgb_alg::T_deg_full

Definition at line 222 of file tgb_internal.h.

◆ tailReductions

BOOLEAN slimgb_alg::tailReductions

Definition at line 264 of file tgb_internal.h.

◆ tmp_lm

poly slimgb_alg::tmp_lm

Definition at line 223 of file tgb_internal.h.

◆ tmp_pair_lm

poly* slimgb_alg::tmp_pair_lm

Definition at line 224 of file tgb_internal.h.

◆ tmp_spn

sorted_pair_node** slimgb_alg::tmp_spn

Definition at line 225 of file tgb_internal.h.

◆ to_destroy

poly_list_node* slimgb_alg::to_destroy

Definition at line 236 of file tgb_internal.h.

◆ use_noro

BOOLEAN slimgb_alg::use_noro

Definition at line 259 of file tgb_internal.h.

◆ use_noro_last_block

BOOLEAN slimgb_alg::use_noro_last_block

Definition at line 260 of file tgb_internal.h.

◆ weighted_lengths

wlen_type* slimgb_alg::weighted_lengths

Definition at line 218 of file tgb_internal.h.


The documentation for this class was generated from the following files: