A row in a matrix of bits. More...

#include <Bit_Row_defs.hh>

Public Member Functions
	Bit_Row ()
	Default constructor. More...

	Bit_Row (const Bit_Row &y)
	Copy constructor. More...

	Bit_Row (const Bit_Row &y, const Bit_Row &z)
	Set-union constructor. More...

	~Bit_Row ()
	Destructor. More...

Bit_Row &	operator= (const Bit_Row &y)
	Assignment operator. More...

void	m_swap (Bit_Row &y)
	Swaps `*this` with `y`. More...

bool	operator[] (unsigned long k) const
	Returns the truth value corresponding to the bit in position `k`. More...

void	set (unsigned long k)
	Sets the bit in position `k`. More...

void	set_until (unsigned long k)
	Sets bits up to position `k` (excluded). More...

void	clear (unsigned long k)
	Clears the bit in position `k`. More...

void	clear_from (unsigned long k)
	Clears bits from position `k` (included) onward. More...

void	clear ()
	Clears all the bits of the row. More...

void	union_assign (const Bit_Row &x, const Bit_Row &y)
	Assigns to `*this` the set-theoretic union of `x` and `y`. More...

void	intersection_assign (const Bit_Row &x, const Bit_Row &y)
	Assigns to `*this` the set-theoretic intersection of `x` and `y`. More...

void	difference_assign (const Bit_Row &x, const Bit_Row &y)
	Assigns to `*this` the set-theoretic difference of `x` and `y`. More...

unsigned long	first () const
	Returns the index of the first set bit or ULONG_MAX if no bit is set. More...

unsigned long	next (unsigned long position) const
	Returns the index of the first set bit after `position` or ULONG_MAX if no bit after `position` is set. More...

unsigned long	last () const
	Returns the index of the last set bit or ULONG_MAX if no bit is set. More...

unsigned long	prev (unsigned long position) const
	Returns the index of the first set bit before `position` or ULONG_MAX if no bits before `position` is set. More...

unsigned long	count_ones () const
	Returns the number of set bits in the row. More...

bool	empty () const
	Returns `true` if no bit is set in the row. More...

memory_size_type	total_memory_in_bytes () const
	Returns the total size in bytes of the memory occupied by `*this`. More...

memory_size_type	external_memory_in_bytes () const
	Returns the size in bytes of the memory managed by `*this`. More...

bool	OK () const
	Checks if all the invariants are satisfied. More...

Private Member Functions
void	union_helper (const Bit_Row &y, const Bit_Row &z)
	Assigns to `*this` the union of `y` and `z`. More...

Private Attributes
mpz_t	vec
	Bit-vector representing the row. More...

Friends
int	compare (const Bit_Row &x, const Bit_Row &y)

bool	operator== (const Bit_Row &x, const Bit_Row &y)

bool	operator!= (const Bit_Row &x, const Bit_Row &y)

bool	subset_or_equal (const Bit_Row &x, const Bit_Row &y)

bool	subset_or_equal (const Bit_Row &x, const Bit_Row &y, bool &strict_subset)

bool	strict_subset (const Bit_Row &x, const Bit_Row &y)

Related Functions
(Note that these are not member functions.)
int	compare (const Bit_Row &x, const Bit_Row &y)

bool	subset_or_equal (const Bit_Row &x, const Bit_Row &y)

bool	subset_or_equal (const Bit_Row &x, const Bit_Row &y, bool &strict_subset)

bool	strict_subset (const Bit_Row &x, const Bit_Row &y)

bool	operator== (const Bit_Row &x, const Bit_Row &y)

bool	operator!= (const Bit_Row &x, const Bit_Row &y)

void	swap (Bit_Row &x, Bit_Row &y)
	Swaps `x` with `y`. More...

void	iter_swap (std::vector< Bit_Row >::iterator x, std::vector< Bit_Row >::iterator y)
	Swaps objects referred by `x` and `y`. More...

bool	operator== (const Bit_Row &x, const Bit_Row &y)
	Returns `true` if and only if `x` and `y` are equal. More...

bool	operator!= (const Bit_Row &x, const Bit_Row &y)
	Returns `true` if and only if `x` and `y` are not equal. More...

int	compare (const Bit_Row &x, const Bit_Row &y)
	The basic comparison function. More...

bool	subset_or_equal (const Bit_Row &x, const Bit_Row &y)
	Set-theoretic inclusion test. More...

bool	subset_or_equal (const Bit_Row &x, const Bit_Row &y, bool &strict_subset)
	Set-theoretic inclusion test: sets `strict_subset` to a Boolean indicating whether the inclusion is strict or not. More...

bool	strict_subset (const Bit_Row &x, const Bit_Row &y)
	Set-theoretic strict inclusion test. More...

void	swap (Bit_Row &x, Bit_Row &y)

void	iter_swap (std::vector< Bit_Row >::iterator x, std::vector< Bit_Row >::iterator y)

Detailed Description

A row in a matrix of bits.

Definition at line 108 of file Bit_Row_defs.hh.

Constructor & Destructor Documentation

Parma_Polyhedra_Library::Bit_Row::Bit_Row ( )

inline

Default constructor.

Definition at line 43 of file Bit_Row_inlines.hh.

References vec.

                  {
   mpz_init(vec);
 }

Parma_Polyhedra_Library::Bit_Row::Bit_Row ( const Bit_Row & y )

inline

Copy constructor.

Definition at line 48 of file Bit_Row_inlines.hh.

References vec.

                                  {
   mpz_init_set(vec, y.vec);
 }

Parma_Polyhedra_Library::Bit_Row::Bit_Row	(	const Bit_Row &	y,
		const Bit_Row &	z
	)

inline

Set-union constructor.

Constructs an object containing the set-union of y and z.

Definition at line 53 of file Bit_Row_inlines.hh.

References PPL_BITS_PER_GMP_LIMB, union_helper(), and vec.

                                                    {
   const mp_size_t y_size = y.vec->_mp_size;
   PPL_ASSERT(y_size >= 0);
   const mp_size_t z_size = z.vec->_mp_size;
   PPL_ASSERT(z_size >= 0);
   if (y_size < z_size) {
     PPL_ASSERT(static_cast<unsigned long>(z_size)
                <= C_Integer<unsigned long>::max / PPL_BITS_PER_GMP_LIMB);
     mpz_init2(vec, static_cast<unsigned long>(z_size) * PPL_BITS_PER_GMP_LIMB);
     union_helper(y, z);
   }
   else {
     PPL_ASSERT(static_cast<unsigned long>(y_size)
                <= C_Integer<unsigned long>::max / PPL_BITS_PER_GMP_LIMB);
     mpz_init2(vec, static_cast<unsigned long>(y_size) * PPL_BITS_PER_GMP_LIMB);
     union_helper(z, y);
   }
 }

Parma_Polyhedra_Library::Bit_Row::~Bit_Row ( )

inline

Destructor.

Definition at line 73 of file Bit_Row_inlines.hh.

References vec.

                   {
   mpz_clear(vec);
 }

Member Function Documentation

void Parma_Polyhedra_Library::Bit_Row::clear ( unsigned long k )

inline

Clears the bit in position k.

Definition at line 89 of file Bit_Row_inlines.hh.

References vec.

Referenced by Parma_Polyhedra_Library::Polyhedron::BHZ09_NNC_poly_hull_assign_if_exact(), Parma_Polyhedra_Library::Polyhedron::select_H79_constraints(), and Parma_Polyhedra_Library::BD_Shape< T >::shortest_path_reduction_assign().

                                     {
   mpz_clrbit(vec, k);
 }

void Parma_Polyhedra_Library::Bit_Row::clear ( )

inline

Clears all the bits of the row.

Definition at line 116 of file Bit_Row_inlines.hh.

References vec.

                {
   mpz_set_ui(vec, 0UL);
 }

void Parma_Polyhedra_Library::Bit_Row::clear_from ( unsigned long k )

inline

Clears bits from position k (included) onward.

Definition at line 94 of file Bit_Row_inlines.hh.

References vec.

                                          {
   mpz_tdiv_r_2exp(vec, vec, k);
 }

unsigned long Parma_Polyhedra_Library::Bit_Row::count_ones ( ) const

inline

Returns the number of set bits in the row.

Definition at line 99 of file Bit_Row_inlines.hh.

References vec.

Referenced by Parma_Polyhedra_Library::Polyhedron::conversion().

                           {
   const mp_size_t x_size = vec->_mp_size;
   PPL_ASSERT(x_size >= 0);
   return (x_size == 0) ? 0 : mpn_popcount(vec->_mp_d, x_size);
 }

void Parma_Polyhedra_Library::Bit_Row::difference_assign	(	const Bit_Row &	x,
		const Bit_Row &	y
	)

inline

Assigns to *this the set-theoretic difference of x and y.

Definition at line 156 of file Bit_Row_inlines.hh.

References PPL_DIRTY_TEMP, and vec.

Referenced by Parma_Polyhedra_Library::Polyhedron::BHZ09_NNC_poly_hull_assign_if_exact().

                                                              {
   PPL_DIRTY_TEMP(mpz_class, complement_y);
   mpz_com(complement_y.get_mpz_t(), y.vec);
   mpz_and(vec, x.vec, complement_y.get_mpz_t());
 }

bool Parma_Polyhedra_Library::Bit_Row::empty ( ) const

inline

Returns true if no bit is set in the row.

Definition at line 106 of file Bit_Row_inlines.hh.

References vec.

Referenced by Parma_Polyhedra_Library::Polyhedron::BHZ09_NNC_poly_hull_assign_if_exact(), and Parma_Polyhedra_Library::Polyhedron::simplify_using_context_assign().

                      {
   return mpz_sgn(vec) == 0;
 }

memory_size_type Parma_Polyhedra_Library::Bit_Row::external_memory_in_bytes ( ) const

inline

Returns the size in bytes of the memory managed by *this.

Definition at line 121 of file Bit_Row_inlines.hh.

References vec.

Referenced by total_memory_in_bytes().

                                         {
   return static_cast<memory_size_type>(vec[0]._mp_alloc) * PPL_SIZEOF_MP_LIMB_T;
 }

unsigned long Parma_Polyhedra_Library::Bit_Row::first ( ) const

Returns the index of the first set bit or ULONG_MAX if no bit is set.

Definition at line 32 of file Bit_Row.cc.

References Parma_Polyhedra_Library::Implementation::first_one(), PPL_BITS_PER_GMP_LIMB, and vec.

Referenced by Parma_Polyhedra_Library::Polyhedron::BHZ09_NNC_poly_hull_assign_if_exact().

                         {
   const mp_size_t vec_size = vec->_mp_size;
   PPL_ASSERT(vec_size >= 0);
   mp_srcptr p = vec->_mp_d;
   for (mp_size_t li = 0; li < vec_size; ++li, ++p) {
     const mp_limb_t limb = *p;
     if (limb != 0) {
       return static_cast<unsigned long>(li) * PPL_BITS_PER_GMP_LIMB
         + Implementation::first_one(limb);
       }
   }
   return C_Integer<unsigned long>::max;
 }

void Parma_Polyhedra_Library::Bit_Row::intersection_assign	(	const Bit_Row &	x,
		const Bit_Row &	y
	)

inline

Assigns to *this the set-theoretic intersection of x and y.

Definition at line 151 of file Bit_Row_inlines.hh.

References vec.

Referenced by Parma_Polyhedra_Library::Polyhedron::BHZ09_NNC_poly_hull_assign_if_exact().

                                                                {
   mpz_and(vec, x.vec, y.vec);
 }

unsigned long Parma_Polyhedra_Library::Bit_Row::last ( ) const

Returns the index of the last set bit or ULONG_MAX if no bit is set.

Definition at line 92 of file Bit_Row.cc.

References Parma_Polyhedra_Library::Implementation::last_one(), and PPL_BITS_PER_GMP_LIMB.

Referenced by Parma_Polyhedra_Library::Bit_Matrix::OK().

                        {
   mp_size_t li = vec->_mp_size;
   PPL_ASSERT(li >= 0);
   if (li == 0) {
     return C_Integer<unsigned long>::max;
   }
   --li;
   const mp_srcptr p = vec->_mp_d + li;
   const mp_limb_t limb = *p;
   PPL_ASSERT(limb != 0);
   return static_cast<unsigned long>(li) * PPL_BITS_PER_GMP_LIMB
     + Implementation::last_one(limb);
 }

void Parma_Polyhedra_Library::Bit_Row::m_swap ( Bit_Row & y )

inline

Swaps *this with y.

Definition at line 111 of file Bit_Row_inlines.hh.

References vec.

Referenced by swap().

                           {
   mpz_swap(vec, y.vec);
 }

unsigned long Parma_Polyhedra_Library::Bit_Row::next ( unsigned long position ) const

Returns the index of the first set bit after position or ULONG_MAX if no bit after position is set.

Definition at line 47 of file Bit_Row.cc.

References Parma_Polyhedra_Library::Implementation::first_one(), and PPL_BITS_PER_GMP_LIMB.

Referenced by Parma_Polyhedra_Library::Polyhedron::BHZ09_NNC_poly_hull_assign_if_exact().

                                              {
   ++position;
 
   /*
     The alternative implementation using the mpz_scan1() function
     of GMP was measured to be slower that ours.  Here it is, in
     case mpz_scan1() is improved:
 
     <CODE>
       unsigned long r = mpz_scan1(vec, position);
       return (r == C_Integer<unsigned long>::max) ? -1 : r;
     </CODE>
   */
 
   const unsigned long uli = position / PPL_BITS_PER_GMP_LIMB;
   mp_size_t li = static_cast<mp_size_t>(uli);
   const mp_size_t vec_size = vec->_mp_size;
   PPL_ASSERT(vec_size >= 0);
   if (li >= vec_size) {
     return C_Integer<unsigned long>::max;
   }
 
   // Get the first limb.
   mp_srcptr p = vec->_mp_d + li;
 
   // Mask off any bits before `position' in the first limb.
   mp_limb_t limb
     = *p & ((~static_cast<mp_limb_t>(0)) << (position % PPL_BITS_PER_GMP_LIMB));
 
   while (true) {
     if (limb != 0) {
       return static_cast<unsigned long>(li) * PPL_BITS_PER_GMP_LIMB
         + Implementation::first_one(limb);
     }
     ++li;
     if (li == vec_size) {
       break;
     }
     ++p;
     limb = *p;
   }
   return C_Integer<unsigned long>::max;
 }

bool Parma_Polyhedra_Library::Bit_Row::OK ( ) const

Checks if all the invariants are satisfied.

Definition at line 331 of file Bit_Row.cc.

Referenced by Parma_Polyhedra_Library::Bit_Matrix::OK().

                      {
   const mp_size_t vec_size = vec->_mp_size;
   const mp_size_t vec_alloc = vec->_mp_alloc;
   return vec_size >= 0
     && vec_alloc >= vec_size
     && (vec_size == 0 || mpz_getlimbn(vec, vec_size-1) != 0);
 }

Bit_Row & Parma_Polyhedra_Library::Bit_Row::operator= ( const Bit_Row & y )

inline

Assignment operator.

Definition at line 78 of file Bit_Row_inlines.hh.

References vec.

                                    {
   mpz_set(vec, y.vec);
   return *this;
 }

bool Parma_Polyhedra_Library::Bit_Row::operator[] ( unsigned long k ) const

Returns the truth value corresponding to the bit in position k.

Definition at line 152 of file Bit_Row.cc.

                                                   {
   const mp_size_t vec_size = vec->_mp_size;
   PPL_ASSERT(vec_size >= 0);
 
   const unsigned long i = k / static_cast<unsigned long>(GMP_NUMB_BITS);
   if (i >= static_cast<unsigned long>(vec_size)) {
     return false;
   }
 
   const mp_limb_t limb = *(vec->_mp_d + i);
   return ((limb >> (k % static_cast<unsigned long>(GMP_NUMB_BITS))) & 1U) != 0;
 }

unsigned long Parma_Polyhedra_Library::Bit_Row::prev ( unsigned long position ) const

Returns the index of the first set bit before position or ULONG_MAX if no bits before position is set.

Definition at line 107 of file Bit_Row.cc.

References Parma_Polyhedra_Library::Implementation::last_one(), and PPL_BITS_PER_GMP_LIMB.

                                              {
   if (position == 0) {
     return C_Integer<unsigned long>::max;
   }
 
   --position;
 
   const mp_size_t vec_size = vec->_mp_size;
   PPL_ASSERT(vec_size > 0);
   const unsigned long uli = position / PPL_BITS_PER_GMP_LIMB;
   mp_size_t li = static_cast<mp_size_t>(uli);
 
   mp_limb_t limb;
   mp_srcptr p = vec->_mp_d;
 
   // Get the first limb.
   if (li >= vec_size) {
     li = vec_size - 1;
     p += li;
     limb = *p;
   }
   else {
     const mp_limb_t mask
       = (~static_cast<mp_limb_t>(0))
       >> (PPL_BITS_PER_GMP_LIMB - 1U - position % PPL_BITS_PER_GMP_LIMB);
     p += li;
     limb = *p & mask;
   }
 
   while (true) {
     if (limb != 0) {
       return static_cast<unsigned long>(li) * PPL_BITS_PER_GMP_LIMB
         + Implementation::last_one(limb);
       }
     if (li == 0) {
       break;
     }
     --li;
     --p;
     limb = *p;
   }
   return C_Integer<unsigned long>::max;
 }

void Parma_Polyhedra_Library::Bit_Row::set ( unsigned long k )

inline

Sets the bit in position k.

Definition at line 84 of file Bit_Row_inlines.hh.

References vec.

Referenced by Parma_Polyhedra_Library::Polyhedron::BHZ09_C_poly_hull_assign_if_exact(), Parma_Polyhedra_Library::Polyhedron::BHZ09_NNC_poly_hull_assign_if_exact(), Parma_Polyhedra_Library::Polyhedron::conversion(), Parma_Polyhedra_Library::Polyhedron::select_H79_constraints(), Parma_Polyhedra_Library::BD_Shape< T >::shortest_path_reduction_assign(), Parma_Polyhedra_Library::Polyhedron::simplify_using_context_assign(), Parma_Polyhedra_Library::Polyhedron::strongly_minimize_constraints(), and Parma_Polyhedra_Library::Polyhedron::strongly_minimize_generators().

                                   {
   mpz_setbit(vec, k);
 }

void Parma_Polyhedra_Library::Bit_Row::set_until ( unsigned long k )

Sets bits up to position k (excluded).

Definition at line 166 of file Bit_Row.cc.

Referenced by Parma_Polyhedra_Library::Polyhedron::BHZ09_C_poly_hull_assign_if_exact(), and Parma_Polyhedra_Library::Polyhedron::BHZ09_NNC_poly_hull_assign_if_exact().

                                      {
   // FIXME, TODO: this is an inefficient implementation.
   while (k-- > 0) {
     mpz_setbit(vec, k);
   }
 }

memory_size_type Parma_Polyhedra_Library::Bit_Row::total_memory_in_bytes ( ) const

inline

Returns the total size in bytes of the memory occupied by *this.

Definition at line 126 of file Bit_Row_inlines.hh.

References external_memory_in_bytes().

                                      {
   return sizeof(*this) + external_memory_in_bytes();
 }

void Parma_Polyhedra_Library::Bit_Row::union_assign	(	const Bit_Row &	x,
		const Bit_Row &	y
	)

inline

Assigns to *this the set-theoretic union of x and y.

Definition at line 131 of file Bit_Row_inlines.hh.

References PPL_BITS_PER_GMP_LIMB, union_helper(), and vec.

Referenced by Parma_Polyhedra_Library::Polyhedron::BHZ09_C_poly_hull_assign_if_exact(), Parma_Polyhedra_Library::Polyhedron::BHZ09_NNC_poly_hull_assign_if_exact(), and Parma_Polyhedra_Library::Polyhedron::strongly_minimize_constraints().

                                                         {
   const mp_size_t x_size = x.vec->_mp_size;
   PPL_ASSERT(x_size >= 0);
   const mp_size_t y_size = y.vec->_mp_size;
   PPL_ASSERT(y_size >= 0);
   if (x_size < y_size) {
     PPL_ASSERT(static_cast<unsigned long>(y_size)
                <= C_Integer<unsigned long>::max / PPL_BITS_PER_GMP_LIMB);
     mpz_realloc2(vec, static_cast<unsigned long>(y_size) * PPL_BITS_PER_GMP_LIMB);
     union_helper(x, y);
   }
   else {
     PPL_ASSERT(static_cast<unsigned long>(x_size)
                <= C_Integer<unsigned long>::max / PPL_BITS_PER_GMP_LIMB);
     mpz_realloc2(vec, static_cast<unsigned long>(x_size) * PPL_BITS_PER_GMP_LIMB);
     union_helper(y, x);
   }
 }

void Parma_Polyhedra_Library::Bit_Row::union_helper	(	const Bit_Row &	y,
		const Bit_Row &	z
	)

private

Assigns to *this the union of y and z.

The size of y must be be less than or equal to the size of z. Upon entry, vec must have allocated enough space to contain the result.

Definition at line 340 of file Bit_Row.cc.

References vec.

Referenced by Bit_Row(), and union_assign().

                                                            {
   mp_size_t y_size = y.vec->_mp_size;
   mp_size_t z_size = z.vec->_mp_size;
   PPL_ASSERT(y_size <= z_size);
   PPL_ASSERT(vec->_mp_alloc >= z_size);
   vec->_mp_size = z.vec->_mp_size;
   mp_srcptr yp = y.vec->_mp_d;
   mp_srcptr zp = z.vec->_mp_d;
   mp_ptr p = vec->_mp_d;
   z_size -= y_size;
   while (y_size > 0) {
     *p = *yp | * zp;
     ++yp;
     ++zp;
     ++p;
     --y_size;
   }
   while (z_size > 0) {
     *p = *zp;
     ++zp;
     ++p;
     --z_size;
   }
 }

Friends And Related Function Documentation

int compare	(	const Bit_Row &	x,
		const Bit_Row &	y
	)

Compares x with y starting from the least significant bits. The ordering is total and has the following property: if x and y are two rows seen as sets of naturals, if x is a strict subset of y, then x comes before y.

Returns

-1 if x comes before y in the ordering;
0 if x and y are equal;
1 if x comes after y in the ordering.

int compare	(	const Bit_Row &	x,
		const Bit_Row &	y
	)

friend

int compare	(	const Bit_Row &	x,
		const Bit_Row &	y
	)

References vec.

                                                {
   const mp_size_t x_size = x.vec->_mp_size;
   PPL_ASSERT(x_size >= 0);
   const mp_size_t y_size = y.vec->_mp_size;
   PPL_ASSERT(y_size >= 0);
   mp_size_t size = ((x_size > y_size) ? y_size : x_size);
   mp_srcptr xp = x.vec->_mp_d;
   mp_srcptr yp = y.vec->_mp_d;
   while (size > 0) {
     const mp_limb_t xl = *xp;
     const mp_limb_t yl = *yp;
     if (xl != yl) {
       // Get the ones where they are different.
       const mp_limb_t diff = xl ^ yl;
       // First bit that is different.
       const mp_limb_t mask = diff & ~(diff-1);
       return ((xl & mask) != 0) ? 1 : -1;
     }
     ++xp;
     ++yp;
     --size;
   }
   return (x_size == y_size) ? 0 : ((x_size > y_size) ? 1 : -1);
 }

void iter_swap	(	std::vector< Bit_Row >::iterator	x,
		std::vector< Bit_Row >::iterator	y
	)

void iter_swap	(	std::vector< Bit_Row >::iterator	x,
		std::vector< Bit_Row >::iterator	y
	)

References Parma_Polyhedra_Library::swap().

                                         {
   swap(*x, *y);
 }

bool operator!=	(	const Bit_Row &	x,
		const Bit_Row &	y
	)

bool operator!=	(	const Bit_Row &	x,
		const Bit_Row &	y
	)

friend

bool operator!=	(	const Bit_Row &	x,
		const Bit_Row &	y
	)

References vec.

                                                   {
   const mp_size_t x_vec_size = x.vec->_mp_size;
   PPL_ASSERT(x_vec_size >= 0);
   const mp_size_t y_vec_size = y.vec->_mp_size;
   PPL_ASSERT(y_vec_size >= 0);
 
   if (x_vec_size != y_vec_size) {
     return true;
   }
 
   return mpn_cmp(x.vec->_mp_d, y.vec->_mp_d, x_vec_size) != 0;
 }

bool operator==	(	const Bit_Row &	x,
		const Bit_Row &	y
	)

bool operator==	(	const Bit_Row &	x,
		const Bit_Row &	y
	)

friend

bool operator==	(	const Bit_Row &	x,
		const Bit_Row &	y
	)

References vec.

                                                   {
   const mp_size_t x_vec_size = x.vec->_mp_size;
   PPL_ASSERT(x_vec_size >= 0);
   const mp_size_t y_vec_size = y.vec->_mp_size;
   PPL_ASSERT(y_vec_size >= 0);
 
   if (x_vec_size != y_vec_size) {
     return false;
   }
 
   return mpn_cmp(x.vec->_mp_d, y.vec->_mp_d, x_vec_size) == 0;
 }

bool strict_subset	(	const Bit_Row &	x,
		const Bit_Row &	y
	)

bool strict_subset	(	const Bit_Row &	x,
		const Bit_Row &	y
	)

friend

bool strict_subset	(	const Bit_Row &	x,
		const Bit_Row &	y
	)

References vec.

                                                      {
   mp_size_t x_size = x.vec->_mp_size;
   PPL_ASSERT(x_size >= 0);
   const mp_size_t y_size = y.vec->_mp_size;
   PPL_ASSERT(y_size >= 0);
   if (x_size > y_size) {
     return false;
   }
   bool different = (x_size < y_size);
   mp_srcptr xp = x.vec->_mp_d;
   mp_srcptr yp = y.vec->_mp_d;
   while (x_size > 0) {
     const mp_limb_t xl = *xp;
     const mp_limb_t yl = *yp;
     if ((xl & ~yl) != 0) {
       return false;
     }
     if (!different && xl != yl) {
       different = true;
     }
     ++xp;
     ++yp;
     --x_size;
   }
   return different;
 }

bool subset_or_equal	(	const Bit_Row &	x,
		const Bit_Row &	y
	)

bool subset_or_equal	(	const Bit_Row &	x,
		const Bit_Row &	y,
		bool &	strict_subset
	)

bool subset_or_equal	(	const Bit_Row &	x,
		const Bit_Row &	y
	)

friend

bool subset_or_equal	(	const Bit_Row &	x,
		const Bit_Row &	y,
		bool &	strict_subset
	)

friend

bool subset_or_equal	(	const Bit_Row &	x,
		const Bit_Row &	y
	)

References vec.

                                                        {
   mp_size_t x_size = x.vec->_mp_size;
   PPL_ASSERT(x_size >= 0);
   const mp_size_t y_size = y.vec->_mp_size;
   PPL_ASSERT(y_size >= 0);
   if (x_size > y_size) {
     return false;
   }
   mp_srcptr xp = x.vec->_mp_d;
   mp_srcptr yp = y.vec->_mp_d;
   while (x_size > 0) {
     if ((*xp & ~*yp) != 0) {
       return false;
     }
     ++xp;
     ++yp;
     --x_size;
   }
   return true;
 }

bool subset_or_equal	(	const Bit_Row &	x,
		const Bit_Row &	y,
		bool &	strict_subset
	)

References vec.

                                           {
   mp_size_t x_size = x.vec->_mp_size;
   PPL_ASSERT(x_size >= 0);
   const mp_size_t y_size = y.vec->_mp_size;
   PPL_ASSERT(y_size >= 0);
   if (x_size > y_size) {
     return false;
   }
   mp_srcptr xp = x.vec->_mp_d;
   mp_srcptr yp = y.vec->_mp_d;
   strict_subset = (x_size < y_size);
   mp_limb_t xl;
   mp_limb_t yl;
   if (strict_subset) {
     while (x_size > 0) {
       xl = *xp;
       yl = *yp;
       if ((xl & ~yl) != 0) {
         return false;
       }
     strict_subset_next:
       ++xp;
       ++yp;
       --x_size;
     }
   }
   else {
     while (x_size > 0) {
       xl = *xp;
       yl = *yp;
       if (xl != yl) {
         if ((xl & ~yl) != 0) {
           return false;
         }
         strict_subset = true;
         goto strict_subset_next;
       }
       ++xp;
       ++yp;
       --x_size;
     }
   }
   return true;
 }

void swap	(	Bit_Row &	x,
		Bit_Row &	y
	)

void swap	(	Bit_Row &	x,
		Bit_Row &	y
	)

References m_swap().

                              {
   x.m_swap(y);
 }

Member Data Documentation

mpz_t Parma_Polyhedra_Library::Bit_Row::vec

private

Bit-vector representing the row.

Definition at line 202 of file Bit_Row_defs.hh.

Referenced by Bit_Row(), clear(), clear_from(), compare(), count_ones(), difference_assign(), empty(), external_memory_in_bytes(), first(), intersection_assign(), m_swap(), operator!=(), operator=(), operator==(), set(), strict_subset(), subset_or_equal(), union_assign(), union_helper(), and ~Bit_Row().

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

Public Member Functions

Private Member Functions

Private Attributes

Friends

Related Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation