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