FlopCpp  trunk
MP_expression.hpp
Go to the documentation of this file.
1 // ******************** FlopCpp **********************************************
2 // File: MP_expression.hpp
3 // $Id$
4 // Author: Tim Helge Hultberg (thh@mat.ua.pt)
5 // Copyright (C) 2003 Tim Helge Hultberg
6 // All Rights Reserved.
7 // ****************************************************************************
8 
9 #ifndef _MP_expression_hpp_
10 #define _MP_expression_hpp_
11 
12 #include <vector>
13 #include <set>
14 
15 #include "MP_domain.hpp"
16 #include "MP_constant.hpp"
17 #include "MP_utilities.hpp"
18 
19 namespace flopc {
20 
21  class Boolean;
22  class MP_domain;
23  class MP_constraint;
24  class Row;
25  class MP_variable;
26  class VariableRef;
27  class CoefLess;
28 
34  struct Coef {
35  Coef(int c, int r, double v, int s = 0) :
36  col(c), row(r), stage(s), val(v) {}
37  int col, row, stage;
38  double val;
39  };
40 
41  class TerminalExpression;
42 
48  class GenerateFunctor : public Functor {
49  public:
50  GenerateFunctor(std::vector<Coef>& coefs) : Coefs(coefs) {}
51 
52  virtual ~GenerateFunctor(){}
53 
55  R = r;
56  }
57  void setMultiplicator(std::vector<Constant>& mults, double m) {
58  multiplicators = mults;
59  m_ = m;
60  }
62  C = c;
63  }
64  virtual int row_number() const;
65 
66  void operator()() const;
67 
68  double m_;
69  std::vector<Constant> multiplicators;
72  std::vector<Coef>& Coefs;
73  };
74 
81  public:
82  ObjectiveGenerateFunctor(std::vector<Coef>& coefs) : GenerateFunctor(coefs) {}
83  virtual int row_number() const {
84  return -1;
85  }
86  };
87 
94  friend class MP_expression;
95  friend class Handle<MP_expression_base*>;
96  private:
97  int count;
98  public:
99  MP_expression_base() : count(0) {}
100 
101  virtual double level() const = 0;
102  virtual void generate(const MP_domain& domain,
103  std::vector<Constant> multiplicators,
104  GenerateFunctor& f,
105  double m) const = 0;
106  virtual void insertVariables(std::set<MP_variable*>& v) const = 0;
107 
108  virtual ~MP_expression_base() {}
109  };
110 
122  class MP_expression : public Handle<MP_expression_base*> {
123  friend class MP_constraint;
124  public:
132  MP_expression(const Constant& c);
134  MP_expression(const VariableRef& v);
135  virtual ~MP_expression() {}
136  };
137 
145  public:
146  virtual double getValue() const = 0;
147  virtual int getColumn() const = 0;
148  virtual int getStage() const = 0;
149  };
150 
158  public:
160  left(e1),right(e2) {}
161  void insertVariables(std::set<MP_variable*>& v) const {
162  left->insertVariables(v);
163  right->insertVariables(v);
164  }
165  protected:
167  };
168 
170  MP_expression operator+(const MP_expression& e1, const MP_expression& e2);
174  MP_expression operator+(const MP_expression& e1, const Constant& e2);
178  MP_expression operator+(const Constant& e1, const MP_expression& e2);
182  MP_expression operator-(const MP_expression& e1, const MP_expression& e2);
186  MP_expression operator-(const MP_expression& e1, const Constant& e2);
190  MP_expression operator-(const Constant& e1, const MP_expression& e2);
194  MP_expression operator*(const Constant& e1, const MP_expression& e2);
198  MP_expression operator*(const MP_expression& e1, const Constant& e2);
202  MP_expression sum(const MP_domain& d, const MP_expression& e);
203 
204 } // End of namespace flopc
205 #endif
flopc::GenerateFunctor::~GenerateFunctor
virtual ~GenerateFunctor()
Definition: MP_expression.hpp:52
flopc::operator*
Constant operator*(const Constant &a, const Constant &b)
Returns the product of two constants.
flopc::Expression_operator::right
MP_expression right
Definition: MP_expression.hpp:166
flopc::Constant
Reference counted class for all "constant" types of data.
Definition: MP_constant.hpp:48
flopc::GenerateFunctor::GenerateFunctor
GenerateFunctor(std::vector< Coef > &coefs)
Definition: MP_expression.hpp:50
flopc::Functor
Function object.
Definition: MP_utilities.hpp:26
flopc::Expression_operator::insertVariables
void insertVariables(std::set< MP_variable * > &v) const
Definition: MP_expression.hpp:161
flopc::GenerateFunctor::setMultiplicator
void setMultiplicator(std::vector< Constant > &mults, double m)
Definition: MP_expression.hpp:57
flopc::MP_domain
Range over which some other constuct is defined.
Definition: MP_domain.hpp:61
flopc::MP_expression_base::insertVariables
virtual void insertVariables(std::set< MP_variable * > &v) const =0
flopc::GenerateFunctor::Coefs
std::vector< Coef > & Coefs
Definition: MP_expression.hpp:72
MP_domain.hpp
MP_utilities.hpp
flopc::Expression_operator::left
MP_expression left
Definition: MP_expression.hpp:166
flopc::ObjectiveGenerateFunctor::ObjectiveGenerateFunctor
ObjectiveGenerateFunctor(std::vector< Coef > &coefs)
Definition: MP_expression.hpp:82
flopc::Coef::stage
int stage
Definition: MP_expression.hpp:37
flopc::Handle
Utility for doing reference counted pointers.
Definition: MP_utilities.hpp:105
flopc::GenerateFunctor::R
MP_constraint * R
Definition: MP_expression.hpp:70
flopc::Coef::Coef
Coef(int c, int r, double v, int s=0)
Definition: MP_expression.hpp:35
flopc::ObjectiveGenerateFunctor::row_number
virtual int row_number() const
Definition: MP_expression.hpp:83
flopc::GenerateFunctor::row_number
virtual int row_number() const
flopc::GenerateFunctor
Functor to facilitate generation of coefficients.
Definition: MP_expression.hpp:48
flopc::GenerateFunctor::operator()
void operator()() const
flopc::operator-
Constant operator-(const Constant &a, const Constant &b)
Returns the difference of two constants.
flopc::MP_expression_base::generate
virtual void generate(const MP_domain &domain, std::vector< Constant > multiplicators, GenerateFunctor &f, double m) const =0
flopc::TerminalExpression::getValue
virtual double getValue() const =0
flopc::MP_expression::MP_expression
MP_expression()
default constructor
Definition: MP_expression.hpp:126
flopc::ObjectiveGenerateFunctor
Functor to facilitate generation of the objective function.
Definition: MP_expression.hpp:80
flopc::TerminalExpression::getColumn
virtual int getColumn() const =0
flopc::operator+
Constant operator+(const Constant &a, const Constant &b)
Returns the sum of two constants.
flopc::Coef
Internal representation of a Coefficient in a matrix.
Definition: MP_expression.hpp:34
flopc::MP_expression_base::~MP_expression_base
virtual ~MP_expression_base()
Definition: MP_expression.hpp:108
flopc::sum
Constant sum(const MP_domain &i, const Constant &e)
Returns the sum of two constants.
flopc::Expression_operator
The base class for all expressions.
Definition: MP_expression.hpp:157
flopc::Coef::val
double val
Definition: MP_expression.hpp:38
flopc::GenerateFunctor::setTerminalExpression
void setTerminalExpression(const TerminalExpression *c)
Definition: MP_expression.hpp:61
flopc::GenerateFunctor::m_
double m_
Definition: MP_expression.hpp:68
flopc
All flopc++ code is contained within the flopc namespace.
Definition: flopc.hpp:49
flopc::VariableRef
Semantic representation of a variable in a Math Program.
Definition: MP_variable.hpp:35
flopc::MP_expression
Symbolic representation of a linear expression.
Definition: MP_expression.hpp:122
flopc::MP_expression::MP_expression
MP_expression(MP_expression_base *r)
Constructor for internal use.
Definition: MP_expression.hpp:130
flopc::MP_expression_base::level
virtual double level() const =0
flopc::GenerateFunctor::C
const TerminalExpression * C
Definition: MP_expression.hpp:71
flopc::GenerateFunctor::multiplicators
std::vector< Constant > multiplicators
Definition: MP_expression.hpp:69
flopc::MP_constraint
Semantic representation of a linear constraint.
Definition: MP_constraint.hpp:194
flopc::MP_expression::~MP_expression
virtual ~MP_expression()
Definition: MP_expression.hpp:135
flopc::TerminalExpression
The base class for all expressions.
Definition: MP_expression.hpp:144
flopc::MP_expression_base::MP_expression_base
MP_expression_base()
Definition: MP_expression.hpp:99
MP_constant.hpp
flopc::TerminalExpression::getStage
virtual int getStage() const =0
flopc::Coef::row
int row
Definition: MP_expression.hpp:37
flopc::Coef::col
int col
Definition: MP_expression.hpp:37
flopc::Expression_operator::Expression_operator
Expression_operator(const MP_expression &e1, const MP_expression &e2)
Definition: MP_expression.hpp:159
flopc::MP_expression_base
The base class for all expressions.
Definition: MP_expression.hpp:93
flopc::GenerateFunctor::setConstraint
void setConstraint(MP_constraint *r)
Definition: MP_expression.hpp:54