00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #ifndef PPL_Powerset_inlines_hh
00024 #define PPL_Powerset_inlines_hh 1
00025
00026 #include <algorithm>
00027 #include <cassert>
00028
00029 namespace Parma_Polyhedra_Library {
00030
00031 template <typename D>
00032 inline
00033 Powerset<D>::omega_iterator::omega_iterator()
00034 : base() {
00035 }
00036
00037 template <typename D>
00038 inline
00039 Powerset<D>::omega_iterator::omega_iterator(const omega_iterator& y)
00040 : base(y.base) {
00041 }
00042
00043 template <typename D>
00044 inline
00045 Powerset<D>::omega_iterator::omega_iterator(const Base& b)
00046 : base(b) {
00047 }
00048
00049 template <typename D>
00050 inline typename Powerset<D>::omega_iterator::reference
00051 Powerset<D>::omega_iterator::operator*() const {
00052 return *base;
00053 }
00054
00055 template <typename D>
00056 inline typename Powerset<D>::omega_iterator::pointer
00057 Powerset<D>::omega_iterator::operator->() const {
00058 return &*base;
00059 }
00060
00061 template <typename D>
00062 inline typename Powerset<D>::omega_iterator&
00063 Powerset<D>::omega_iterator::operator++() {
00064 ++base;
00065 return *this;
00066 }
00067
00068 template <typename D>
00069 inline typename Powerset<D>::omega_iterator
00070 Powerset<D>::omega_iterator::operator++(int) {
00071 omega_iterator tmp = *this;
00072 operator++();
00073 return tmp;
00074 }
00075
00076 template <typename D>
00077 inline typename Powerset<D>::omega_iterator&
00078 Powerset<D>::omega_iterator::operator--() {
00079 --base;
00080 return *this;
00081 }
00082
00083 template <typename D>
00084 inline typename Powerset<D>::omega_iterator
00085 Powerset<D>::omega_iterator::operator--(int) {
00086 omega_iterator tmp = *this;
00087 operator--();
00088 return tmp;
00089 }
00090
00091 template <typename D>
00092 inline bool
00093 Powerset<D>::omega_iterator::operator==(const omega_iterator& y) const {
00094 return base == y.base;
00095 }
00096
00097 template <typename D>
00098 inline bool
00099 Powerset<D>::omega_iterator::operator!=(const omega_iterator& y) const {
00100 return !operator==(y);
00101 }
00102
00103 template <typename D>
00104 inline
00105 Powerset<D>::omega_const_iterator::omega_const_iterator()
00106 : base() {
00107 }
00108
00109 template <typename D>
00110 inline
00111 Powerset<D>
00112 ::omega_const_iterator::omega_const_iterator(const omega_const_iterator& y)
00113 : base(y.base) {
00114 }
00115
00116 template <typename D>
00117 inline
00118 Powerset<D>::omega_const_iterator::omega_const_iterator(const Base& b)
00119 : base(b) {
00120 }
00121
00122 template <typename D>
00123 inline typename Powerset<D>::omega_const_iterator::reference
00124 Powerset<D>::omega_const_iterator::operator*() const {
00125 return *base;
00126 }
00127
00128 template <typename D>
00129 inline typename Powerset<D>::omega_const_iterator::pointer
00130 Powerset<D>::omega_const_iterator::operator->() const {
00131 return &*base;
00132 }
00133
00134 template <typename D>
00135 inline typename Powerset<D>::omega_const_iterator&
00136 Powerset<D>::omega_const_iterator::operator++() {
00137 ++base;
00138 return *this;
00139 }
00140
00141 template <typename D>
00142 inline typename Powerset<D>::omega_const_iterator
00143 Powerset<D>::omega_const_iterator::operator++(int) {
00144 omega_const_iterator tmp = *this;
00145 operator++();
00146 return tmp;
00147 }
00148
00149 template <typename D>
00150 inline typename Powerset<D>::omega_const_iterator&
00151 Powerset<D>::omega_const_iterator::operator--() {
00152 --base;
00153 return *this;
00154 }
00155
00156 template <typename D>
00157 inline typename Powerset<D>::omega_const_iterator
00158 Powerset<D>::omega_const_iterator::operator--(int) {
00159 omega_const_iterator tmp = *this;
00160 operator--();
00161 return tmp;
00162 }
00163
00164 template <typename D>
00165 inline bool
00166 Powerset<D>
00167 ::omega_const_iterator::operator==(const omega_const_iterator& y) const {
00168 return base == y.base;
00169 }
00170
00171 template <typename D>
00172 inline bool
00173 Powerset<D>
00174 ::omega_const_iterator::operator!=(const omega_const_iterator& y) const {
00175 return !operator==(y);
00176 }
00177
00178 template <typename D>
00179 inline
00180 Powerset<D>
00181 ::omega_const_iterator::omega_const_iterator(const omega_iterator& y)
00182 : base(y.base) {
00183 }
00184
00186 template <typename D>
00187 inline bool
00188 operator==(const typename Powerset<D>::omega_iterator& x,
00189 const typename Powerset<D>::omega_const_iterator& y) {
00190 return Powerset<D>::omega_const_iterator(x).operator==(y);
00191 }
00192
00194 template <typename D>
00195 inline bool
00196 operator!=(const typename Powerset<D>::omega_iterator& x,
00197 const typename Powerset<D>::omega_const_iterator& y) {
00198 return !(x == y);
00199 }
00200
00201 template <typename D>
00202 inline typename Powerset<D>::iterator
00203 Powerset<D>::begin() {
00204 return sequence.begin();
00205 }
00206
00207 template <typename D>
00208 inline typename Powerset<D>::iterator
00209 Powerset<D>::end() {
00210 return sequence.end();
00211 }
00212
00213 template <typename D>
00214 inline typename Powerset<D>::const_iterator
00215 Powerset<D>::begin() const {
00216 return sequence.begin();
00217 }
00218
00219 template <typename D>
00220 inline typename Powerset<D>::const_iterator
00221 Powerset<D>::end() const {
00222 return sequence.end();
00223 }
00224
00225 template <typename D>
00226 inline typename Powerset<D>::reverse_iterator
00227 Powerset<D>::rbegin() {
00228 return reverse_iterator(end());
00229 }
00230
00231 template <typename D>
00232 inline typename Powerset<D>::reverse_iterator
00233 Powerset<D>::rend() {
00234 return reverse_iterator(begin());
00235 }
00236
00237 template <typename D>
00238 inline typename Powerset<D>::const_reverse_iterator
00239 Powerset<D>::rbegin() const {
00240 return const_reverse_iterator(end());
00241 }
00242
00243 template <typename D>
00244 inline typename Powerset<D>::const_reverse_iterator
00245 Powerset<D>::rend() const {
00246 return const_reverse_iterator(begin());
00247 }
00248
00249 template <typename D>
00250 inline typename Powerset<D>::size_type
00251 Powerset<D>::size() const {
00252 return sequence.size();
00253 }
00254
00255 template <typename D>
00256 inline bool
00257 Powerset<D>::empty() const {
00258 return sequence.empty();
00259 }
00260
00261 template <typename D>
00262 inline typename Powerset<D>::iterator
00263 Powerset<D>::drop_disjunct(iterator position) {
00264 return sequence.erase(position.base);
00265 }
00266
00267 template <typename D>
00268 inline void
00269 Powerset<D>::drop_disjuncts(iterator first, iterator last) {
00270 sequence.erase(first.base, last.base);
00271 }
00272
00273 template <typename D>
00274 inline void
00275 Powerset<D>::clear() {
00276 sequence.clear();
00277 }
00278
00279 template <typename D>
00280 inline
00281 Powerset<D>::Powerset(const Powerset& y)
00282 : sequence(y.sequence), reduced(y.reduced) {
00283 }
00284
00285 template <typename D>
00286 inline Powerset<D>&
00287 Powerset<D>::operator=(const Powerset& y) {
00288 sequence = y.sequence;
00289 reduced = y.reduced;
00290 return *this;
00291 }
00292
00293 template <typename D>
00294 inline void
00295 Powerset<D>::swap(Powerset& y) {
00296 std::swap(sequence, y.sequence);
00297 std::swap(reduced, y.reduced);
00298 }
00299
00300 template <typename D>
00301 inline
00302 Powerset<D>::Powerset()
00303 : sequence(), reduced(true) {
00304 }
00305
00306 template <typename D>
00307 inline
00308 Powerset<D>::Powerset(const D& d)
00309 : sequence(), reduced(true) {
00310 if (!d.is_bottom())
00311 sequence.push_back(d);
00312 assert(OK());
00313 }
00314
00315 template <typename D>
00316 inline
00317 Powerset<D>::~Powerset() {
00318 }
00319
00320 template <typename D>
00321 inline void
00322 Powerset<D>::add_non_bottom_disjunct(const D& d) {
00323 assert(!d.is_bottom());
00324 add_non_bottom_disjunct(d, begin(), end());
00325 }
00326
00327 template <typename D>
00328 inline void
00329 Powerset<D>::add_disjunct(const D& d) {
00330 if (!d.is_bottom())
00331 add_non_bottom_disjunct(d);
00332 }
00333
00335 template <typename D>
00336 inline
00337 bool operator!=(const Powerset<D>& x, const Powerset<D>& y) {
00338 return !(x == y);
00339 }
00340
00341 template <typename D>
00342 inline bool
00343 Powerset<D>::is_top() const {
00344
00345 omega_reduce();
00346 const_iterator xi = begin();
00347 const_iterator x_end = end();
00348 return xi != x_end && xi->is_top() && ++xi == x_end;
00349 }
00350
00351 template <typename D>
00352 inline bool
00353 Powerset<D>::is_bottom() const {
00354
00355 omega_reduce();
00356 return empty();
00357 }
00358
00359 template <typename D>
00360 inline void
00361 Powerset<D>::collapse() {
00362 if (!empty())
00363 collapse(sequence.begin());
00364 }
00365
00366 template <typename D>
00367 inline void
00368 Powerset<D>::meet_assign(const Powerset& y) {
00369 pairwise_apply_assign(y, std::mem_fun_ref(&D::meet_assign));
00370 }
00371
00372 template <typename D>
00373 inline void
00374 Powerset<D>::upper_bound_assign(const Powerset& y) {
00375 least_upper_bound_assign(y);
00376 }
00377
00378 template <typename D>
00379 inline memory_size_type
00380 Powerset<D>::total_memory_in_bytes() const {
00381 return sizeof(*this) + external_memory_in_bytes();
00382 }
00383
00384 }
00385
00386
00387 namespace std {
00388
00390 template <typename D>
00391 inline void
00392 swap(Parma_Polyhedra_Library::Powerset<D>& x,
00393 Parma_Polyhedra_Library::Powerset<D>& y) {
00394 x.swap(y);
00395 }
00396
00397 }
00398
00399 #endif // !defined(PPL_Powerset_inlines_hh)