FlopCpp trunk
Loading...
Searching...
No Matches
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
19namespace 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
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,
105 double m) const = 0;
106 virtual void insertVariables(std::set<MP_variable*>& v) const = 0;
107
109 };
110
122 class MP_expression : public Handle<MP_expression_base*> {
123 friend class MP_constraint;
124 public:
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
203
204} // End of namespace flopc
205#endif
Reference counted class for all "constant" types of data.
Expression_operator(const MP_expression &e1, const MP_expression &e2)
void insertVariables(std::set< MP_variable * > &v) const
Functor to facilitate generation of coefficients.
GenerateFunctor(std::vector< Coef > &coefs)
std::vector< Coef > & Coefs
virtual int row_number() const
std::vector< Constant > multiplicators
void setMultiplicator(std::vector< Constant > &mults, double m)
void operator()() const
void setTerminalExpression(const TerminalExpression *c)
const TerminalExpression * C
void setConstraint(MP_constraint *r)
Utility for doing reference counted pointers.
Handle(const MP_expression_base *&r)
Semantic representation of a linear constraint.
Range over which some other constuct is defined.
Definition MP_domain.hpp:61
The base class for all expressions.
virtual double level() const =0
virtual void insertVariables(std::set< MP_variable * > &v) const =0
virtual void generate(const MP_domain &domain, std::vector< Constant > multiplicators, GenerateFunctor &f, double m) const =0
Symbolic representation of a linear expression.
MP_expression(const VariableRef &v)
Constructor which (silently) converts a Variable to a MP_expression.
MP_expression(MP_expression_base *r)
Constructor for internal use.
MP_expression()
default constructor
MP_expression(const Constant &c)
Constructor which (silently) converts a Constant to a MP_expression.
Symantic representation of a variable.
ObjectiveGenerateFunctor(std::vector< Coef > &coefs)
The base class for all expressions.
virtual double getValue() const =0
virtual int getColumn() const =0
virtual int getStage() const =0
Semantic representation of a variable in a Math Program.
Constant operator+(const Constant &a, const Constant &b)
Returns the sum of two constants.
Constant sum(const MP_domain &i, const Constant &e)
Returns the sum of two constants.
Constant operator*(const Constant &a, const Constant &b)
Returns the product of two constants.
Constant operator-(const Constant &a, const Constant &b)
Returns the difference of two constants.
All flopc++ code is contained within the flopc namespace.
Definition flopc.hpp:49
Coef(int c, int r, double v, int s=0)