• Main Page
  • Related Pages
  • Modules
  • Namespaces
  • Classes
  • Files
  • File List
  • File Members

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 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       return (left->evaluate() <= right->evaluate());
00105     }
00106   };
00107 
00108   class Boolean_less : public Comparison {
00109     friend MP_boolean operator<(const MP_index_exp& e1, 
00110                                 const MP_index_exp& e2);
00111     friend MP_boolean operator<(const Constant& e1, const Constant& e2); 
00112   private:
00113     Boolean_less(const Constant& e1, const Constant& e2) : Comparison(e1,e2) {}
00114     bool evaluate() const {
00115       return (left->evaluate() < right->evaluate());
00116     }
00117   };
00118 
00119   class Boolean_greaterEq : public Comparison {
00120     friend MP_boolean operator>=(MP_index& e1, MP_index& e2);
00121     friend MP_boolean operator>=(const MP_index_exp& e1, 
00122                                  const MP_index_exp& e2);
00123     friend MP_boolean operator>=(const Constant& e1, const Constant& e2);
00124   private:
00125     Boolean_greaterEq(const Constant& e1, const Constant& e2) : 
00126       Comparison(e1,e2) {}
00127     bool evaluate() const { 
00128       return (left->evaluate() >= right->evaluate());
00129     }
00130   };
00131 
00132   class Boolean_greater : public Comparison {
00133     friend MP_boolean operator>(const MP_index_exp& e1, const MP_index_exp& e2);
00134     friend MP_boolean operator>(const Constant& e1, const Constant& e2);
00135   private:
00136     Boolean_greater(const Constant& e1, const Constant& e2): Comparison(e1,e2) {}
00137     bool evaluate() const {
00138       return (left->evaluate() > right->evaluate());
00139     }
00140   };
00141 
00142   class Boolean_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_equal(const Constant& e1, const Constant& e2) : Comparison(e1,e2) {}
00147     bool evaluate() const {
00148       return (left->evaluate() == right->evaluate());
00149     }
00150   };
00151 
00152   class Boolean_not_equal : public Comparison {
00153     friend MP_boolean operator!=(const MP_index_exp& e1, const MP_index_exp& e2);
00154     friend MP_boolean operator!=(const Constant& e1, const Constant& e2);
00155   private:
00156     Boolean_not_equal(const Constant& e1, const Constant& e2) : Comparison(e1,e2) {}
00157     bool evaluate() const { 
00158       return (left->evaluate() != right->evaluate());
00159     }
00160   };
00161 
00162 //   MP_boolean alltrue(const MP_domain& d, const MP_boolean& b) {
00163 //     return new Boolean_alltrue(d,b);
00164 //   }
00165 
00166   MP_boolean operator!(const MP_boolean& b) {
00167     return new Boolean_negate(b);
00168   }
00169   MP_boolean operator&&(const MP_boolean& e1, const MP_boolean& e2) {
00170     return new Boolean_and(e1, e2);
00171   }
00172   MP_boolean operator||(const MP_boolean& e1, const MP_boolean& e2) {
00173     return new Boolean_or(e1, e2);
00174   }
00175   MP_boolean operator<=(const MP_index_exp& e1, const MP_index_exp& e2) {
00176     return new Boolean_lessEq(e1, e2);
00177   } 
00178   MP_boolean operator<=(const Constant& e1, const Constant& e2) {
00179     return new Boolean_lessEq(e1, e2);
00180   }
00181   MP_boolean operator<(const MP_index_exp& e1, const MP_index_exp& e2) {
00182     return new Boolean_less(e1, e2);
00183   }
00184   MP_boolean operator<(const Constant& e1, const Constant& e2) {
00185     return new Boolean_less(e1, e2);
00186   }
00187   MP_boolean operator>=(const MP_index_exp& e1, const MP_index_exp& e2) {
00188     return new Boolean_greaterEq(e1, e2);
00189   }
00190   MP_boolean operator>=(const Constant& e1, const Constant& e2) {
00191     return new Boolean_greaterEq(e1, e2);
00192   }
00193   MP_boolean operator>(const MP_index_exp& e1, const MP_index_exp& e2) {
00194     return new Boolean_greater(e1, e2);
00195   }
00196   MP_boolean operator>(const Constant& e1, const Constant& e2) {
00197     return new Boolean_greater(e1, e2);
00198   }
00199   MP_boolean operator==(const MP_index_exp& e1, const MP_index_exp& e2) {
00200     return new Boolean_equal(e1, e2);
00201   }
00202   MP_boolean operator!=(const MP_index_exp& e1, const MP_index_exp& e2) {
00203     return new Boolean_not_equal(e1, e2);
00204   }
00205   MP_boolean operator==(const Constant& e1, const Constant& e2) {
00206     return new Boolean_equal(e1, e2);
00207   }
00208   MP_boolean operator!=(const Constant& e1, const Constant& e2) {
00209     return new Boolean_not_equal(e1, e2);
00210   }
00211 
00212 } // End of namespace flopc
00213 
00214 using namespace flopc;
00215 
00216 MP_boolean::MP_boolean(bool b) : Handle<Boolean_base*>(new Boolean_bool(b)) {} 
00217 
00218 MP_boolean::MP_boolean(const Constant& c) : Handle<Boolean_base*>(new Boolean_Constant(c)) {}
00219 
00220 MP_boolean::MP_boolean(SUBSETREF& c) :  Handle<Boolean_base*>(new Boolean_SUBSETREF(c)) {}

Generated on Thu Jul 29 2010 20:00:14 for FLOPC++ by  doxygen 1.7.1