FlopCpp trunk
Loading...
Searching...
No Matches
MP_model.hpp
Go to the documentation of this file.
1// ******************** FlopCpp **********************************************
2// File: MP_model.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_model_hpp_
10#define _MP_model_hpp_
11
12#include <ostream>
13#include <vector>
14#include <set>
15#include <string>
16
17#include "MP_expression.hpp"
18#include "MP_constraint.hpp"
19#include <CoinPackedVector.hpp>
21
22namespace flopc {
23
24 class MP_variable;
25 class MP_index;
26 class MP_set;
27
35 class Messenger {
36 public:
37 virtual void logMessage(int level, const char * const msg){}
38 friend class MP_model;
39 private:
40 virtual void constraintDebug(std::string name, const std::vector<Coef>& cfs) {}
41 virtual void objectiveDebug(const std::vector<Coef>& cfs) {}
42 virtual void statistics(int bm, int m, int bn, int n, int nz) {}
43 virtual void generationTime(double t) {}
44 protected:
45 virtual ~Messenger() {}
46 };
47
51 class NormalMessenger : public Messenger {
52 friend class MP_model;
53 private:
54 virtual void statistics(int bm, int m, int bn, int n, int nz);
55 virtual void generationTime(double t);
56 };
57
62 friend class MP_model;
63 private:
64 virtual void constraintDebug(std::string name, const std::vector<Coef>& cfs);
65 virtual void objectiveDebug(const std::vector<Coef>& cfs);
66 };
67
89 class MP_model {
90 friend class MP_constraint;
91 public:
93 typedef enum {MINIMIZE=1, MAXIMIZE=-1} MP_direction;
94
115
118
120 delete messenger;
121 }
122
131 return mSolverState;
132 }
133
134 void silent() {
135 delete messenger;
136 messenger = new Messenger;
137 }
138
139 void verbose() {
140 delete messenger;
141 messenger = new VerboseMessenger;
142 }
143
146 Solver = s;
147 }
148
151 return Solver;
152 }
153
156
160 void maximize();
164 void maximize(const MP_expression &obj);
168 void minimize();
172 void minimize(const MP_expression &obj);
173
177 void minimize_max(MP_set& d, const MP_expression &obj);
178
191 void attach(OsiSolverInterface *solver=NULL);
198 void detach();
211 const double* solution;
212 const double* reducedCost;
213 const double* rowPrice;
214 const double* rowActivity;
218 double getInfinity() const;
219
221 void add(MP_variable* v);
223 void addRow(const Constraint& c);
224
236 return messenger;
237 }
238 private:
239 typedef std::set<MP_variable* >::iterator varIt;
240 typedef std::set<MP_constraint* >::iterator conIt;
241 static MP_model& default_model;
242 static MP_model* current_model;
243 MP_model(const MP_model&);
244 MP_model& operator=(const MP_model&);
245
246 Messenger* messenger;
247
248
249 static void assemble(std::vector<Coef>& v, std::vector<Coef>& av);
250 void add(MP_constraint* c);
251 MP_expression Objective;
252 std::set<MP_constraint *> Constraints;
253 std::set<MP_variable *> Variables;
254 public:
257 private:
258 int m;
259 int n;
260 int nz;
261 int *Cst;
262 int *Clg;
263 int *Rnr;
264 double *Elm;
265 double *bl;
266 double *bu;
267 double *c;
268 double *l;
269 double *u;
270 MP_status mSolverState;
271 };
272
274 std::ostream &operator<<(std::ostream &os,
275 const MP_model::MP_status &condition);
277 std::ostream &operator<<(std::ostream &os,
278 const MP_model::MP_direction &direction);
279
280} // End of namespace flopc
281#endif
Semantic representation of a constraint in a Math Program.
Semantic representation of a linear constraint.
Symbolic representation of a linear expression.
Representation of an index.
Definition MP_index.hpp:53
This is the anchor point for all constructs in a FlopC++ model.
Definition MP_model.hpp:89
MP_model(OsiSolverInterface *s, Messenger *m=new NormalMessenger)
Constructs an MP_model from an OsiSolverInterface *.
OsiSolverInterface * Solver
Definition MP_model.hpp:256
void maximize(const MP_expression &obj)
Binds the data and calls the solver to maximize the parameter obj objective expression.
void attach(OsiSolverInterface *solver=NULL)
attaches the symantic representation of a model and data to a particular OsiSolverInterface
void addRow(const Constraint &c)
Adds a constraint to the MP_model.
void add(MP_variable *v)
Adds a variable to the MP_model.
MP_status
Reflects the state of the solution from solve()
Definition MP_model.hpp:97
@ ABANDONED
if solve is called and solver abandons the problem (time?
Definition MP_model.hpp:106
@ OPTIMAL
if the solve method is called and the optimal solution found.
Definition MP_model.hpp:99
@ PRIMAL_INFEASIBLE
if solve is called and solver finds model primal infeasible.
Definition MP_model.hpp:101
@ SOLVER_ONLY
A solver is placed in the constructor, but it is not yet attached or solved.
Definition MP_model.hpp:109
@ ATTACHED
A solver is attached, but not yet solved.
Definition MP_model.hpp:111
@ DUAL_INFEASIBLE
if solve is called and solver finds the model dual infeasible.
Definition MP_model.hpp:103
@ DETACHED
No solver is attached.
Definition MP_model.hpp:113
Messenger * getMessenger()
Gets the current messenger.
Definition MP_model.hpp:235
void minimize_max(MP_set &d, const MP_expression &obj)
Binds the data and calls the solver to minimize maximum value of the parameter obj objective expressi...
friend class MP_constraint
Definition MP_model.hpp:90
void silent()
used to silence FlopC++
Definition MP_model.hpp:134
OsiSolverInterface * operator->()
allows access to the OsiSolverInterface *
Definition MP_model.hpp:150
const double * rowPrice
Definition MP_model.hpp:213
void verbose()
used to help understanding and debugging FlopC++'s behavior.
Definition MP_model.hpp:139
MP_direction
used when calling the solve() method.
Definition MP_model.hpp:93
const double * rowActivity
Definition MP_model.hpp:214
const double * solution
Accessors for the results after a call to maximize()/minimize()
Definition MP_model.hpp:211
double getInfinity() const
Useful for getting an appropriate value to pass in as "infinity".
void setSolver(OsiSolverInterface *s)
allows for replacement of the solver used.
Definition MP_model.hpp:145
static MP_model & getDefaultModel()
Can be used to get the default model.
static MP_model * getCurrentModel()
Can be used to get the current model.
void detach()
detaches an OsiSolverInterface object from the model.
void minimize(const MP_expression &obj)
Binds the data and calls the solver to minimize the parameter obj objective expression.
MP_model::MP_status solve(const MP_model::MP_direction &dir)
calls the appropriate solving methods in the OsiSolverInterface.
void maximize()
Binds the data and calls the solver to maximize the current objective expression.
const double * reducedCost
Definition MP_model.hpp:212
void setObjective(const MP_expression &o)
sets the "current objective" to the parameter o
MP_model & add(MP_constraint &c)
Adds a constrataint block to the model.
void minimize()
Binds the data and calls the solver to minimize the current objective expression.
MP_status getStatus() const
Returns the current status of the model-solver interaction.
Definition MP_model.hpp:130
Representation of a set for indexing into some other construct.
Definition MP_set.hpp:78
Symantic representation of a variable.
Inteface for hooking up to internal flopc++ message handling.
Definition MP_model.hpp:35
friend class MP_model
Definition MP_model.hpp:38
virtual ~Messenger()
Definition MP_model.hpp:45
virtual void logMessage(int level, const char *const msg)
Definition MP_model.hpp:37
Internal use: used when Normal output is selected.
Definition MP_model.hpp:51
friend class MP_model
Definition MP_model.hpp:52
Internal use: used when Verbose output is selected.
Definition MP_model.hpp:61
friend class MP_model
Definition MP_model.hpp:62
All flopc++ code is contained within the flopc namespace.
Definition flopc.hpp:49
std::ostream & operator<<(std::ostream &os, const MP_model::MP_status &condition)
allows print of result from call to solve();