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_Linear_Row_inlines_hh
00025 #define PPL_Linear_Row_inlines_hh 1
00026
00027 #include "globals.defs.hh"
00028 #include "assert.hh"
00029 #include <algorithm>
00030
00031 namespace Parma_Polyhedra_Library {
00032
00033 inline
00034 Linear_Row::Flags::Flags()
00035 : Row::Flags() {
00036
00037 }
00038
00039 inline
00040 Linear_Row::Flags::Flags(const Topology t)
00041 : Row::Flags(t << nnc_bit) {
00042 #ifndef NDEBUG
00043 set_bits(1 << nnc_validity_bit);
00044 #endif
00045 }
00046
00047 inline
00048 Linear_Row::Flags::Flags(const Topology t, const Kind k)
00049 : Row::Flags((k << rpi_bit) | (t << nnc_bit)) {
00050 #ifndef NDEBUG
00051 set_bits((1 << rpi_validity_bit)
00052 | (1 << nnc_validity_bit));
00053 #endif
00054 }
00055
00056 inline bool
00057 Linear_Row::Flags::is_ray_or_point_or_inequality() const {
00058 PPL_ASSERT(test_bits(1 << rpi_validity_bit));
00059 return test_bits(RAY_OR_POINT_OR_INEQUALITY << rpi_bit);
00060 }
00061
00062 inline void
00063 Linear_Row::Flags::set_is_ray_or_point_or_inequality() {
00064 #ifndef NDEBUG
00065 set_bits(1 << rpi_validity_bit);
00066 #endif
00067 set_bits(RAY_OR_POINT_OR_INEQUALITY << rpi_bit);
00068 }
00069
00070 inline bool
00071 Linear_Row::Flags::is_line_or_equality() const {
00072 PPL_ASSERT(test_bits(1 << rpi_validity_bit));
00073 return !is_ray_or_point_or_inequality();
00074 }
00075
00076 inline void
00077 Linear_Row::Flags::set_is_line_or_equality() {
00078 #ifndef NDEBUG
00079 set_bits(1 << rpi_validity_bit);
00080 #endif
00081 reset_bits(RAY_OR_POINT_OR_INEQUALITY << rpi_bit);
00082 }
00083
00084 inline bool
00085 Linear_Row::Flags::is_not_necessarily_closed() const {
00086 PPL_ASSERT(test_bits(1 << nnc_validity_bit));
00087 return test_bits(NOT_NECESSARILY_CLOSED << nnc_bit);
00088 }
00089
00090 inline bool
00091 Linear_Row::Flags::is_necessarily_closed() const {
00092 PPL_ASSERT(test_bits(1 << nnc_validity_bit));
00093 return !is_not_necessarily_closed();
00094 }
00095
00096 inline void
00097 Linear_Row::Flags::set_not_necessarily_closed() {
00098 #ifndef NDEBUG
00099 set_bits(1 << nnc_validity_bit);
00100 #endif
00101 set_bits(NOT_NECESSARILY_CLOSED << nnc_bit);
00102 }
00103
00104 inline void
00105 Linear_Row::Flags::set_necessarily_closed() {
00106 #ifndef NDEBUG
00107 set_bits(1 << nnc_validity_bit);
00108 #endif
00109 reset_bits(NOT_NECESSARILY_CLOSED << nnc_bit);
00110 }
00111
00112 inline Topology
00113 Linear_Row::Flags::topology() const {
00114 return is_necessarily_closed() ? NECESSARILY_CLOSED : NOT_NECESSARILY_CLOSED;
00115 }
00116
00117 inline bool
00118 Linear_Row::Flags::operator==(const Flags& y) const {
00119 base_type mask = low_bits_mask<base_type>(first_free_bit);
00120 return (get_bits() & mask) == (y.get_bits() & mask);
00121 }
00122
00123 inline bool
00124 Linear_Row::Flags::operator!=(const Flags& y) const {
00125 return !operator==(y);
00126 }
00127
00128 inline const Linear_Row::Flags&
00129 Linear_Row::flags() const {
00130 return static_cast<const Flags&>(Row::flags());
00131 }
00132
00133 inline Linear_Row::Flags&
00134 Linear_Row::flags() {
00135 return static_cast<Flags&>(Row::flags());
00136 }
00137
00138 inline bool
00139 Linear_Row::is_necessarily_closed() const {
00140 return flags().is_necessarily_closed();
00141 }
00142
00143 inline dimension_type
00144 Linear_Row::max_space_dimension() {
00145
00146
00147 return max_size() - 2;
00148 }
00149
00150 inline dimension_type
00151 Linear_Row::space_dimension() const {
00152 const dimension_type sz = size();
00153 return (sz == 0)
00154 ? 0
00155 : sz - (is_necessarily_closed() ? 1 : 2);
00156 }
00157
00158 inline
00159 Linear_Row::Linear_Row()
00160 : Row() {
00161 }
00162
00163 inline void
00164 Linear_Row::construct(const dimension_type sz, const dimension_type capacity,
00165 const Flags f) {
00166 Row::construct(sz, capacity, f);
00167 }
00168
00169 inline
00170 Linear_Row::Linear_Row(const dimension_type sz, const dimension_type capacity,
00171 const Flags f) {
00172 construct(sz, capacity, f);
00173 }
00174
00175 inline void
00176 Linear_Row::construct(const dimension_type sz, const Flags f) {
00177 construct(sz, sz, f);
00178 }
00179
00180 inline
00181 Linear_Row::Linear_Row(const dimension_type sz, const Flags f) {
00182 construct(sz, f);
00183 }
00184
00185 inline
00186 Linear_Row::Linear_Row(const Linear_Row& y)
00187 : Row(y) {
00188 }
00189
00190 inline
00191 Linear_Row::Linear_Row(const Linear_Row& y,
00192 const dimension_type capacity)
00193 : Row(y, capacity) {
00194 }
00195
00196 inline
00197 Linear_Row::Linear_Row(const Linear_Row& y,
00198 const dimension_type sz, const dimension_type capacity)
00199 : Row(y, sz, capacity) {
00200 }
00201
00202 inline
00203 Linear_Row::~Linear_Row() {
00204 }
00205
00206 inline bool
00207 Linear_Row::is_line_or_equality() const {
00208 return flags().is_line_or_equality();
00209 }
00210
00211 inline bool
00212 Linear_Row::is_ray_or_point_or_inequality() const {
00213 return flags().is_ray_or_point_or_inequality();
00214 }
00215
00216 inline Topology
00217 Linear_Row::topology() const {
00218 return flags().topology();
00219 }
00220
00221 inline void
00222 Linear_Row::set_is_line_or_equality() {
00223 flags().set_is_line_or_equality();
00224 }
00225
00226 inline void
00227 Linear_Row::set_is_ray_or_point_or_inequality() {
00228 flags().set_is_ray_or_point_or_inequality();
00229 }
00230
00231 inline void
00232 Linear_Row::set_necessarily_closed() {
00233 flags().set_necessarily_closed();
00234 }
00235
00236 inline void
00237 Linear_Row::set_not_necessarily_closed() {
00238 flags().set_not_necessarily_closed();
00239 }
00240
00241 inline Coefficient_traits::const_reference
00242 Linear_Row::inhomogeneous_term() const {
00243 return (*this)[0];
00244 }
00245
00246 inline Coefficient_traits::const_reference
00247 Linear_Row::coefficient(const dimension_type k) const {
00248 return (*this)[k+1];
00249 }
00250
00251 inline void
00252 Linear_Row::strong_normalize() {
00253 normalize();
00254 sign_normalize();
00255 }
00256
00258 inline bool
00259 operator==(const Linear_Row& x, const Linear_Row& y) {
00260 return x.flags() == y.flags()
00261 && static_cast<const Row&>(x) == static_cast<const Row&>(y);
00262 }
00263
00265 inline bool
00266 operator!=(const Linear_Row& x, const Linear_Row& y) {
00267 return !(x == y);
00268 }
00269
00270 }
00271
00272
00273 namespace std {
00274
00276 inline void
00277 swap(Parma_Polyhedra_Library::Linear_Row& x,
00278 Parma_Polyhedra_Library::Linear_Row& y) {
00279 x.swap(y);
00280 }
00281
00283 inline void
00284 iter_swap(std::vector<Parma_Polyhedra_Library::Linear_Row>::iterator x,
00285 std::vector<Parma_Polyhedra_Library::Linear_Row>::iterator y) {
00286 swap(*x, *y);
00287 }
00288
00289 }
00290
00291 #endif // !defined(PPL_Linear_Row_inlines_hh)