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 operator/(const MP_expression& e1, const Constant& e2);
00208   MP_expression sum(const MP_domain& d, const MP_expression& e);
00209 
00210 } // End of namespace flopc
00211 #endif

Generated on Fri May 16 00:25:12 2008 for FLOPC++ by  doxygen 1.4.7