00001
00002
00003
00004
00005
00006
00007
00008
00009 #ifndef _MP_expression_hpp_
00010 #define _MP_expression_hpp_
00011
00012 #include <vector>
00013 #include <set>
00014 using std::vector;
00015 using std::set;
00016
00017 #include "MP_domain.hpp"
00018 #include "MP_constant.hpp"
00019 #include "MP_utilities.hpp"
00020
00021 namespace flopc {
00022
00023 class MP_constraint;
00024 class TerminalExpression;
00025 class MP_variable;
00026 class VariableRef;
00027
00028 class MP {
00029 friend class MP_expression;
00030 friend class MP_constraint;
00031 friend class MP_model;
00032 friend class Messenger;
00033 friend class VerboseMessenger;
00034 friend class CoefLess;
00035 friend class MP_expression_base;
00036 friend class VariableRef;
00037
00038 struct Coef {
00039 Coef(int c, int r, double v, int s = 0) :
00040 col(c), row(r), stage(s), val(v) {}
00041 int col, row, stage;
00042 double val;
00043 };
00044
00045 struct CoefLess {
00046 bool operator() (const MP::Coef& a, const MP::Coef& b) const;
00047 };
00048
00049 protected:
00050 class GenerateFunctor : public Functor {
00051 public:
00052 GenerateFunctor(MP_constraint* r, vector<Coef>& cfs): R(r), Coefs(cfs) {}
00053
00054 void setMultiplicator(vector<Constant>& mults, double m) {
00055 multiplicators = mults;
00056 M = m;
00057 }
00058 void setTerminalExpression(const TerminalExpression* c) {
00059 C = c;
00060 }
00061
00062 void operator()() const;
00063 private:
00064 vector<Constant> multiplicators;
00065 MP_constraint* R;
00066 double M;
00067 const TerminalExpression* C;
00068 vector<MP::Coef>& Coefs;
00069 };
00070 };
00071
00072
00078 class MP_expression_base {
00079 friend class MP_expression;
00080 friend class Handle<MP_expression_base*>;
00081 private:
00082 int count;
00083 public:
00084 MP_expression_base() : count(0) {}
00085
00086 virtual double level() const = 0;
00087 virtual void generate(const MP_domain& domain,
00088 vector<Constant> multiplicators,
00089 MP::GenerateFunctor &f,
00090 double m) const = 0;
00091
00092 virtual void insertVariables(set<MP_variable*>& v) const = 0;
00093
00094 virtual ~MP_expression_base() {}
00095 };
00096
00097
00110 class MP_expression : public Handle<MP_expression_base*> {
00111 public:
00112 MP_expression() : Handle<MP_expression_base*>(0) {}
00114 MP_expression(const Constant& c);
00116 MP_expression(const VariableRef& v);
00117 MP_expression(MP_expression_base* r) : Handle<MP_expression_base*>(r) {}
00118 };
00119
00120
00127 class TerminalExpression : public MP_expression_base {
00128 public:
00129 virtual double getValue() const = 0;
00130 virtual int getColumn() const = 0;
00131 virtual int getStage() const = 0;
00132 };
00133
00138 class VariableRef : public TerminalExpression {
00139 friend class MP_variable;
00140 public:
00141 int getColumn() const;
00142 private:
00143 VariableRef(MP_variable* v,
00144 const MP_index_exp& i1,
00145 const MP_index_exp& i2,
00146 const MP_index_exp& i3,
00147 const MP_index_exp& i4,
00148 const MP_index_exp& i5);
00149
00150 double level() const;
00151
00152 void insertVariables(set<MP_variable*>& v) const {
00153 v.insert(V);
00154 }
00155 double getValue() const {
00156 return 1.0;
00157 }
00158 int getStage() const {
00159 return 0;
00160 }
00161 void generate(const MP_domain& domain,
00162 vector<Constant> multiplicators,
00163 MP::GenerateFunctor& f,
00164 double m) const;
00165 MP_variable* V;
00166 int offset;
00167 const MP_index_exp I1,I2,I3,I4,I5;
00168 };
00169
00171 MP_expression operator+(const MP_expression& e1, const MP_expression& e2);
00173 MP_expression operator+(const MP_expression& e1, const Constant& e2);
00175 MP_expression operator+(const Constant& e1, const MP_expression& e2);
00177 MP_expression operator-(const MP_expression& e1, const MP_expression& e2);
00179 MP_expression operator-(const MP_expression& e1, const Constant& e2);
00181 MP_expression operator-(const Constant& e1, const MP_expression& e2);
00183 MP_expression operator*(const Constant& e1, const MP_expression& e2);
00185 MP_expression operator*(const MP_expression& e1, const Constant& e2);
00187 MP_expression operator/(const MP_expression& e1, const Constant& e2);
00189 MP_expression sum(const MP_domain& d, const MP_expression& e);
00190
00191 }
00192 #endif