00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #ifndef PPL_Powerset_inlines_hh
00025 #define PPL_Powerset_inlines_hh 1
00026
00027 #include <algorithm>
00028 #include "assert.hh"
00029
00030 namespace Parma_Polyhedra_Library {
00031
00032 template <typename D>
00033 inline typename Powerset<D>::iterator
00034 Powerset<D>::begin() {
00035 return sequence.begin();
00036 }
00037
00038 template <typename D>
00039 inline typename Powerset<D>::iterator
00040 Powerset<D>::end() {
00041 return sequence.end();
00042 }
00043
00044 template <typename D>
00045 inline typename Powerset<D>::const_iterator
00046 Powerset<D>::begin() const {
00047 return sequence.begin();
00048 }
00049
00050 template <typename D>
00051 inline typename Powerset<D>::const_iterator
00052 Powerset<D>::end() const {
00053 return sequence.end();
00054 }
00055
00056 template <typename D>
00057 inline typename Powerset<D>::reverse_iterator
00058 Powerset<D>::rbegin() {
00059 return reverse_iterator(end());
00060 }
00061
00062 template <typename D>
00063 inline typename Powerset<D>::reverse_iterator
00064 Powerset<D>::rend() {
00065 return reverse_iterator(begin());
00066 }
00067
00068 template <typename D>
00069 inline typename Powerset<D>::const_reverse_iterator
00070 Powerset<D>::rbegin() const {
00071 return const_reverse_iterator(end());
00072 }
00073
00074 template <typename D>
00075 inline typename Powerset<D>::const_reverse_iterator
00076 Powerset<D>::rend() const {
00077 return const_reverse_iterator(begin());
00078 }
00079
00080 template <typename D>
00081 inline typename Powerset<D>::size_type
00082 Powerset<D>::size() const {
00083 return sequence.size();
00084 }
00085
00086 template <typename D>
00087 inline bool
00088 Powerset<D>::empty() const {
00089 return sequence.empty();
00090 }
00091
00092 template <typename D>
00093 inline typename Powerset<D>::iterator
00094 Powerset<D>::drop_disjunct(iterator position) {
00095 return sequence.erase(position.base);
00096 }
00097
00098 template <typename D>
00099 inline void
00100 Powerset<D>::drop_disjuncts(iterator first, iterator last) {
00101 sequence.erase(first.base, last.base);
00102 }
00103
00104 template <typename D>
00105 inline void
00106 Powerset<D>::clear() {
00107 sequence.clear();
00108 }
00109
00110 template <typename D>
00111 inline
00112 Powerset<D>::Powerset(const Powerset& y)
00113 : sequence(y.sequence), reduced(y.reduced) {
00114 }
00115
00116 template <typename D>
00117 inline Powerset<D>&
00118 Powerset<D>::operator=(const Powerset& y) {
00119 sequence = y.sequence;
00120 reduced = y.reduced;
00121 return *this;
00122 }
00123
00124 template <typename D>
00125 inline void
00126 Powerset<D>::swap(Powerset& y) {
00127 std::swap(sequence, y.sequence);
00128 std::swap(reduced, y.reduced);
00129 }
00130
00131 template <typename D>
00132 inline
00133 Powerset<D>::Powerset()
00134 : sequence(), reduced(true) {
00135 }
00136
00137 template <typename D>
00138 inline
00139 Powerset<D>::Powerset(const D& d)
00140 : sequence(), reduced(false) {
00141 sequence.push_back(d);
00142 PPL_ASSERT_HEAVY(OK());
00143 }
00144
00145 template <typename D>
00146 inline
00147 Powerset<D>::~Powerset() {
00148 }
00149
00150 template <typename D>
00151 inline void
00152 Powerset<D>::add_non_bottom_disjunct_preserve_reduction(const D& d) {
00153
00154 add_non_bottom_disjunct_preserve_reduction(d, begin(), end());
00155 }
00156
00157 template <typename D>
00158 inline void
00159 Powerset<D>::add_disjunct(const D& d) {
00160 sequence.push_back(d);
00161 reduced = false;
00162 }
00163
00165 template <typename D>
00166 inline
00167 bool operator!=(const Powerset<D>& x, const Powerset<D>& y) {
00168 return !(x == y);
00169 }
00170
00171 template <typename D>
00172 inline bool
00173 Powerset<D>::is_top() const {
00174
00175 omega_reduce();
00176 const_iterator xi = begin();
00177 const_iterator x_end = end();
00178 return xi != x_end && xi->is_top() && ++xi == x_end;
00179 }
00180
00181 template <typename D>
00182 inline bool
00183 Powerset<D>::is_bottom() const {
00184
00185 omega_reduce();
00186 return empty();
00187 }
00188
00189 template <typename D>
00190 inline void
00191 Powerset<D>::collapse() {
00192 if (!empty())
00193 collapse(sequence.begin());
00194 }
00195
00196 template <typename D>
00197 inline void
00198 Powerset<D>::meet_assign(const Powerset& y) {
00199 pairwise_apply_assign(y, std::mem_fun_ref(&D::meet_assign));
00200 }
00201
00202 template <typename D>
00203 inline void
00204 Powerset<D>::upper_bound_assign(const Powerset& y) {
00205 least_upper_bound_assign(y);
00206 }
00207
00208 template <typename D>
00209 inline bool
00210 Powerset<D>::upper_bound_assign_if_exact(const Powerset& y) {
00211 least_upper_bound_assign(y);
00212 return true;
00213 }
00214
00215 template <typename D>
00216 inline memory_size_type
00217 Powerset<D>::total_memory_in_bytes() const {
00218 return sizeof(*this) + external_memory_in_bytes();
00219 }
00220
00221 }
00222
00223
00224 namespace std {
00225
00227 template <typename D>
00228 inline void
00229 swap(Parma_Polyhedra_Library::Powerset<D>& x,
00230 Parma_Polyhedra_Library::Powerset<D>& y) {
00231 x.swap(y);
00232 }
00233
00234 }
00235
00236 #endif // !defined(PPL_Powerset_inlines_hh)