MP_boolean.cpp

Go to the documentation of this file.
00001 // ******************** FlopCpp **********************************************
00002 // File: MP_boolean.cpp
00003 // $Id$
00004 // Author: Tim Helge Hultberg (thh@mat.ua.pt)
00005 // Copyright (C) 2003 Tim Helge Hultberg
00006 // All Rights Reserved.
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 } // End of namespace flopc
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 

Generated on Fri Aug 26 03:02:58 2011 for FLOPC++ by  doxygen 1.4.7