Parma_Polyhedra_Library::Bit_Row Class Reference
[C++ Language Interface]

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

#include <Bit_Row.defs.hh>

List of all members.

Public Member Functions

 Bit_Row ()
 Default constructor.
 Bit_Row (const Bit_Row &y)
 Copy constructor.
 Bit_Row (const Bit_Row &y, const Bit_Row &z)
 Set-union constructor.
 ~Bit_Row ()
 Destructor.
Bit_Rowoperator= (const Bit_Row &y)
 Assignment operator.
void swap (Bit_Row &y)
 Swaps *this with y.
bool operator[] (unsigned long k) const
 Returns the truth value corresponding to the bit in position k.
void set (unsigned long k)
 Sets the bit in position k.
void set_until (unsigned long k)
 Sets bits up to position k (excluded).
void clear (unsigned long k)
 Clears the bit in position k.
void clear_from (unsigned long k)
 Clears bits from position k (included) onward.
void clear ()
 Clears all the bits of the row.
unsigned long first () const
 Returns the index of the first set bit or ULONG_MAX if no bit is set.
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.
unsigned long last () const
 Returns the index of the last set bit or ULONG_MAX if no bit is set.
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.
unsigned long count_ones () const
 Returns the number of set bits in the row.
bool empty () const
 Returns true if no bit is set in the row.
memory_size_type total_memory_in_bytes () const
 Returns the total size in bytes of the memory occupied by *this.
memory_size_type external_memory_in_bytes () const
 Returns the size in bytes of the memory managed by *this.
bool OK () const
 Checks if all the invariants are satisfied.

Private Member Functions

void union_helper (const Bit_Row &x, const Bit_Row &y)
 Assigns to *this the union of y and z.

Private Attributes

mpz_t vec
 Bit-vector representing the row.

Friends

int compare (const Bit_Row &x, const Bit_Row &y)
 The basic comparison function.
bool operator== (const Bit_Row &x, const Bit_Row &y)
 Returns true if and only if x and y are equal.
bool operator!= (const Bit_Row &x, const Bit_Row &y)
 Returns true if and only if x and y are not equal.
bool subset_or_equal (const Bit_Row &x, const Bit_Row &y)
 Set-theoretic inclusion test.
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.
bool strict_subset (const Bit_Row &x, const Bit_Row &y)
 Set-theoretic strict inclusion test.
void set_union (const Bit_Row &x, const Bit_Row &y, Bit_Row &z)
 Set-theoretic union.
void set_intersection (const Bit_Row &x, const Bit_Row &y, Bit_Row &z)
 Set-theoretic intersection.
void set_difference (const Bit_Row &x, const Bit_Row &y, Bit_Row &z)
 Set-theoretic difference.

Related Functions

(Note that these are not member functions.)



void swap (Parma_Polyhedra_Library::Bit_Row &x, Parma_Polyhedra_Library::Bit_Row &y)
 Specializes std::swap.
void iter_swap (std::vector< Parma_Polyhedra_Library::Bit_Row >::iterator x, std::vector< Parma_Polyhedra_Library::Bit_Row >::iterator y)
 Specializes std::iter_swap.

Detailed Description

A row in a matrix of bits.

Definition at line 112 of file Bit_Row.defs.hh.


Constructor & Destructor Documentation

Parma_Polyhedra_Library::Bit_Row::Bit_Row (  )  [inline]

Default constructor.

Definition at line 42 of file Bit_Row.inlines.hh.

References vec.

00042                  {
00043   mpz_init(vec);
00044 }

Parma_Polyhedra_Library::Bit_Row::Bit_Row ( const Bit_Row y  )  [inline]

Copy constructor.

Definition at line 47 of file Bit_Row.inlines.hh.

References vec.

00047                                  {
00048   mpz_init_set(vec, y.vec);
00049 }

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 52 of file Bit_Row.inlines.hh.

References PPL_BITS_PER_GMP_LIMB, union_helper(), and vec.

00052                                                    {
00053   const mp_size_t y_size = y.vec->_mp_size;
00054   PPL_ASSERT(y_size >= 0);
00055   const mp_size_t z_size = z.vec->_mp_size;
00056   PPL_ASSERT(z_size >= 0);
00057   if (y_size < z_size) {
00058     PPL_ASSERT(static_cast<unsigned long>(z_size)
00059            <= ULONG_MAX / PPL_BITS_PER_GMP_LIMB);
00060     mpz_init2(vec, z_size * PPL_BITS_PER_GMP_LIMB);
00061     union_helper(y, z);
00062   }
00063   else {
00064     PPL_ASSERT(static_cast<unsigned long>(y_size)
00065            <= ULONG_MAX / PPL_BITS_PER_GMP_LIMB);
00066     mpz_init2(vec, y_size * PPL_BITS_PER_GMP_LIMB);
00067     union_helper(z, y);
00068   }
00069 }

Parma_Polyhedra_Library::Bit_Row::~Bit_Row (  )  [inline]

Destructor.

Definition at line 72 of file Bit_Row.inlines.hh.

References vec.

00072                   {
00073   mpz_clear(vec);
00074 }


Member Function Documentation

void Parma_Polyhedra_Library::Bit_Row::clear (  )  [inline]

Clears all the bits of the row.

Definition at line 115 of file Bit_Row.inlines.hh.

References vec.

00115                {
00116   mpz_set_ui(vec, 0UL);
00117 }

void Parma_Polyhedra_Library::Bit_Row::clear ( unsigned long  k  )  [inline]
void Parma_Polyhedra_Library::Bit_Row::clear_from ( unsigned long  k  )  [inline]

Clears bits from position k (included) onward.

Definition at line 93 of file Bit_Row.inlines.hh.

References vec.

00093                                          {
00094   mpz_tdiv_r_2exp(vec, vec, k);
00095 }

unsigned long Parma_Polyhedra_Library::Bit_Row::count_ones (  )  const [inline]

Returns the number of set bits in the row.

Definition at line 98 of file Bit_Row.inlines.hh.

References vec.

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

00098                           {
00099   mp_size_t x_size = vec->_mp_size;
00100   PPL_ASSERT(x_size >= 0);
00101   return x_size == 0 ? 0 : mpn_popcount(vec->_mp_d, x_size);
00102 }

bool Parma_Polyhedra_Library::Bit_Row::empty (  )  const [inline]

Returns true if no bit is set in the row.

Definition at line 105 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().

00105                      {
00106   return mpz_sgn(vec) == 0;
00107 }

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 120 of file Bit_Row.inlines.hh.

References vec.

Referenced by total_memory_in_bytes().

00120                                         {
00121   return vec[0]._mp_alloc * PPL_SIZEOF_MP_LIMB_T;
00122 }

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 33 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().

00033                         {
00034   const mp_size_t vec_size = vec->_mp_size;
00035   PPL_ASSERT(vec_size >= 0);
00036   mp_size_t li = 0;
00037   mp_srcptr p = vec->_mp_d;
00038   for (; li < vec_size; ++li, ++p) {
00039     const mp_limb_t limb = *p;
00040     if (limb != 0)
00041       return li*PPL_BITS_PER_GMP_LIMB + Implementation::first_one(limb);
00042   }
00043   return ULONG_MAX;
00044 }

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 82 of file Bit_Row.cc.

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

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

00082                        {
00083   mp_size_t li = vec->_mp_size;
00084   PPL_ASSERT(li >= 0);
00085   if (li == 0)
00086     return ULONG_MAX;
00087   --li;
00088   const mp_srcptr p = vec->_mp_d + li;
00089   const mp_limb_t limb = *p;
00090   PPL_ASSERT(limb != 0);
00091   return li*PPL_BITS_PER_GMP_LIMB + Implementation::last_one(limb);
00092 }

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(), PPL_BITS_PER_GMP_LIMB, and vec.

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

00047                                              {
00048   ++position;
00049 
00050   // The alternative implementation using the mpz_scan1() function
00051   // of GMP was measured to be slower that ours.  Here it is, in
00052   // case mpz_scan1() is improved.
00053   //
00054   // unsigned long r = mpz_scan1(vec, position);
00055   // return (r == ULONG_MAX) ? -1 : r;
00056 
00057   mp_size_t li = position / PPL_BITS_PER_GMP_LIMB;
00058   const mp_size_t vec_size = vec->_mp_size;
00059   PPL_ASSERT(vec_size >= 0);
00060   if (li >= vec_size)
00061     return ULONG_MAX;
00062 
00063   // Get the first limb.
00064   mp_srcptr p = vec->_mp_d + li;
00065 
00066   // Mask off any bits before `position' in the first limb.
00067   mp_limb_t limb = *p & (~(mp_limb_t) 0) << (position % PPL_BITS_PER_GMP_LIMB);
00068 
00069   while (true) {
00070     if (limb != 0)
00071       return li*PPL_BITS_PER_GMP_LIMB + Implementation::first_one(limb);
00072     ++li;
00073     if (li == vec_size)
00074       break;
00075     ++p;
00076     limb = *p;
00077   }
00078   return ULONG_MAX;
00079 }

bool Parma_Polyhedra_Library::Bit_Row::OK (  )  const

Checks if all the invariants are satisfied.

Definition at line 302 of file Bit_Row.cc.

References vec.

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

00302                      {
00303   const mp_size_t vec_size = vec->_mp_size;
00304   const mp_size_t vec_alloc = vec->_mp_alloc;
00305   return vec_size >= 0
00306     && vec_alloc >= vec_size
00307     && (vec_size == 0 || mpz_getlimbn(vec, vec_size-1) != 0);
00308 }

Bit_Row & Parma_Polyhedra_Library::Bit_Row::operator= ( const Bit_Row y  )  [inline]

Assignment operator.

Definition at line 77 of file Bit_Row.inlines.hh.

References vec.

00077                                    {
00078   mpz_set(vec, y.vec);
00079   return *this;
00080 }

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 135 of file Bit_Row.cc.

References vec.

00135                                                   {
00136   const mp_size_t vec_size = vec->_mp_size;
00137   PPL_ASSERT(vec_size >= 0);
00138 
00139   unsigned long i = k / GMP_NUMB_BITS;
00140   if (i >= static_cast<unsigned long>(vec_size))
00141     return false;
00142 
00143   mp_limb_t limb = *(vec->_mp_d + i);
00144   return (limb >> (k % GMP_NUMB_BITS)) & 1;
00145 }

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 95 of file Bit_Row.cc.

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

00095                                              {
00096   if (position == 0)
00097     return ULONG_MAX;
00098 
00099   --position;
00100 
00101   const mp_size_t vec_size = vec->_mp_size;
00102   PPL_ASSERT(vec_size > 0);
00103   mp_size_t li = position / PPL_BITS_PER_GMP_LIMB;
00104 
00105   mp_limb_t limb;
00106   mp_srcptr p = vec->_mp_d;
00107 
00108   // Get the first limb.
00109   if (li >= vec_size) {
00110     li = vec_size - 1;
00111     p += li;
00112     limb = *p;
00113   }
00114   else {
00115     const mp_limb_t mask
00116       = (~(mp_limb_t) 0)
00117       >> (PPL_BITS_PER_GMP_LIMB - 1 - position % PPL_BITS_PER_GMP_LIMB);
00118     p += li;
00119     limb = *p & mask;
00120   }
00121 
00122   while (true) {
00123     if (limb != 0)
00124       return li*PPL_BITS_PER_GMP_LIMB + Implementation::last_one(limb);
00125     if (li == 0)
00126       break;
00127     --li;
00128     --p;
00129     limb = *p;
00130   }
00131   return ULONG_MAX;
00132 }

void Parma_Polyhedra_Library::Bit_Row::set ( unsigned long  k  )  [inline]
void Parma_Polyhedra_Library::Bit_Row::set_until ( unsigned long  k  ) 

Sets bits up to position k (excluded).

Definition at line 148 of file Bit_Row.cc.

References vec.

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().

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

void Parma_Polyhedra_Library::Bit_Row::swap ( Bit_Row y  )  [inline]

Swaps *this with y.

Definition at line 110 of file Bit_Row.inlines.hh.

References vec.

Referenced by swap().

00110                         {
00111   mpz_swap(vec, y.vec);
00112 }

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 125 of file Bit_Row.inlines.hh.

References external_memory_in_bytes().

00125                                      {
00126   return sizeof(*this) + external_memory_in_bytes();
00127 }

void Parma_Polyhedra_Library::Bit_Row::union_helper ( const Bit_Row x,
const Bit_Row y 
) [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 311 of file Bit_Row.cc.

References vec.

Referenced by Bit_Row().

00311                                                            {
00312   mp_size_t y_size = y.vec->_mp_size;
00313   mp_size_t z_size = z.vec->_mp_size;
00314   PPL_ASSERT(y_size <= z_size);
00315   PPL_ASSERT(vec->_mp_alloc >= z_size);
00316   vec->_mp_size = z_size;
00317   mp_srcptr yp = y.vec->_mp_d;
00318   mp_srcptr zp = z.vec->_mp_d;
00319   mp_ptr p = vec->_mp_d;
00320   z_size -= y_size;
00321   while (y_size > 0) {
00322     *p = *yp | * zp;
00323     ++yp;
00324     ++zp;
00325     ++p;
00326     --y_size;
00327   }
00328   while (z_size > 0) {
00329     *p = *zp;
00330     ++zp;
00331     ++p;
00332     --z_size;
00333   }
00334 }


Friends And Related Function Documentation

int compare ( const Bit_Row x,
const Bit_Row y 
) [friend]

The basic comparison function.

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.

Definition at line 156 of file Bit_Row.cc.

00156                                                {
00157   const mp_size_t x_size = x.vec->_mp_size;
00158   PPL_ASSERT(x_size >= 0);
00159   const mp_size_t y_size = y.vec->_mp_size;
00160   PPL_ASSERT(y_size >= 0);
00161   mp_size_t size = (x_size > y_size ? y_size : x_size);
00162   mp_srcptr xp = x.vec->_mp_d;
00163   mp_srcptr yp = y.vec->_mp_d;
00164   while (size > 0) {
00165     const mp_limb_t xl = *xp;
00166     const mp_limb_t yl = *yp;
00167     if (xl != yl) {
00168       // Get the ones where they are different.
00169       const mp_limb_t diff = xl ^ yl;
00170       // First bit that is different.
00171       const mp_limb_t mask = diff & ~(diff-1);
00172       return (xl & mask) ? 1 : -1;
00173     }
00174     ++xp;
00175     ++yp;
00176     --size;
00177   }
00178   return x_size == y_size ? 0 : (x_size > y_size ? 1 : -1);
00179 }

void iter_swap ( std::vector< Parma_Polyhedra_Library::Bit_Row >::iterator  x,
std::vector< Parma_Polyhedra_Library::Bit_Row >::iterator  y 
) [related]

Specializes std::iter_swap.

Definition at line 336 of file Bit_Row.inlines.hh.

References Parma_Polyhedra_Library::swap().

00337                                                                {
00338   swap(*x, *y);
00339 }

bool operator!= ( const Bit_Row x,
const Bit_Row y 
) [friend]

Returns true if and only if x and y are not equal.

Definition at line 289 of file Bit_Row.cc.

00289                                                   {
00290   const mp_size_t x_vec_size = x.vec->_mp_size;
00291   PPL_ASSERT(x_vec_size >= 0);
00292   const mp_size_t y_vec_size = y.vec->_mp_size;
00293   PPL_ASSERT(y_vec_size >= 0);
00294 
00295   if (x_vec_size != y_vec_size)
00296     return true;
00297 
00298   return mpn_cmp(x.vec->_mp_d, y.vec->_mp_d, x_vec_size) != 0;
00299 }

bool operator== ( const Bit_Row x,
const Bit_Row y 
) [friend]

Returns true if and only if x and y are equal.

Definition at line 275 of file Bit_Row.cc.

00275                                                   {
00276   const mp_size_t x_vec_size = x.vec->_mp_size;
00277   PPL_ASSERT(x_vec_size >= 0);
00278   const mp_size_t y_vec_size = y.vec->_mp_size;
00279   PPL_ASSERT(y_vec_size >= 0);
00280 
00281   if (x_vec_size != y_vec_size)
00282     return false;
00283 
00284   return mpn_cmp(x.vec->_mp_d, y.vec->_mp_d, x_vec_size) == 0;
00285 }

void set_difference ( const Bit_Row x,
const Bit_Row y,
Bit_Row z 
) [friend]

Set-theoretic difference.

Definition at line 158 of file Bit_Row.inlines.hh.

00158                                                                {
00159   PPL_DIRTY_TEMP0(mpz_class, complement_y);
00160   mpz_com(complement_y.get_mpz_t(), y.vec);
00161   mpz_and(z.vec, x.vec, complement_y.get_mpz_t());
00162 }

void set_intersection ( const Bit_Row x,
const Bit_Row y,
Bit_Row z 
) [friend]

Set-theoretic intersection.

Definition at line 152 of file Bit_Row.inlines.hh.

00152                                                                  {
00153   mpz_and(z.vec, x.vec, y.vec);
00154 }

void set_union ( const Bit_Row x,
const Bit_Row y,
Bit_Row z 
) [friend]

Set-theoretic union.

Definition at line 131 of file Bit_Row.inlines.hh.

00131                                                           {
00132   const mp_size_t x_size = x.vec->_mp_size;
00133   PPL_ASSERT(x_size >= 0);
00134   const mp_size_t y_size = y.vec->_mp_size;
00135   PPL_ASSERT(y_size >= 0);
00136   if (x_size < y_size) {
00137     PPL_ASSERT(static_cast<unsigned long>(y_size)
00138            <= ULONG_MAX / PPL_BITS_PER_GMP_LIMB);
00139     mpz_realloc2(z.vec, y_size * PPL_BITS_PER_GMP_LIMB);
00140     z.union_helper(x, y);
00141   }
00142   else {
00143     PPL_ASSERT(static_cast<unsigned long>(x_size)
00144            <= ULONG_MAX / PPL_BITS_PER_GMP_LIMB);
00145     mpz_realloc2(z.vec, x_size * PPL_BITS_PER_GMP_LIMB);
00146     z.union_helper(y, x);
00147   }
00148 }

bool strict_subset ( const Bit_Row x,
const Bit_Row y 
) [friend]

Set-theoretic strict inclusion test.

Definition at line 249 of file Bit_Row.cc.

00249                                                      {
00250   mp_size_t x_size = x.vec->_mp_size;
00251   PPL_ASSERT(x_size >= 0);
00252   mp_size_t y_size = y.vec->_mp_size;
00253   PPL_ASSERT(y_size >= 0);
00254   if (x_size > y_size)
00255     return false;
00256   bool different = (x_size < y_size);
00257   mp_srcptr xp = x.vec->_mp_d;
00258   mp_srcptr yp = y.vec->_mp_d;
00259   while (x_size > 0) {
00260     const mp_limb_t xl = *xp;
00261     const mp_limb_t yl = *yp;
00262     if (xl & ~yl)
00263       return false;
00264     if (!different && xl != yl)
00265       different = true;
00266     ++xp;
00267     ++yp;
00268     --x_size;
00269   }
00270   return different;
00271 }

bool subset_or_equal ( const Bit_Row x,
const Bit_Row y,
bool &  strict_subset 
) [friend]

Set-theoretic inclusion test: sets strict_subset to a Boolean indicating whether the inclusion is strict or not.

Definition at line 204 of file Bit_Row.cc.

00205                                           {
00206   mp_size_t x_size = x.vec->_mp_size;
00207   PPL_ASSERT(x_size >= 0);
00208   mp_size_t y_size = y.vec->_mp_size;
00209   PPL_ASSERT(y_size >= 0);
00210   if (x_size > y_size)
00211     return false;
00212   mp_srcptr xp = x.vec->_mp_d;
00213   mp_srcptr yp = y.vec->_mp_d;
00214   strict_subset = (x_size < y_size);
00215   mp_limb_t xl;
00216   mp_limb_t yl;
00217   if (strict_subset) {
00218     while (x_size > 0) {
00219       xl = *xp;
00220       yl = *yp;
00221       if (xl & ~yl)
00222         return false;
00223     strict_subset_next:
00224       ++xp;
00225       ++yp;
00226       --x_size;
00227     }
00228   }
00229   else {
00230     while (x_size > 0) {
00231       xl = *xp;
00232       yl = *yp;
00233       if (xl != yl) {
00234         if (xl & ~yl)
00235           return false;
00236         strict_subset = true;
00237         goto strict_subset_next;
00238       }
00239       ++xp;
00240       ++yp;
00241       --x_size;
00242     }
00243   }
00244   return true;
00245 }

bool subset_or_equal ( const Bit_Row x,
const Bit_Row y 
) [friend]

Set-theoretic inclusion test.

Definition at line 183 of file Bit_Row.cc.

00183                                                        {
00184   mp_size_t x_size = x.vec->_mp_size;
00185   PPL_ASSERT(x_size >= 0);
00186   mp_size_t y_size = y.vec->_mp_size;
00187   PPL_ASSERT(y_size >= 0);
00188   if (x_size > y_size)
00189     return false;
00190   mp_srcptr xp = x.vec->_mp_d;
00191   mp_srcptr yp = y.vec->_mp_d;
00192   while (x_size > 0) {
00193     if (*xp & ~*yp)
00194       return false;
00195     ++xp;
00196     ++yp;
00197     --x_size;
00198   }
00199   return true;
00200 }

Specializes std::swap.

Definition at line 329 of file Bit_Row.inlines.hh.

References swap().

00330                                         {
00331   x.swap(y);
00332 }


Member Data Documentation


The documentation for this class was generated from the following files:
Generated on Sun Feb 27 16:20:23 2011 for PPL by  doxygen 1.6.3