MP_expression.hpp

Go to the documentation of this file.
00001 // ******************** FlopCpp **********************************************
00002 // File: MP_expression.hpp
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 #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 Boolean;
00024     class MP_domain;
00025     class MP_constraint;
00026     class Row;
00027     class MP_variable;
00028     class VariableRef;
00029     class CoefLess;
00030 
00036     struct Coef {
00037         Coef(int c, int r, double v, int s = 0) : 
00038             col(c), row(r), stage(s), val(v)  {}
00039         int col, row, stage;
00040         double val;
00041     };
00042 
00043     class TerminalExpression;
00044 
00050     class GenerateFunctor : public Functor {
00051     public:
00052         GenerateFunctor(vector<Coef>& coefs) : Coefs(coefs) {}
00053 
00054         virtual ~GenerateFunctor(){}
00055 
00056         void setConstraint(MP_constraint* r) {
00057             R = r;
00058         }
00059         void setMultiplicator(vector<Constant>& mults, double m) {
00060             multiplicators = mults;
00061             m_ = m;
00062         }
00063         void setTerminalExpression(const TerminalExpression* c) {
00064             C = c;
00065         }
00066         virtual int row_number() const;
00067 
00068         void operator()() const;
00069 
00070         double m_;
00071         vector<Constant> multiplicators;
00072         MP_constraint* R;
00073         const TerminalExpression* C;
00074         vector<Coef>& Coefs;
00075     };
00076 
00082     class ObjectiveGenerateFunctor : public GenerateFunctor {
00083     public:
00084         ObjectiveGenerateFunctor(vector<Coef>& coefs) : GenerateFunctor(coefs) {}
00085         virtual int row_number() const {
00086             return -1;
00087         }
00088     };
00089 
00095     class MP_expression_base {
00096         friend class MP_expression;
00097         friend class Handle<MP_expression_base*>;
00098     private:
00099         int count;
00100     public:
00101         MP_expression_base() : count(0) {}
00102 
00103         virtual double level() const = 0;
00104         virtual void generate(const MP_domain& domain,
00105                               vector<Constant> multiplicators,
00106                               GenerateFunctor& f,
00107                               double m) const = 0;
00108         virtual void insertVariables(set<MP_variable*>& v) const = 0;
00109 
00110         virtual ~MP_expression_base() {}
00111     };
00112 
00124     class MP_expression : public Handle<MP_expression_base*> {
00125         friend class MP_constraint;
00126     public:
00128         MP_expression() : Handle<MP_expression_base*>(0) {}
00132         MP_expression(MP_expression_base* r) : Handle<MP_expression_base*>(r) {}
00134         MP_expression(const Constant& c);
00136         MP_expression(const VariableRef& v);
00137         virtual ~MP_expression() {}
00138     };
00139 
00146     class TerminalExpression : public MP_expression_base {
00147     public:
00148         virtual double getValue() const = 0; 
00149         virtual int getColumn() const = 0;
00150         virtual int getStage() const = 0;
00151     };
00152 
00159     class Expression_operator : public MP_expression_base {
00160     public:
00161         Expression_operator(const MP_expression& e1, const MP_expression& e2) : 
00162             left(e1),right(e2) {}
00163         void insertVariables(set<MP_variable*>& v) const {
00164             left->insertVariables(v);
00165             right->insertVariables(v);
00166         }
00167     protected:
00168         MP_expression left,right;
00169     };
00170 
00172     MP_expression operator+(const MP_expression& e1, const MP_expression& e2);
00176     MP_expression operator+(const MP_expression& e1, const Constant& e2);
00180     MP_expression operator+(const Constant& e1, const MP_expression& e2);
00184     MP_expression operator-(const MP_expression& e1, const MP_expression& e2);
00188     MP_expression operator-(const MP_expression& e1, const Constant& e2);
00192     MP_expression operator-(const Constant& e1, const MP_expression& e2);
00196     MP_expression operator*(const Constant& e1, const MP_expression& e2); 
00200     MP_expression operator*(const MP_expression& e1, const Constant& e2);
00204     MP_expression sum(const MP_domain& d, const MP_expression& e);
00205 
00206 } // End of namespace flopc
00207 #endif

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