sbuckets.cc File Reference

#include "omalloc/omalloc.h"
#include "misc/auxiliary.h"
#include "polys/sbuckets.h"
#include "polys/monomials/ring.h"
#include "polys/monomials/p_polys.h"

Go to the source code of this file.

Data Structures
class	sBucketPoly
class	sBucket

Functions
ring	sBucketGetRing (const sBucket_pt bucket)
	Returns bucket ring. More...
bool	sIsEmpty (const sBucket_pt bucket)
	Test whether bucket is empty!? More...
sBucket_pt	sBucketCopy (const sBucket_pt bucket)
	Copy sBucket non-intrusive!!! More...
sBucket_pt	sBucketCreate (const ring r)
void	sBucketDestroy (sBucket_pt *bucket)
void	sBucketDeleteAndDestroy (sBucket_pt *bucket_pt)
void	sBucket_Merge_m (sBucket_pt bucket, poly p)
void	sBucket_Merge_p (sBucket_pt bucket, poly p, int length)
	Merges p into Spoly: assumes Bpoly and p have no common monoms destroys p! More...
void	sBucket_Add_m (sBucket_pt bucket, poly p)
void	sBucket_Add_p (sBucket_pt bucket, poly p, int length)
	adds poly p to bucket destroys p! More...
void	sBucketClearMerge (sBucket_pt bucket, poly *p, int *length)
void	sBucketClearAdd (sBucket_pt bucket, poly *p, int *length)
poly	sBucketSortMerge (poly p, const ring r)
	Sorts p with bucketSort: assumes all monomials of p are different. More...
poly	sBucketSortAdd (poly p, const ring r)
	Sorts p with bucketSort: p may have equal monomials. More...

Variables
static omBin	sBucket_bin = omGetSpecBin(sizeof(sBucket))

---

Data Structure Documentation

sBucketPoly

class sBucketPoly

Definition at line 26 of file sbuckets.cc.

Data Fields
long	length
poly	p

sBucket

class sBucket

Definition at line 33 of file sbuckets.cc.

Data Fields
ring	bucket_ring
sBucketPoly	buckets[BIT_SIZEOF_LONG - 3]
long	max_bucket

Function Documentation

sBucket_Add_m()

void sBucket_Add_m	(	sBucket_pt	bucket,
		poly	p
	)

Definition at line 176 of file sbuckets.cc.

{
  assume(bucket != NULL);
  assume(1 == pLength(p));
 
  int length = 1;
 
  int i = 0; //SI_LOG2(length);
 
  while (bucket->buckets[i].p != NULL)
  {
    int shorter;
    p = bucket->bucket_ring->p_Procs->p_Add_q(p, bucket->buckets[i].p,
                shorter, bucket->bucket_ring);
    length+=bucket->buckets[i].length-shorter;
    bucket->buckets[i].p = NULL;
    bucket->buckets[i].length = 0;
    if (p==NULL)
    {
      if (i > bucket->max_bucket) bucket->max_bucket = i;
      return;
    }
    i = SI_LOG2(length);
  }
 
  bucket->buckets[i].p = p;
  bucket->buckets[i].length = length;
  if (i > bucket->max_bucket) bucket->max_bucket = i;
}

sBucket_Add_p()

void sBucket_Add_p	(	sBucket_pt	bucket,
		poly	p,
		int	length
	)

adds poly p to bucket destroys p!

Definition at line 206 of file sbuckets.cc.

{
  assume(bucket != NULL);
  assume(length <= 0 || length == pLength(p));
 
  if (p == NULL) return;
  if (length <= 0) length = pLength(p);
 
  int i = SI_LOG2(length);
 
  while (bucket->buckets[i].p != NULL)
  {
    int shorter;
    p = bucket->bucket_ring->p_Procs->p_Add_q(p, bucket->buckets[i].p, shorter,
                bucket->bucket_ring);
    length+= bucket->buckets[i].length-shorter;
    bucket->buckets[i].p = NULL;
    bucket->buckets[i].length = 0;
    if (p==NULL)
    {
      if (i > bucket->max_bucket) bucket->max_bucket = i;
      return;
    }
    i = SI_LOG2(length);
  }
 
  bucket->buckets[i].p = p;
  bucket->buckets[i].length = length;
  if (i > bucket->max_bucket) bucket->max_bucket = i;
}

sBucket_Merge_m()

void sBucket_Merge_m	(	sBucket_pt	bucket,
		poly	p
	)

Definition at line 130 of file sbuckets.cc.

{
  assume(p != NULL && pNext(p) == NULL);
  int length = 1;
  int i = 0;
 
  while (bucket->buckets[i].p != NULL)
  {
    p = p_Merge_q(p, bucket->buckets[i].p, bucket->bucket_ring);
    length += bucket->buckets[i].length;
    bucket->buckets[i].p = NULL;
    bucket->buckets[i].length = 0;
    i++;
    assume(SI_LOG2(length) == i);
  }
 
  bucket->buckets[i].p = p;
  bucket->buckets[i].length = length;
  if (i > bucket->max_bucket) bucket->max_bucket = i;
}

sBucket_Merge_p()

void sBucket_Merge_p	(	sBucket_pt	bucket,
		poly	p,
		int	length
	)

Merges p into Spoly: assumes Bpoly and p have no common monoms destroys p!

Definition at line 151 of file sbuckets.cc.

{
  assume(bucket != NULL);
  assume(length <= 0 || length == pLength(p));
 
  if (p == NULL) return;
  if (length <= 0) length = pLength(p);
 
  int i = SI_LOG2(length);
 
  while (bucket->buckets[i].p != NULL)
  {
    p = p_Merge_q(p, bucket->buckets[i].p, bucket->bucket_ring);
    length += bucket->buckets[i].length;
    bucket->buckets[i].p = NULL;
    bucket->buckets[i].length = 0;
    i++;
    assume(SI_LOG2(length) == i);
  }
 
  bucket->buckets[i].p = p;
  bucket->buckets[i].length = length;
  if (i > bucket->max_bucket) bucket->max_bucket = i;
}

sBucketClearAdd()

void sBucketClearAdd	(	sBucket_pt	bucket,
		poly *	p,
		int *	length
	)

Definition at line 277 of file sbuckets.cc.

{
  poly pr = NULL;
  int  lr = 0;
  int i = 0;
 
  while (bucket->buckets[i].p == NULL)
  {
    assume( bucket->buckets[i].length == 0 );
    i++;
    if (i > bucket->max_bucket) goto done;
  }
 
  pr = bucket->buckets[i].p;
  lr = bucket->buckets[i].length;
 
  assume( pr != NULL && (lr > 0) );
 
  bucket->buckets[i].p = NULL;
  bucket->buckets[i].length = 0;
  i++;
 
  while (i <= bucket->max_bucket)
  {
    if (bucket->buckets[i].p != NULL)
    {
      assume( bucket->buckets[i].length == pLength(bucket->buckets[i].p) );
 
      pr = p_Add_q(pr, bucket->buckets[i].p, lr, bucket->buckets[i].length,
                   bucket->bucket_ring);
 
      bucket->buckets[i].p = NULL;
      bucket->buckets[i].length = 0;
    }
 
    assume( bucket->buckets[i].p == NULL );
    assume( bucket->buckets[i].length == 0 );
    i++;
  }
 
done:
 
  *p = pr;
  *length = lr;
 
  bucket->max_bucket = 0;
 
  assume( sIsEmpty(bucket) );
}

sBucketClearMerge()

void sBucketClearMerge	(	sBucket_pt	bucket,
		poly *	p,
		int *	length
	)

Definition at line 239 of file sbuckets.cc.

{
  poly pr = NULL;
  int  lr = 0;
  int i = 0;
 
  while (bucket->buckets[i].p == NULL)
  {
    i++;
    if (i > bucket->max_bucket) goto done;
  }
 
  pr = bucket->buckets[i].p;
  lr = bucket->buckets[i].length;
  bucket->buckets[i].p = NULL;
  bucket->buckets[i].length = 0;
  i++;
 
  while (i <= bucket->max_bucket)
  {
    if (bucket->buckets[i].p != NULL)
    {
      pr = p_Merge_q(pr, bucket->buckets[i].p,bucket->bucket_ring);
      lr += bucket->buckets[i].length;
      bucket->buckets[i].p = NULL;
      bucket->buckets[i].length = 0;
    }
    i++;
  }
 
  done:
  *p = pr;
  *length = lr;
  bucket->max_bucket = 0;
}

sBucketCopy()

sBucket_pt sBucketCopy

(

const sBucket_pt

bucket

)

Copy sBucket non-intrusive!!!

Definition at line 74 of file sbuckets.cc.

{
  const ring r = bucket->bucket_ring;
 
  sBucket_pt newbucket = sBucketCreate(r);
 
  newbucket->max_bucket = bucket->max_bucket;
 
  for(int i = 0; i <= bucket->max_bucket; i++)
  {
    assume( i < (BIT_SIZEOF_LONG - 3) );
    assume( pLength(bucket->buckets[i].p) == bucket->buckets[i].length );
 
    newbucket->buckets[i].p = p_Copy(bucket->buckets[i].p, r);
    newbucket->buckets[i].length = bucket->buckets[i].length;
 
    assume( pLength(newbucket->buckets[i].p) == newbucket->buckets[i].length );
  }
 
  return newbucket;
}

sBucketCreate()

sBucket_pt sBucketCreate

(

const ring

r

)

Definition at line 99 of file sbuckets.cc.

{
  sBucket_pt bucket = (sBucket_pt) omAlloc0Bin(sBucket_bin);
  bucket->bucket_ring = r;
  return bucket;
}

sBucketDeleteAndDestroy()

void sBucketDeleteAndDestroy

(

sBucket_pt *

bucket_pt

)

Definition at line 113 of file sbuckets.cc.

{
  sBucket_pt bucket = *bucket_pt;
  int i;
  for (i=0; i<= bucket->max_bucket; i++)
  {
    p_Delete(&(bucket->buckets[i].p), bucket->bucket_ring);
  }
  omFreeBin(bucket, sBucket_bin);
  *bucket_pt = NULL;
}

sBucketDestroy()

void sBucketDestroy

(

sBucket_pt *

bucket

)

Definition at line 106 of file sbuckets.cc.

{
  assume(bucket != NULL);
  omFreeBin(*bucket, sBucket_bin);
  *bucket = NULL;
}

sBucketGetRing()

ring sBucketGetRing

(

const sBucket_pt

bucket

)

Returns bucket ring.

Definition at line 50 of file sbuckets.cc.

{ return bucket->bucket_ring; }

sBucketSortAdd()

poly sBucketSortAdd	(	poly	p,
		const ring	r
	)

Sorts p with bucketSort: p may have equal monomials.

Definition at line 368 of file sbuckets.cc.

{
#ifndef SING_NDEBUG
  int l_in = pLength(p);
#endif
 
  if (p == NULL || pNext(p) == NULL) return p;
 
  sBucket_pt bucket = sBucketCreate(r);
  poly pn = pNext(p);
 
  do
  {
    pNext(p) = NULL;
    sBucket_Add_m(bucket, p);
    p = pn;
    if (p == NULL) break;
    pn = pNext(pn);
  }
  while (1);
 
  int l_dummy;
  sBucketClearAdd(bucket, &pn, &l_dummy);
  sBucketDestroy(&bucket);
 
  p_Test(pn, r);
#ifndef SING_NDEBUG
  assume(l_dummy == pLength(pn));
  assume(l_in >= l_dummy);
#endif
  return pn;
}

sBucketSortMerge()

poly sBucketSortMerge	(	poly	p,
		const ring	r
	)

Sorts p with bucketSort: assumes all monomials of p are different.

Definition at line 334 of file sbuckets.cc.

{
  if (p == NULL || pNext(p) == NULL) return p;
 
#ifndef SING_NDEBUG
  int l_in = pLength(p);
#endif  
  sBucket_pt bucket = sBucketCreate(r);
  poly pn = pNext(p);
 
  do
  {
    pNext(p) = NULL;
    sBucket_Merge_m(bucket, p);
    p = pn;
    if (p == NULL) break;
    pn = pNext(pn);
  }
  while (1);
 
  int l_dummy;
  sBucketClearMerge(bucket, &pn, &l_dummy);
  sBucketDestroy(&bucket);
 
  p_Test(pn, r);
  assume(l_dummy == pLength(pn));
  assume(l_in == l_dummy);
  return pn;
}

sIsEmpty()

bool sIsEmpty

(

const sBucket_pt

bucket

)

Test whether bucket is empty!?

Definition at line 54 of file sbuckets.cc.

{
  for(int i = 0; i < (BIT_SIZEOF_LONG - 3); i++)
  {
    assume( i < (BIT_SIZEOF_LONG - 3) );
    assume( pLength(bucket->buckets[i].p) == bucket->buckets[i].length );
 
    if( bucket->buckets[i].p != NULL )
      return false;
 
    if( bucket->buckets[i].length != 0 )
      return false;
  }
 
  return( bucket->max_bucket == 0 );
 
}

Variable Documentation

sBucket_bin

omBin sBucket_bin = omGetSpecBin(sizeof(sBucket))

static

Definition at line 42 of file sbuckets.cc.