MP_constraint.hpp

Go to the documentation of this file.
00001 // ******************** FlopCpp **********************************************
00002 // File: MP_constraint.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_constraint_hpp_
00010 #define _MP_constraint_hpp_
00011 
00012 #include <set>
00013 using std::set;
00014 
00015 #include <map>
00016 using std::map;
00017 
00018 #include "MP_set.hpp"
00019 #include "MP_domain.hpp"
00020 #include "MP_utilities.hpp"
00021 #include "MP_expression.hpp"
00022 #include "MP_boolean.hpp"
00023 #include "MP_data.hpp"
00024 
00025 namespace flopc {
00026 
00027   class MP_constraint;
00028   class Constant;
00029   class MP_model;
00030   class MP_variable;
00031 
00035   enum  Sense_enum {LE,GE,EQ};
00036 
00042   class Constraint {
00043     friend class MP_constraint;
00044     friend class MP_model;
00045     friend Constraint operator<=(const MP_expression& l, const MP_expression& r);
00046     friend Constraint operator<=(const Constant& l, const MP_expression& r); 
00047     friend Constraint operator<=(const MP_expression& l, const Constant& r); 
00048     friend Constraint operator<=(const VariableRef& l, const VariableRef& r); 
00049 
00050     friend Constraint operator>=(const MP_expression& l, const MP_expression& r);
00051     friend Constraint operator>=(const Constant& l, const MP_expression& r); 
00052     friend Constraint operator>=(const MP_expression& l, const Constant& r); 
00053     friend Constraint operator>=(const VariableRef& l, const VariableRef& r);
00054 
00055     friend Constraint operator==(const MP_expression& l, const MP_expression& r);
00056     friend Constraint operator==(const Constant& l, const MP_expression& r); 
00057     friend Constraint operator==(const MP_expression& l, const Constant& r); 
00058     friend Constraint operator==(const VariableRef& l, const VariableRef& r); 
00059   private:
00060     Constraint(const MP_expression& l, const MP_expression& r, Sense_enum s) : 
00061       left(l), right(r), sense(s) {}
00062 
00063     MP_expression left,right;
00064     Sense_enum sense;
00065   };
00066 
00072   inline Constraint operator<=(const MP_expression& l, const MP_expression& r) {
00073     return Constraint(l, r, LE);
00074   }
00080   inline Constraint operator<=(const Constant& l, const MP_expression& r) {
00081     return operator<=(MP_expression(l), r);
00082   }
00088   inline Constraint operator<=(const MP_expression& l, const Constant& r){
00089     return operator<=(l, MP_expression(r));
00090   }
00096   inline Constraint operator<=(const VariableRef& l, const VariableRef& r) {
00097     return *new Constraint(l, r, LE);
00098   }
00099     
00105   inline Constraint operator>=(const MP_expression& l, const MP_expression& r) {
00106     return *new Constraint(l, r, GE);
00107   }
00113   inline Constraint operator>=(const Constant& l, const MP_expression& r){
00114     return operator>=(MP_expression(l), r);
00115   }
00121   inline Constraint operator>=(const MP_expression& l, const Constant& r){
00122     return operator>=(l, MP_expression(r));
00123   }
00129   inline Constraint operator>=(const VariableRef& l, const VariableRef& r) {
00130     return *new Constraint(l, r, GE);
00131   }
00132     
00138   inline Constraint operator==(const MP_expression& l, const MP_expression& r) {
00139     return *new Constraint(l, r, EQ);
00140   }
00146   inline Constraint operator==(const Constant& l, const MP_expression& r){
00147     return operator==(MP_expression(l), r);
00148   }
00154   inline Constraint operator==(const MP_expression& l, const Constant& r) {
00155     return operator==(l, MP_expression(r));
00156   }
00162   inline Constraint operator==(const VariableRef& l, const VariableRef& r) {
00163     return *new Constraint(l, r, EQ);
00164   }
00165 
00166 
00167   class GenerateFunctor;
00168 
00197   class MP_constraint : public RowMajor, public Named {
00198   public: 
00200     MP_constraint(
00201       const MP_set_base &s1 = MP_set::getEmpty(), 
00202       const MP_set_base &s2 = MP_set::getEmpty(), 
00203       const MP_set_base &s3 = MP_set::getEmpty(),
00204       const MP_set_base &s4 = MP_set::getEmpty(), 
00205       const MP_set_base &s5 = MP_set::getEmpty()
00206       );
00207 
00208     MP_constraint& operator()(
00209       const MP_index_exp& i1 = MP_index_exp::getEmpty(), 
00210       const MP_index_exp& i2 = MP_index_exp::getEmpty(), 
00211       const MP_index_exp& i3 = MP_index_exp::getEmpty(), 
00212       const MP_index_exp& i4 = MP_index_exp::getEmpty(), 
00213       const MP_index_exp& i5 = MP_index_exp::getEmpty()
00214       )  {
00215       I1 = i1; I2 = i2; I3 = i3; I4 = i4; I5 = i5;
00216       return *this;
00217     }
00218 
00219     operator int() {
00220       return offset + f(I1->evaluate(),I2->evaluate(),I3->evaluate(),
00221                         I4->evaluate(),I5->evaluate());
00222     }
00223 
00224     virtual ~MP_constraint() {}
00225 
00226     double price(int i1=0, int i2=0, int i3=0, int i4=0, int i5=0) const;
00227 
00228     void coefficients(GenerateFunctor& f);
00229 
00230     int row_number() const;
00231 
00232     MP_constraint& such_that(const MP_boolean& b) {
00233       B = b; 
00234       return *this; 
00235     }
00236 
00237     void insertVariables(set<MP_variable*>& v);
00238 
00239     void operator=(const Constraint& v); 
00240     
00241     void display(string s="") const;
00242 
00243     MP_model* M;
00244     int offset;
00245     MP_expression left,right;
00246     Sense_enum sense;
00247   private:
00248     MP_boolean B;
00249     const MP_set_base &S1, &S2, &S3, &S4, &S5; 
00250     MP_index_exp I1, I2, I3, I4, I5;
00251   };
00252 
00253 }  // End of namespace flopc
00254 #endif

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