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_Generator_inlines_hh
00024 #define PPL_Generator_inlines_hh 1
00025
00026 namespace Parma_Polyhedra_Library {
00027
00028 inline
00029 Generator::Generator(Linear_Expression& e, Type type, Topology topology) {
00030 assert(type != CLOSURE_POINT || topology == NOT_NECESSARILY_CLOSED);
00031 Linear_Row::swap(e);
00032 flags() = Flags(topology, (type == LINE
00033 ? LINE_OR_EQUALITY
00034 : RAY_OR_POINT_OR_INEQUALITY));
00035 }
00036
00037 inline
00038 Generator::Generator(const Generator& g)
00039 : Linear_Row(g) {
00040 }
00041
00042 inline
00043 Generator::Generator(const Generator& g, dimension_type dimension)
00044 : Linear_Row(g, dimension, dimension) {
00045 }
00046
00047 inline
00048 Generator::~Generator() {
00049 }
00050
00051 inline Generator&
00052 Generator::operator=(const Generator& g) {
00053 Linear_Row::operator=(g);
00054 return *this;
00055 }
00056
00057 inline dimension_type
00058 Generator::max_space_dimension() {
00059 return Linear_Row::max_space_dimension();
00060 }
00061
00062 inline dimension_type
00063 Generator::space_dimension() const {
00064 return Linear_Row::space_dimension();
00065 }
00066
00067 inline bool
00068 Generator::is_line() const {
00069 return is_line_or_equality();
00070 }
00071
00072 inline bool
00073 Generator::is_ray_or_point() const {
00074 return is_ray_or_point_or_inequality();
00075 }
00076
00077 inline bool
00078 Generator::is_line_or_ray() const {
00079 return (*this)[0] == 0;
00080 }
00081
00082 inline bool
00083 Generator::is_ray() const {
00084 return is_ray_or_point() && is_line_or_ray();
00085 }
00086
00087 inline Generator::Type
00088 Generator::type() const {
00089 if (is_line())
00090 return LINE;
00091 if (is_line_or_ray())
00092 return RAY;
00093 if (is_necessarily_closed())
00094 return POINT;
00095 else {
00096
00097 const Generator& g = *this;
00098 return (g[size() - 1] == 0) ? CLOSURE_POINT : POINT;
00099 }
00100 }
00101
00102 inline bool
00103 Generator::is_point() const {
00104 return type() == POINT;
00105 }
00106
00107 inline bool
00108 Generator::is_closure_point() const {
00109 return type() == CLOSURE_POINT;
00110 }
00111
00112 inline void
00113 Generator::set_is_line() {
00114 set_is_line_or_equality();
00115 }
00116
00117 inline void
00118 Generator::set_is_ray_or_point() {
00119 set_is_ray_or_point_or_inequality();
00120 }
00121
00122 inline Coefficient_traits::const_reference
00123 Generator::coefficient(const Variable v) const {
00124 if (v.space_dimension() > space_dimension())
00125 throw_dimension_incompatible("coefficient(v)", "v", v);
00126 return Linear_Row::coefficient(v.id());
00127 }
00128
00129 inline Coefficient_traits::const_reference
00130 Generator::divisor() const {
00131 Coefficient_traits::const_reference d = Linear_Row::inhomogeneous_term();
00132 if (!is_ray_or_point() || d == 0)
00133 throw_invalid_argument("divisor()",
00134 "*this is neither a point nor a closure point");
00135 return d;
00136 }
00137
00138 inline memory_size_type
00139 Generator::external_memory_in_bytes() const {
00140 return Linear_Row::external_memory_in_bytes();
00141 }
00142
00143 inline memory_size_type
00144 Generator::total_memory_in_bytes() const {
00145 return Linear_Row::total_memory_in_bytes();
00146 }
00147
00148 inline const Generator&
00149 Generator::zero_dim_point() {
00150 static const Generator zdp = point();
00151 return zdp;
00152 }
00153
00154 inline const Generator&
00155 Generator::zero_dim_closure_point() {
00156 static const Generator zdcp = closure_point();
00157 return zdcp;
00158 }
00159
00161 inline Generator
00162 line(const Linear_Expression& e) {
00163 return Generator::line(e);
00164 }
00165
00167 inline Generator
00168 ray(const Linear_Expression& e) {
00169 return Generator::ray(e);
00170 }
00171
00173 inline Generator
00174 point(const Linear_Expression& e, Coefficient_traits::const_reference d) {
00175 return Generator::point(e, d);
00176 }
00177
00179 inline Generator
00180 closure_point(const Linear_Expression& e,
00181 Coefficient_traits::const_reference d) {
00182 return Generator::closure_point(e, d);
00183 }
00184
00186 inline bool
00187 operator==(const Generator& x, const Generator& y) {
00188 return x.is_equivalent_to(y);
00189 }
00190
00192 inline bool
00193 operator!=(const Generator& x, const Generator& y) {
00194 return !x.is_equivalent_to(y);
00195 }
00196
00197 inline void
00198 Generator::ascii_dump(std::ostream& s) const {
00199 Linear_Row::ascii_dump(s);
00200 }
00201
00202 inline bool
00203 Generator::ascii_load(std::istream& s) {
00204 return Linear_Row::ascii_load(s);
00205 }
00206
00207 inline void
00208 Generator::swap(Generator& y) {
00209 Linear_Row::swap(y);
00210 }
00211
00212 }
00213
00214 namespace std {
00215
00217 inline void
00218 swap(Parma_Polyhedra_Library::Generator& x,
00219 Parma_Polyhedra_Library::Generator& y) {
00220 x.swap(y);
00221 }
00222
00223 }
00224
00225 #endif // !defined(PPL_Generator_inlines_hh)