#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() [2/3]

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

Definition at line 604 of file kInline.h.

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

◆ 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);
}

◆ Clear()

KINLINE void sLObject::Clear ( )

Definition at line 578 of file kInline.h.

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

◆ 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);
}

◆ 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();
}

◆ Delete()

KINLINE void sLObject::Delete ( )

Definition at line 585 of file kInline.h.

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

◆ 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;
}

◆ 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;
}

◆ 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;
}

◆ 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));
  }
}

◆ 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);
}

◆ 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--;
  }
}

◆ 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;
}

◆ 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);
}

◆ 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);
}

◆ operator=()

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

Definition at line 905 of file kInline.h.

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

◆ 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);
}

◆ 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;
}

◆ 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;
      }
    }
  }
}

◆ 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;
}

◆ 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;
  }
}

◆ 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);
  }
}

◆ 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);
}

◆ 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;
}

◆ 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;
}

◆ 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;
  }
}

◆ 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);
  }
}

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