Loading...
Searching...
No Matches
sLObject Class Reference

`#include <kutil.h>`

## Public Member Functions

KINLINE void | Init (ring tailRing=currRing)
KINLINE | sLObject (ring tailRing=currRing)
KINLINE | sLObject (poly p, ring tailRing=currRing)
KINLINE | sLObject (poly p, ring c_r, ring tailRing)
KINLINE void | Delete ()
KINLINE void | Clear ()
KINLINE void | LmDeleteAndIter ()
KINLINE poly | LmExtractAndIter ()
KINLINE void | PrepareRed (BOOLEAN use_bucket)
KINLINE void | SetLmTail (poly lm, poly new_p, int length, int use_bucket, ring r)
KINLINE void | Tail_Minus_mm_Mult_qq (poly m, poly qq, int lq, poly spNoether)
KINLINE void | Tail_Mult_nn (number n)
KINLINE poly | GetP (omBin lmBin=(omBin) NULL)
KINLINE poly | GetTP ()
KINLINE void | CanonicalizeP ()
KINLINE void | Copy ()
KINLINE int | GetpLength ()
KINLINE long | pLDeg (BOOLEAN use_last)
KINLINE long | pLDeg ()
KINLINE int | SetLength (BOOLEAN lengt_pLength=FALSE)
KINLINE long | SetDegStuffReturnLDeg ()
KINLINE long | SetDegStuffReturnLDeg (BOOLEAN use_last)
KINLINE long | MinComp ()
KINLINE long | Comp ()
KINLINE void | ShallowCopyDelete (ring new_tailRing, pShallowCopyDeleteProc p_shallow_copy_delete)
KINLINE void | SetShortExpVector ()
KINLINE sLObject & | operator= (const sTObject &)
KINLINE TObject * | T_1 (const skStrategy *strat)
KINLINE TObject * | T_2 (const skStrategy *strat)
KINLINE void | T_1_2 (const skStrategy *strat, TObject *&T_1, TObject *&T_2)
KINLINE void | Normalize ()
KINLINE void | HeadNormalize ()
Public Member Functions inherited from sTObject
KINLINE void | Init (ring r=currRing)
KINLINE | sTObject (ring tailRing=currRing)
KINLINE | sTObject (poly p, ring tailRing=currRing)
KINLINE | sTObject (poly p, ring c_r, ring tailRing)
KINLINE | sTObject (sTObject *T, int copy)
KINLINE void | Set (ring r=currRing)
KINLINE void | Set (poly p_in, ring r=currRing)
KINLINE void | Set (poly p_in, ring c_r, ring t_r)
KINLINE void | Delete ()
KINLINE void | Clear ()
KINLINE void | Copy ()
KINLINE poly | GetLmCurrRing ()
KINLINE poly | GetLmTailRing ()
KINLINE poly | GetLm (ring r)
KINLINE void | GetLm (poly &p, ring &r) const
KINLINE BOOLEAN | IsNull () const
KINLINE int | GetpLength ()
KINLINE void | SetLmCurrRing ()
KINLINE poly | Next ()
KINLINE void | LmDeleteAndIter ()
KINLINE long | pTotalDeg () const
KINLINE long | pFDeg () const
KINLINE long | SetpFDeg ()
KINLINE long | GetpFDeg () const
KINLINE long | pLDeg ()
KINLINE long | SetDegStuffReturnLDeg ()
KINLINE void | Mult_nn (number n)
KINLINE void | ShallowCopyDelete (ring new_tailRing, omBin new_tailBin, pShallowCopyDeleteProc p_shallow_copy_delete, BOOLEAN set_max=TRUE)
KINLINE void | pNorm ()
KINLINE void | pCleardenom ()
KINLINE void | pContent ()
void | wrp ()

## Data Fields

unsigned long | sev
poly | p1
poly | p2
poly | lcm
kBucket_pt | bucket
int | i_r1
int | i_r2
unsigned | checked
BOOLEAN | prod_crit
Data Fields inherited from sTObject
unsigned long | sevSig
poly | sig
poly | p
poly | t_p
poly | max_exp
ring | tailRing
long | FDeg
int | ecart
int | length
int | pLength
int | i_r
int | shift
char | is_normalized
char | is_redundant
char | is_sigsafe
char | is_special

## Detailed Description

Definition at line 184 of file kutil.h.

## Constructor & Destructor Documentation

## sLObject() [1/3]

KINLINE sLObject::sLObject | ( | ring | tailRing = currRing | ) |

Definition at line 600 of file kInline.h.

{
Init(r);
}
sLObject::Init
KINLINE void Init(ring tailRing=currRing)
Definition kInline.h:592

## sLObject() [2/3]

KINLINE sLObject::sLObject | ( | poly | p,
|  | ring | tailRing = currRing )

Definition at line 604 of file kInline.h.

{
Init(r);
Set(p_in, r);
}
sTObject::Set
KINLINE void Set(ring r=currRing)
Definition kInline.h:106

## sLObject() [3/3]

KINLINE sLObject::sLObject | ( | poly | p,
|  | ring | c_r,
|  | ring | tailRing )

Definition at line 610 of file kInline.h.

{
Init(t_r);
Set(p_in, c_r, t_r);
}

## Member Function Documentation

## CanonicalizeP()

KINLINE void sLObject::CanonicalizeP | ( |  | ) |

Definition at line 361 of file kInline.h.

{
if (bucket != NULL)
kBucketCanonicalize(bucket);
}
sLObject::bucket
kBucket_pt bucket
Definition kutil.h:193
kBucketCanonicalize
int kBucketCanonicalize(kBucket_pt bucket)
Canonicalizes Bpoly, i.e. converts polys of buckets into one poly in one bucket: Returns number of bu...
NULL
#define NULL
Definition omList.c:12

## Clear()

KINLINE void sLObject::Clear | ( |  | ) |

Definition at line 578 of file kInline.h.

{
sTObject::Clear();
sev = 0;
}
sLObject::sev
unsigned long sev
Definition kutil.h:188
sTObject::Clear
KINLINE void Clear()
Definition kInline.h:213

## Comp()

KINLINE long sLObject::Comp | ( |  | ) |

Definition at line 896 of file kInline.h.

{
poly pp;
ring r;
GetLm(pp, r);
assume(pp != NULL);
return p_GetComp(pp, r);
}
pp
CanonicalForm FACTORY_PUBLIC pp(const CanonicalForm &)
CanonicalForm pp ( const CanonicalForm & f ).
Definition cf_gcd.cc:676
sTObject::GetLm
KINLINE poly GetLm(ring r)
Definition kInline.h:262
assume
#define assume(x)
Definition mod2.h:389
p_GetComp
#define p_GetComp(p, r)
Definition monomials.h:64

## Copy()

KINLINE void sLObject::Copy | ( |  | ) |

Definition at line 803 of file kInline.h.

{
if (bucket != NULL)
{
int i = kBucketCanonicalize(bucket);
kBucket_pt new_bucket = kBucketCreate(tailRing);
kBucketInit(new_bucket,
p_Copy(bucket->buckets[i], tailRing),
bucket->buckets_length[i]);
bucket = new_bucket;
if (t_p != NULL) pNext(t_p) = NULL;
if (p != NULL) pNext(p) = NULL;
}
TObject::Copy();
}
i
int i
Definition cfEzgcd.cc:132
sTObject::p
poly p
Definition kutil.h:74
sTObject::t_p
poly t_p
Definition kutil.h:75
sTObject::tailRing
ring tailRing
Definition kutil.h:77
kBucketInit
void kBucketInit(kBucket_pt bucket, poly lm, int length)
Definition kbuckets.cc:493
kBucketCreate
kBucket_pt kBucketCreate(const ring bucket_ring)
Creation/Destruction of buckets.
Definition kbuckets.cc:209
pNext
#define pNext(p)
Definition monomials.h:36
p_Copy
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition p_polys.h:848
kBucket_pt
kBucket * kBucket_pt
Definition ring.h:26

## Delete()

KINLINE void sLObject::Delete | ( |  | ) |

Definition at line 585 of file kInline.h.

{
sTObject::Delete();
if (bucket != NULL)
kBucketDeleteAndDestroy(&bucket);
}
sTObject::Delete
KINLINE void Delete()
Definition kInline.h:199
kBucketDeleteAndDestroy
void kBucketDeleteAndDestroy(kBucket_pt *bucket_pt)
Definition kbuckets.cc:223

## GetP()

KINLINE poly sLObject::GetP | ( | omBin | lmBin = (omBin)NULL | ) |

Definition at line 753 of file kInline.h.

{
//kTest_L(this);
if (p == NULL)
{
p = k_LmInit_tailRing_2_currRing(t_p, tailRing,
((lmBin!=NULL)?lmBin:currRing->PolyBin));
FDeg = pFDeg();
}
else if ((lmBin != NULL) && (lmBin != currRing->PolyBin))
{
p = p_LmShallowCopyDelete(p, currRing);
FDeg = pFDeg();
}
if (bucket != NULL)
{
kBucketClear(bucket, &pNext(p), &pLength);
kBucketDestroy(&bucket);
pLength++;
if (t_p != NULL) pNext(t_p) = pNext(p);
}
//kTest_L(this);
return p;
}
sTObject::pLength
int pLength
Definition kutil.h:81
sTObject::pFDeg
KINLINE long pFDeg() const
Definition kInline.h:422
sTObject::FDeg
long FDeg
Definition kutil.h:78
kBucketClear
void kBucketClear(kBucket_pt bucket, poly *p, int *length)
Definition kbuckets.cc:521
kBucketDestroy
void kBucketDestroy(kBucket_pt *bucket_pt)
Definition kbuckets.cc:216
k_LmInit_tailRing_2_currRing
KINLINE poly k_LmInit_tailRing_2_currRing(poly p, ring tailRing, omBin bin)
Definition kInline.h:968
p_LmShallowCopyDelete
static poly p_LmShallowCopyDelete(poly p, const ring r)
Definition p_polys.h:1414
currRing
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition polys.cc:13

## GetpLength()

KINLINE int sLObject::GetpLength | ( |  | ) |

Definition at line 864 of file kInline.h.

{
if (bucket == NULL)
return sTObject::GetpLength();
int i = kBucketCanonicalize(bucket);
return bucket->buckets_length[i] + 1;
}
sTObject::GetpLength
KINLINE int GetpLength()
Definition kInline.h:293

## GetTP()

KINLINE poly sLObject::GetTP | ( |  | ) |

Definition at line 737 of file kInline.h.

{
//kTest_L(this);
poly tp = GetLmTailRing();
assume(tp != NULL);
if (bucket != NULL)
{
kBucketClear(bucket, &pNext(tp), &pLength);
kBucketDestroy(&bucket);
pLength++;
}
return tp;
}
sTObject::GetLmTailRing
KINLINE poly GetLmTailRing()
Definition kInline.h:249

## HeadNormalize()

KINLINE void sLObject::HeadNormalize | ( |  | ) |

Definition at line 367 of file kInline.h.

{
if (t_p != NULL)
{
nNormalize(pGetCoeff(t_p));
if (p != NULL) pSetCoeff0(p, pGetCoeff(t_p));
}
else
{
nNormalize(pGetCoeff(p));
}
}
pSetCoeff0
#define pSetCoeff0(p, n)
Definition monomials.h:59
pGetCoeff
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
Definition monomials.h:44
nNormalize
#define nNormalize(n)
Definition numbers.h:30

## Init()

KINLINE void sLObject::Init | ( | ring | tailRing = currRing | ) |

Definition at line 592 of file kInline.h.

{
memset(this, 0, sizeof(sLObject));
i_r1 = -1;
i_r2 = -1;
i_r = -1;
Set(r);
}
sLObject::i_r1
int i_r1
Definition kutil.h:194
sLObject::sLObject
KINLINE sLObject(ring tailRing=currRing)
Definition kInline.h:600
sLObject::i_r2
int i_r2
Definition kutil.h:194
sTObject::i_r
int i_r
Definition kutil.h:82

## LmDeleteAndIter()

KINLINE void sLObject::LmDeleteAndIter | ( |  | ) |

Definition at line 691 of file kInline.h.

{
sTObject::LmDeleteAndIter();
if (bucket != NULL)
{
poly _p = kBucketExtractLm(bucket);
if (_p == NULL)
{
kBucketDestroy(&bucket);
p = t_p = NULL;
return;
}
Set(_p, tailRing);
}
else
{
pLength--;
}
}
sTObject::LmDeleteAndIter
KINLINE void LmDeleteAndIter()
Definition kInline.h:313
kBucketExtractLm
poly kBucketExtractLm(kBucket_pt bucket)
Definition kbuckets.cc:511

## LmExtractAndIter()

KINLINE poly sLObject::LmExtractAndIter | ( |  | ) |

Definition at line 711 of file kInline.h.

{
poly ret = GetLmTailRing();
poly pn;
assume(p != NULL || t_p != NULL);
if (bucket != NULL)
{
pn = kBucketExtractLm(bucket);
if (pn == NULL)
kBucketDestroy(&bucket);
}
else
{
pn = pNext(ret);
}
pLength--;
pNext(ret) = NULL;
if (p != NULL && t_p != NULL)
p_LmFree(p, currRing);
Set(pn, tailRing);
return ret;
}
p_LmFree
static void p_LmFree(poly p, ring)
Definition p_polys.h:685

## MinComp()

KINLINE long sLObject::MinComp | ( |  | ) |

Definition at line 881 of file kInline.h.

{
poly tp = GetLmTailRing();
assume(tp != NULL);
if (bucket != NULL)
{
int i = kBucketCanonicalize(bucket);
pNext(tp) = bucket->buckets[i];
long m = p_MinComp(tp, tailRing);
pNext(tp) = NULL;
return m;
}
else
return p_MinComp(tp, tailRing);
}
m
int m
Definition cfEzgcd.cc:128
p_MinComp
static long p_MinComp(poly p, ring lmRing, ring tailRing)
Definition p_polys.h:315

## Normalize()

KINLINE void sLObject::Normalize | ( |  | ) |

Definition at line 347 of file kInline.h.

{
if (t_p != NULL)
{
pNormalize(t_p);
if (p != NULL) pSetCoeff0(p, pGetCoeff(t_p));
}
else
{
pNormalize(p);
}
if (bucket!=NULL) kBucketNormalize(bucket);
}
kBucketNormalize
void kBucketNormalize(kBucket_pt bucket)
apply n_Normalize to all coefficients
pNormalize
#define pNormalize(p)
Definition polys.h:318

## operator=()

KINLINE sLObject & sLObject::operator= | ( | const sTObject & | t | ) |

Definition at line 905 of file kInline.h.

{
memcpy(this, &t, sizeof(sTObject));
return *this;
}
sTObject::sTObject
KINLINE sTObject(ring tailRing=currRing)
Definition kInline.h:116

## pLDeg() [1/2]

KINLINE long sLObject::pLDeg | ( |  | ) |

Definition at line 819 of file kInline.h.

{
poly tp = GetLmTailRing();
assume(tp != NULL);
if (bucket != NULL)
{
int i = kBucketCanonicalize(bucket);
pNext(tp) = bucket->buckets[i];
long ldeg = tailRing->pLDeg(tp, &length, tailRing);
pNext(tp) = NULL;
return ldeg;
}
else
return tailRing->pLDeg(tp, &length, tailRing);
}
sTObject::length
int length
Definition kutil.h:80

## pLDeg() [2/2]

KINLINE long sLObject::pLDeg | ( | BOOLEAN | use_last | ) |

Definition at line 834 of file kInline.h.

{
if (! deg_last || bucket != NULL) return sLObject::pLDeg();
long ldeg;
ldeg = tailRing->pLDeg(GetLmTailRing(), &length, tailRing);
#ifndef SING_NDEBUG
if ( pLength == 0)
p_Last(GetLmTailRing(), pLength, tailRing);
assume ( pLength == length || rIsSyzIndexRing(currRing));
#else
pLength=length;
#endif
return ldeg;
}
sLObject::pLDeg
KINLINE long pLDeg()
Definition kInline.h:819
p_Last
poly p_Last(const poly p, int &l, const ring r)
Definition p_polys.cc:4775
rIsSyzIndexRing
static BOOLEAN rIsSyzIndexRing(const ring r)
Definition ring.h:726

## PrepareRed()

KINLINE void sLObject::PrepareRed | ( | BOOLEAN | use_bucket | ) |

Definition at line 616 of file kInline.h.

{
if (bucket == NULL)
{
unsigned l = GetpLength();
if (use_bucket)
{
bucket = kBucketCreate(tailRing);
if (l>1)
{
poly tp = GetLmTailRing();
assume((int)l == ::pLength(tp));
kBucketInit(bucket, pNext(tp), l-1);
pNext(tp) = NULL;
if (p!=NULL) pNext(p) = NULL;
pLength = 0;
}
}
}
}
l
int l
Definition cfEzgcd.cc:100
sLObject::GetpLength
KINLINE int GetpLength()
Definition kInline.h:864

## SetDegStuffReturnLDeg() [1/2]

KINLINE long sLObject::SetDegStuffReturnLDeg | ( |  | ) |

Definition at line 850 of file kInline.h.

{
FDeg = this->pFDeg();
long d = this->pLDeg();
ecart = d - FDeg;
return d;
}
sTObject::ecart
int ecart
Definition kutil.h:79

## SetDegStuffReturnLDeg() [2/2]

KINLINE long sLObject::SetDegStuffReturnLDeg | ( | BOOLEAN | use_last | ) |

Definition at line 857 of file kInline.h.

{
FDeg = this->pFDeg();
long d = this->pLDeg(use_last);
ecart = d - FDeg;
return d;
}

## SetLength()

KINLINE int sLObject::SetLength | ( | BOOLEAN | lengt_pLength = FALSE | ) |

Definition at line 871 of file kInline.h.

{
if (length_pLength)
{
length = this->GetpLength();
}
else
this->pLDeg();
return length;
}

## SetLmTail()

KINLINE void sLObject::SetLmTail | ( | poly | lm,
|  | poly | new_p,
|  | int | length,
|  | int | use_bucket,
|  | ring | r )

Definition at line 637 of file kInline.h.

{
Set(lm, _tailRing);
if (use_bucket)
{
bucket = kBucketCreate(_tailRing);
kBucketInit(bucket, p_tail, p_Length);
pNext(lm) = NULL;
pLength = 0;
}
else
{
pNext(lm) = p_tail;
pLength = p_Length + 1;
}
}
p_Length
p_Length
Definition p_Procs_Impl.h:123

## SetShortExpVector()

KINLINE void sLObject::SetShortExpVector | ( |  | ) |

Definition at line 791 of file kInline.h.

{
if (t_p != NULL)
{
sev = p_GetShortExpVector(t_p, tailRing);
}
else
{
sev = p_GetShortExpVector(p, currRing);
}
}
p_GetShortExpVector
unsigned long p_GetShortExpVector(const poly p, const ring r)
Definition p_polys.cc:4934

## ShallowCopyDelete()

KINLINE void sLObject::ShallowCopyDelete | ( | ring | new_tailRing,
|  | pShallowCopyDeleteProc | p_shallow_copy_delete )

Definition at line 780 of file kInline.h.

{
if (bucket != NULL)
kBucketShallowCopyDelete(bucket, new_tailRing, new_tailRing->PolyBin,
p_shallow_copy_delete);
sTObject::ShallowCopyDelete(new_tailRing,
new_tailRing->PolyBin,p_shallow_copy_delete,
FALSE);
}
FALSE
#define FALSE
Definition auxiliary.h:97
sTObject::ShallowCopyDelete
KINLINE void ShallowCopyDelete(ring new_tailRing, omBin new_tailBin, pShallowCopyDeleteProc p_shallow_copy_delete, BOOLEAN set_max=TRUE)
Definition kInline.h:381
kBucketShallowCopyDelete
void kBucketShallowCopyDelete(kBucket_pt bucket, ring new_tailRing, omBin new_tailBin, pShallowCopyDeleteProc p_shallow_copy_delete)
For changing the ring of the Bpoly to new_tailBin.
Definition kbuckets.cc:535

## T_1()

KINLINE TObject * sLObject::T_1 | ( | const skStrategy * | strat | ) |

Definition at line 911 of file kInline.h.

{
if (p1 == NULL) return NULL;
if (i_r1 == -1) i_r1 = kFindInT(p1, s->T, s->tl);
assume(i_r1 >= 0 && i_r1 <= s->tl);
TObject* T = s->R[i_r1];
assume(T->p == p1);
return T;
}
sLObject::p1
poly p1
Definition kutil.h:189
s
const CanonicalForm int s
Definition facAbsFact.cc:51
T
STATIC_VAR jList * T
Definition janet.cc:30
kFindInT
int kFindInT(poly p, TSet T, int tlength)
returns index of p in TSet, or -1 if not found
Definition kutil.cc:703
TObject
class sTObject TObject
Definition kutil.h:58

## T_1_2()

KINLINE void sLObject::T_1_2 | ( | const skStrategy * | strat,
|  | TObject *& | T_1,
|  | TObject *& | T_2 )

Definition at line 932 of file kInline.h.

{
if (p1 == NULL)
{
T_1 = NULL;
T_2 = NULL;
return;
}
assume(p1 != NULL && p2 != NULL);
if (i_r1 == -1) i_r1 = kFindInT(p1, strat->T, strat->tl);
if (i_r2 == -1) i_r2 = kFindInT(p2, strat->T, strat->tl);
assume(i_r1 >= 0 && i_r1 <= strat->tl);
assume(i_r2 >= 0 && i_r2 <= strat->tl);
T_1 = strat->R[i_r1];
T_2 = strat->R[i_r2];
assume(T_1->p == p1);
assume(T_2->p == p2);
return;
}
sLObject::T_2
KINLINE TObject * T_2(const skStrategy *strat)
Definition kInline.h:921
sLObject::p2
poly p2
Definition kutil.h:189
sLObject::T_1
KINLINE TObject * T_1(const skStrategy *strat)
Definition kInline.h:911
skStrategy::T
TSet T
Definition kutil.h:325
skStrategy::R
TObject ** R
Definition kutil.h:339
skStrategy::tl
int tl
Definition kutil.h:349

## T_2()

KINLINE TObject * sLObject::T_2 | ( | const skStrategy * | strat | ) |

Definition at line 921 of file kInline.h.

{
if (p1 == NULL) return NULL;
assume(p2 != NULL);
if (i_r2 == -1) i_r2 = kFindInT(p2, strat->T, strat->tl);
assume(i_r2 >= 0 && i_r2 <= strat->tl);
TObject* T = strat->R[i_r2];
assume(T->p == p2);
return T;
}

## Tail_Minus_mm_Mult_qq()

KINLINE void sLObject::Tail_Minus_mm_Mult_qq | ( | poly | m,
|  | poly | qq,
|  | int | lq,
|  | poly | spNoether )

Definition at line 669 of file kInline.h.

{
if (bucket != NULL)
{
kBucket_Minus_m_Mult_p(bucket, m, q, &lq, spNoether);
}
else
{
if (lq<=0) lq= ::pLength(q);
poly _p = (t_p != NULL ? t_p : p);
assume(_p != NULL);
int lp=pLength-1;
pNext(_p) = p_Minus_mm_Mult_qq( pNext(_p), m, q, lp, lq,
spNoether, tailRing );
pLength=lp+1;
// tailRing->p_Procs->p_Minus_mm_Mult_qq(pNext(_p), m, q, shorter,spNoether, tailRing, last);
// pLength += lq - shorter;
}
}
kBucket_Minus_m_Mult_p
void kBucket_Minus_m_Mult_p(kBucket_pt bucket, poly m, poly p, int *l, poly spNoether)
Bpoly == Bpoly - m*p; where m is a monom Does not destroy p and m assume (*l <= 0 || pLength(p) == *l...
Definition kbuckets.cc:722
p_Minus_mm_Mult_qq
static poly p_Minus_mm_Mult_qq(poly p, const poly m, const poly q, int &lp, int lq, const poly spNoether, const ring r)
Definition p_polys.h:1077

## Tail_Mult_nn()

KINLINE void sLObject::Tail_Mult_nn | ( | number | n | ) |

Definition at line 655 of file kInline.h.

{
if (bucket != NULL)
{
kBucket_Mult_n(bucket, n);
}
else
{
poly _p = (t_p != NULL ? t_p : p);
assume(_p != NULL);
pNext(_p) = __p_Mult_nn(pNext(_p), n, tailRing);
}
}
kBucket_Mult_n
void kBucket_Mult_n(kBucket_pt bucket, number n)
Multiply Bucket by number ,i.e. Bpoly == n*Bpoly.
Definition kbuckets.cc:598
__p_Mult_nn
#define __p_Mult_nn(p, n, r)
Definition p_polys.h:973

## Field Documentation

## bucket

kBucket_pt sLObject::bucket

Definition at line 193 of file kutil.h.

## checked

unsigned sLObject::checked

Definition at line 195 of file kutil.h.

## i_r1

int sLObject::i_r1

Definition at line 194 of file kutil.h.

## i_r2

int sLObject::i_r2

Definition at line 194 of file kutil.h.

## lcm

poly sLObject::lcm

Definition at line 192 of file kutil.h.

## p1

poly sLObject::p1

Definition at line 189 of file kutil.h.

## p2

poly sLObject::p2

Definition at line 189 of file kutil.h.

## prod_crit

BOOLEAN sLObject::prod_crit

Definition at line 200 of file kutil.h.

## sev

unsigned long sLObject::sev

Definition at line 188 of file kutil.h.

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

- kernel/GBEngine/kutil.h
- kernel/GBEngine/kInline.h