A row in a matrix of bits. More...
#include <Bit_Row.defs.hh>
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_Row & | operator= (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. | |
A row in a matrix of bits.
Definition at line 112 of file Bit_Row.defs.hh.
| 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 }
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 }
| 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] |
Clears the bit in position k.
Definition at line 88 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(), Parma_Polyhedra_Library::BD_Shape< T >::shortest_path_reduction_assign(), and Parma_Polyhedra_Library::Polyhedron::strongly_minimize_constraints().
00088 { 00089 mpz_clrbit(vec, k); 00090 }
| 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.
| 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().
| 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().
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] |
Sets the bit in position k.
Definition at line 83 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().
00083 { 00084 mpz_setbit(vec, k); 00085 }
| 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 }
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
x comes before y in the ordering;x and y are equal;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 }
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 }
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 }
Set-theoretic difference.
Definition at line 158 of file Bit_Row.inlines.hh.
Set-theoretic intersection.
Definition at line 152 of file Bit_Row.inlines.hh.
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 }
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 }
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 }
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 }
| void swap | ( | Parma_Polyhedra_Library::Bit_Row & | x, | |
| Parma_Polyhedra_Library::Bit_Row & | y | |||
| ) | [related] |
Specializes std::swap.
Definition at line 329 of file Bit_Row.inlines.hh.
References swap().
00330 { 00331 x.swap(y); 00332 }
mpz_t Parma_Polyhedra_Library::Bit_Row::vec [private] |
Bit-vector representing the row.
Definition at line 199 of file Bit_Row.defs.hh.
Referenced by Bit_Row(), clear(), clear_from(), count_ones(), empty(), external_memory_in_bytes(), first(), last(), next(), OK(), operator=(), operator[](), prev(), set(), set_until(), swap(), union_helper(), and ~Bit_Row().
1.6.3