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