00001
00002
00003
00004
00005
00006
00007
00008
00009 #include "MP_boolean.hpp"
00010 #include "MP_constant.hpp"
00011 #include "MP_domain.hpp"
00012 #include "MP_set.hpp"
00013
00014
00015 namespace flopc {
00016
00017 class Boolean_bool : public Boolean_base {
00018 friend class MP_boolean;
00019 private:
00020 Boolean_bool(bool b) : B(b) {}
00021 bool evaluate() const {
00022 return B;
00023 }
00024 bool B;
00025 };
00026
00027 class Boolean_Constant : public Boolean_base {
00028 friend class MP_boolean;
00029 private:
00030 Boolean_Constant(const Constant& c) : C(c) {}
00031 bool evaluate() const {
00032 return C->evaluate();
00033 }
00034 Constant C;
00035 };
00036
00037 class Boolean_SUBSETREF : public Boolean_base {
00038 friend class MP_boolean;
00039 private:
00040 Boolean_SUBSETREF(SUBSETREF& c) : C(&c) {}
00041 bool evaluate() const {
00042 if (C->evaluate() == outOfBound) {
00043 return false;
00044 } else {
00045 return true;
00046 }
00047 }
00048 SUBSETREF* C;
00049 };
00050
00051 class Boolean_negate : public Boolean_base {
00052 friend MP_boolean operator!(const MP_boolean& b);
00053 private:
00054 Boolean_negate(const MP_boolean& b) : B(b) {}
00055 bool evaluate() const {
00056 return !(B->evaluate());
00057 }
00058 MP_boolean B;
00059 };
00060
00061 class Boolean_and : public Boolean_base {
00062 friend MP_boolean operator&&(const MP_boolean& e1, const MP_boolean& e2);
00063 private:
00064 Boolean_and(const MP_boolean& e1, const MP_boolean e2) : left(e1), right(e2) {}
00065 bool evaluate() const {
00066 return left->evaluate() && right->evaluate();
00067 }
00068 MP_boolean left, right;
00069 };
00070
00071 class Boolean_or : public Boolean_base {
00072 friend MP_boolean operator||(const MP_boolean& e1, const MP_boolean& e2);
00073 private:
00074 Boolean_or(const MP_boolean& e1, const MP_boolean& e2) : left(e1), right(e2) {}
00075 bool evaluate() const {
00076 return left->evaluate() || right->evaluate();
00077 }
00078 MP_boolean left, right;
00079 };
00080
00081 class Boolean_alltrue : public Boolean_base {
00082 friend MP_boolean alltrue(const MP_domain& d, const MP_boolean& b);
00083 private:
00084 Boolean_alltrue(const MP_domain& d, const MP_boolean& b) : D(d), B(b) {}
00085 bool evaluate() const {
00086 return true;
00087 }
00088 MP_domain D;
00089 MP_boolean B;
00090 };
00091
00092 class Comparison : public Boolean_base {
00093 protected:
00094 Comparison(const Constant& e1, const Constant& e2) : left(e1), right(e2) {}
00095 Constant left,right;
00096 };
00097
00098 class Boolean_lessEq : public Comparison {
00099 friend MP_boolean operator<=(const MP_index_exp& e1, const MP_index_exp& e2);
00100 friend MP_boolean operator<=(const Constant& e1, const Constant& e2);
00101 private:
00102 Boolean_lessEq(const Constant& e1, const Constant& e2) : Comparison(e1,e2) {}
00103 bool evaluate() const;
00104 };
00105
00106 class Boolean_less : public Comparison {
00107 friend MP_boolean operator<(const MP_index_exp& e1,
00108 const MP_index_exp& e2);
00109 friend MP_boolean operator<(const Constant& e1, const Constant& e2);
00110 private:
00111 Boolean_less(const Constant& e1, const Constant& e2) : Comparison(e1,e2) {}
00112 bool evaluate() const;
00113 };
00114
00115 class Boolean_greaterEq : public Comparison {
00116 friend MP_boolean operator>=(MP_index& e1, MP_index& e2);
00117 friend MP_boolean operator>=(const MP_index_exp& e1,
00118 const MP_index_exp& e2);
00119 friend MP_boolean operator>=(const Constant& e1, const Constant& e2);
00120 private:
00121 Boolean_greaterEq(const Constant& e1, const Constant& e2) :
00122 Comparison(e1,e2) {}
00123 bool evaluate() const;
00124 };
00125
00126 class Boolean_greater : public Comparison {
00127 friend MP_boolean operator>(const MP_index_exp& e1, const MP_index_exp& e2);
00128 friend MP_boolean operator>(const Constant& e1, const Constant& e2);
00129 private:
00130 Boolean_greater(const Constant& e1, const Constant& e2): Comparison(e1,e2) {}
00131 bool evaluate() const;
00132 };
00133
00134 class Boolean_equal : public Comparison {
00135 friend MP_boolean operator==(const MP_index_exp& e1, const MP_index_exp& e2);
00136 friend MP_boolean operator==(const Constant& e1, const Constant& e2);
00137 private:
00138 Boolean_equal(const Constant& e1, const Constant& e2) : Comparison(e1,e2) {}
00139 bool evaluate() const;
00140 };
00141
00142 class Boolean_not_equal : public Comparison {
00143 friend MP_boolean operator!=(const MP_index_exp& e1, const MP_index_exp& e2);
00144 friend MP_boolean operator!=(const Constant& e1, const Constant& e2);
00145 private:
00146 Boolean_not_equal(const Constant& e1, const Constant& e2) : Comparison(e1,e2) {}
00147 bool evaluate() const;
00148 };
00149
00150
00151 MP_boolean alltrue(const MP_domain& d, const MP_boolean& b) {
00152 return new Boolean_alltrue(d,b);
00153 }
00154
00155 MP_boolean operator!(const MP_boolean& b) {
00156 return new Boolean_negate(b);
00157 }
00158 MP_boolean operator&&(const MP_boolean& e1, const MP_boolean& e2) {
00159 return new Boolean_and(e1, e2);
00160 }
00161 MP_boolean operator||(const MP_boolean& e1, const MP_boolean& e2) {
00162 return new Boolean_or(e1, e2);
00163 }
00164 MP_boolean operator<=(const MP_index_exp& e1, const MP_index_exp& e2) {
00165 return new Boolean_lessEq(e1, e2);
00166 }
00167 MP_boolean operator<=(const Constant& e1, const Constant& e2) {
00168 return new Boolean_lessEq(e1, e2);
00169 }
00170 MP_boolean operator<(const MP_index_exp& e1, const MP_index_exp& e2) {
00171 return new Boolean_less(e1, e2);
00172 }
00173 MP_boolean operator<(const Constant& e1, const Constant& e2) {
00174 return new Boolean_less(e1, e2);
00175 }
00176 MP_boolean operator>=(const MP_index_exp& e1, const MP_index_exp& e2) {
00177 return new Boolean_greaterEq(e1, e2);
00178 }
00179 MP_boolean operator>=(const Constant& e1, const Constant& e2) {
00180 return new Boolean_greaterEq(e1, e2);
00181 }
00182 MP_boolean operator>(const MP_index_exp& e1, const MP_index_exp& e2) {
00183 return new Boolean_greater(e1, e2);
00184 }
00185 MP_boolean operator>(const Constant& e1, const Constant& e2) {
00186 return new Boolean_greater(e1, e2);
00187 }
00188 MP_boolean operator==(const MP_index_exp& e1, const MP_index_exp& e2) {
00189 return new Boolean_equal(e1, e2);
00190 }
00191 MP_boolean operator!=(const MP_index_exp& e1, const MP_index_exp& e2) {
00192 return new Boolean_not_equal(e1, e2);
00193 }
00194 MP_boolean operator==(const Constant& e1, const Constant& e2) {
00195 return new Boolean_equal(e1, e2);
00196 }
00197 MP_boolean operator!=(const Constant& e1, const Constant& e2) {
00198 return new Boolean_not_equal(e1, e2);
00199 }
00200
00201 }
00202
00203 using namespace flopc;
00204
00205 MP_boolean::MP_boolean(bool b) : Handle<Boolean_base*>(new Boolean_bool(b)) {}
00206
00207 MP_boolean::MP_boolean(const Constant& c) :
00208 Handle<Boolean_base*>(new Boolean_Constant(c)) {}
00209
00210 MP_boolean::MP_boolean(SUBSETREF& c) :
00211 Handle<Boolean_base*>(new Boolean_SUBSETREF(c)) {}
00212
00213 bool Boolean_lessEq::evaluate() const {
00214 return (left->evaluate() <= right->evaluate());
00215 }
00216 bool Boolean_less::evaluate() const {
00217 return (left->evaluate() < right->evaluate());
00218 }
00219 bool Boolean_greaterEq::evaluate() const {
00220 return (left->evaluate() >= right->evaluate());
00221 }
00222 bool Boolean_greater::evaluate() const {
00223 return (left->evaluate() > right->evaluate());
00224 }
00225 bool Boolean_equal::evaluate() const {
00226 return (left->evaluate() == right->evaluate());
00227 }
00228 bool Boolean_not_equal::evaluate() const {
00229 return (left->evaluate() != right->evaluate());
00230 }
00231
00232