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=NULL)
KINLINE poly	GetTP ()
KINLINE poly	CanonicalizeP ()
KINLINE void	Copy ()
KINLINE poly	CopyGetP ()
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 ()

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
ring	tailRing
long	FDeg
int	ecart
int	length
int	pLength
int	i_r
BOOLEAN	is_normalized
BOOLEAN	is_redundant
BOOLEAN	is_sigsafe
BOOLEAN	is_special

Detailed Description

Definition at line 179 of file kutil.h.

Constructor & Destructor Documentation

KINLINE sLObject::sLObject

(

ring

tailRing = currRing

)

Definition at line 514 of file kInline.h.

{
  Init(r);
}

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

Definition at line 518 of file kInline.h.

{
  Init(r);
  Set(p_in, r);
}

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

Definition at line 524 of file kInline.h.

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

Member Function Documentation

KINLINE poly sLObject::CanonicalizeP

(

)

Definition at line 648 of file kInline.h.

{
  //kTest_L(this);
  int i = -1;

  if (bucket != NULL)
    i = kBucketCanonicalize(bucket);

  if (p == NULL)
    p = k_LmInit_tailRing_2_currRing(t_p, tailRing);

  if (i >= 0) pNext(p) = bucket->buckets[i];
  return p;
}

KINLINE void sLObject::Clear

(

)

Definition at line 493 of file kInline.h.

{
  sTObject::Clear();
  sev = 0;
}

KINLINE long sLObject::Comp

(

)

Definition at line 841 of file kInline.h.

{
  poly pp;
  ring r;
  GetLm(pp, r);
  assume(pp != NULL);
  return p_GetComp(pp, r);
}

KINLINE void sLObject::Copy

(

)

Definition at line 729 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();
}

KINLINE poly sLObject::CopyGetP

(

)

Definition at line 745 of file kInline.h.

{
  if (bucket != NULL)
  {
    int i = kBucketCanonicalize(bucket);
    poly bp = p_Copy(bucket->buckets[i], tailRing);
    pLength = bucket->buckets_length[i] + 1;
    if (bp != NULL)
    {
      assume(t_p != NULL || p != NULL);
      if (t_p != NULL) pNext(t_p) = bp;
      else pNext(p) = bp;
    }
    bucket = NULL;
  }
  return sLObject::GetP();
}

KINLINE void sLObject::Delete

(

)

Definition at line 499 of file kInline.h.

{
  sTObject::Delete();
  if (bucket != NULL)
    kBucketDeleteAndDestroy(&bucket);
}

KINLINE poly sLObject::GetP

(

omBin

lmBin = NULL

)

Definition at line 679 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;
}

KINLINE int sLObject::GetpLength

(

)

Definition at line 809 of file kInline.h.

{
  if (bucket == NULL)
    return sTObject::GetpLength();
  int i = kBucketCanonicalize(bucket);
  return bucket->buckets_length[i] + 1;
}

KINLINE poly sLObject::GetTP

(

)

Definition at line 663 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;
}

KINLINE void sLObject::HeadNormalize

(

)

Definition at line 334 of file kInline.h.

{
  if (t_p != NULL)
  {
    nNormalize(pGetCoeff(t_p));
    if (p != NULL) pSetCoeff0(p, pGetCoeff(t_p));
  }
  else
  {
    nNormalize(pGetCoeff(p));
  }
}

KINLINE void sLObject::Init

(

ring

tailRing = currRing

)

Definition at line 506 of file kInline.h.

{
  memset(this, 0, sizeof(sLObject));
  i_r1 = -1;
  i_r2 = -1;
  i_r = -1;
  Set(r);
}

KINLINE void sLObject::LmDeleteAndIter

(

)

Definition at line 602 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--;
  }
}

KINLINE poly sLObject::LmExtractAndIter

(

)

Definition at line 622 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;
}

KINLINE long sLObject::MinComp

(

)

Definition at line 826 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);
}

KINLINE void sLObject::Normalize

(

)

Definition at line 321 of file kInline.h.

{
  if (t_p != NULL)
  {
    pNormalize(t_p);
    if (p != NULL) pSetCoeff0(p, pGetCoeff(t_p));
  }
  else
  {
    pNormalize(p);
  }
}

KINLINE sLObject & sLObject::operator=

(

const sTObject &

t

)

Definition at line 850 of file kInline.h.

{
  memset(this, 0, sizeof(*this));
  memcpy(this, &t, sizeof(sTObject));
  return *this;
}

KINLINE long sLObject::pLDeg

(

BOOLEAN

use_last

)

Definition at line 779 of file kInline.h.

{
  if (! deg_last || bucket != NULL) return sLObject::pLDeg();

  long ldeg;
  ldeg = tailRing->pLDeg(GetLmTailRing(), &length, tailRing);
#ifdef HAVE_ASSUME
  if ( pLength == 0)
    p_Last(GetLmTailRing(), pLength, tailRing);
  assume ( pLength == length || rIsSyzIndexRing(currRing));
#else
  pLength=length;
#endif
  return ldeg;
}

KINLINE long sLObject::pLDeg

(

)

Definition at line 764 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);
}

KINLINE void sLObject::PrepareRed

(

BOOLEAN

use_bucket

)

Definition at line 530 of file kInline.h.

{
  if (bucket == NULL)
  {
    int l = GetpLength();
    if (use_bucket && (l > 1))
    {
      poly tp = GetLmTailRing();
      assume(l == ::pLength(tp));
      bucket = kBucketCreate(tailRing);
      kBucketInit(bucket, pNext(tp), l-1);
      pNext(tp) = NULL;
      if (p != NULL) pNext(p) = NULL;
      pLength = 0;
    }
  }
}

KINLINE long sLObject::SetDegStuffReturnLDeg

(

)

Definition at line 795 of file kInline.h.

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

KINLINE long sLObject::SetDegStuffReturnLDeg

(

BOOLEAN

use_last

)

Definition at line 802 of file kInline.h.

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

KINLINE int sLObject::SetLength

(

BOOLEAN

lengt_pLength = FALSE

)

Definition at line 816 of file kInline.h.

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

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

Definition at line 548 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;
  }
}

KINLINE void sLObject::SetShortExpVector

(

)

Definition at line 717 of file kInline.h.

{
  if (t_p != NULL)
  {
    sev = p_GetShortExpVector(t_p, tailRing);
  }
  else
  {
    sev = p_GetShortExpVector(p, currRing);
  }
}

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

Definition at line 706 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);
}

KINLINE TObject * sLObject::T_1

(

const skStrategy *

strat

)

Definition at line 857 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;
}

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

Definition at line 878 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;
}

KINLINE TObject * sLObject::T_2

(

const skStrategy *

strat

)

Definition at line 867 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;
}

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

Definition at line 580 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;
  }
}

KINLINE void sLObject::Tail_Mult_nn

(

number

n

)

Definition at line 566 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);
  }
}

Field Documentation

kBucket_pt sLObject::bucket

Definition at line 188 of file kutil.h.

unsigned sLObject::checked

Definition at line 190 of file kutil.h.

int sLObject::i_r1

Definition at line 189 of file kutil.h.

int sLObject::i_r2

Definition at line 189 of file kutil.h.

poly sLObject::lcm

Definition at line 187 of file kutil.h.

poly sLObject::p1

Definition at line 184 of file kutil.h.

poly sLObject::p2

Definition at line 184 of file kutil.h.

BOOLEAN sLObject::prod_crit

Definition at line 195 of file kutil.h.

unsigned long sLObject::sev

Definition at line 183 of file kutil.h.

---

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

• kernel/GBEngine/kutil.h
• kernel/GBEngine/kInline.h