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 #include "MP_index.hpp"
00014 
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 Fri May 16 00:25:12 2008 for FLOPC++ by  doxygen 1.4.7