#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 183 of file kutil.h.

Constructor & Destructor Documentation

◆ sLObject() [1/3]

KINLINE sLObject::sLObject ( ring tailRing = currRing )

Definition at line 613 of file kInline.h.

{
  Init(r);
}

◆ sLObject() [2/3]

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

Definition at line 617 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 623 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 372 of file kInline.h.

{
  if (bucket != NULL)
    kBucketCanonicalize(bucket);
}

◆ Clear()

KINLINE void sLObject::Clear ( )

Definition at line 591 of file kInline.h.

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

◆ Comp()

KINLINE long sLObject::Comp ( )

Definition at line 906 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 813 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 598 of file kInline.h.

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

◆ GetP()

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

Definition at line 763 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 874 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 747 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 378 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 605 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 701 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 721 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 891 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 358 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 915 of file kInline.h.

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

◆ pLDeg() [1/2]

KINLINE long sLObject::pLDeg ( )

Definition at line 829 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 844 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 629 of file kInline.h.

{
  if (bucket == NULL)
  {
    unsigned 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;
    }
  }
}

◆ SetDegStuffReturnLDeg() [1/2]

KINLINE long sLObject::SetDegStuffReturnLDeg ( )

Definition at line 860 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 867 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 881 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 647 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 801 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 790 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 922 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 943 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 932 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 679 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 665 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 192 of file kutil.h.

◆ checked

unsigned sLObject::checked

Definition at line 194 of file kutil.h.

◆ i_r1

int sLObject::i_r1

Definition at line 193 of file kutil.h.

◆ i_r2

int sLObject::i_r2