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 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 } // End of namespace flopc
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 

Generated on Sun Nov 6 03:14:50 2011 for FLOPC++ by  doxygen 1.4.7