# flopc::MP_model Class Reference
[Public interface]

This is the anchor point for all constructs in a FlopC++ model. More...

`#include <MP_model.hpp>`

Collaboration diagram for flopc::MP_model:
[legend]

List of all members.

## Public Types
enum | MP_direction { MINIMIZE = 1, MAXIMIZE = -1 }
| used when calling the solve() method. More...
enum | MP_status { OPTIMAL, PRIMAL_INFEASIBLE, DUAL_INFEASIBLE, ABANDONED, SOLVER_ONLY, ATTACHED, DETACHED }
| Reflects the state of the solution from solve(). More...
## Public Member Functions
| MP_model (OsiSolverInterface *s, Messenger *m=new NormalMessenger)
| Constructs an MP_model from an OsiSolverInterface *.
| ~MP_model ()
MP_status | getStatus () const
| Returns the current status of the model-solver interaction.
void | silent ()
| used to silence FlopC++
void | verbose ()
| used to help understanding and debugging FlopC++'s behavior.
void | setSolver (OsiSolverInterface *s)
| allows for replacement of the solver used.
OsiSolverInterface * | operator-> ()
| allows access to the OsiSolverInterface *
MP_model & | add (MP_constraint &c)
| Adds a constrataint block to the model.
void | maximize ()
| Binds the data and calls the solver to maximize the current objective expression.
void | maximize (const MP_expression &obj)
| Binds the data and calls the solver to maximize the parameter obj objective expression.
void | minimize ()
| Binds the data and calls the solver to minimize the current objective expression.
void | minimize (const MP_expression &obj)
| Binds the data and calls the solver to minimize the parameter obj objective expression.
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 expression.
void | setObjective (const MP_expression &o)
| sets the "current objective" to the parameter o
void | attach (OsiSolverInterface *solver=NULL)
| attaches the symantic representation of a model and data to a particular OsiSolverInterface
void | detach ()
| detaches an OsiSolverInterface object from the model.
MP_model::MP_status | solve (const MP_model::MP_direction &dir)
| calls the appropriate solving methods in the OsiSolverInterface.
double | getInfinity () const
| Useful for getting an appropriate value to pass in as "infinity".
void | add (MP_variable *v)
| Adds a variable to the MP_model.
void | addRow (const Constraint &c)
| Adds a constraint to the MP_model.
Messenger * | getMessenger ()
| Gets the current messenger.
## Static Public Member Functions
static MP_model & | getDefaultModel ()
| Can be used to get the default model.
static MP_model * | getCurrentModel ()
| Can be used to get the current model.
## Public Attributes
const double * | solution
| Accessors for the results after a call to maximize()/minimize().
const double * | reducedCost
const double * | rowPrice
const double * | rowActivity
OsiSolverInterface * | Solver
## Private Types
typedef std::set< MP_variable * > ::iterator | varIt
typedef std::set < MP_constraint * >::iterator | conIt
## Private Member Functions
| MP_model (const MP_model &)
MP_model & | operator= (const MP_model &)
void | add (MP_constraint *c)
## Static Private Member Functions
static void | assemble (std::vector< Coef > &v, std::vector< Coef > &av)
## Private Attributes
Messenger * | messenger
MP_expression | Objective
std::set< MP_constraint * > | Constraints
std::set< MP_variable * > | Variables
int | m
int | n
int | nz
int * | Cst
int * | Clg
int * | Rnr
double * | Elm
double * | bl
double * | bu
double * | c
double * | l
double * | u
MP_status | mSolverState
## Static Private Attributes
static MP_model & | default_model
static MP_model * | current_model
## Friends
class | MP_constraint

## Detailed Description

This is the anchor point for all constructs in a FlopC++ model.

The constructors take an OsiSolverInterface, and (optionally) a replacemente for the Messenger class. There are some built-in changes to the verbosity for output.
The main methods to use are:

- add(MP_constraint & c)
- add(MP_variable* v)
- maximize() and minimize()
  The main ideas are to construct a model, construct domains where things are defined over, then construct variables, constraints, and add them in. Finally, one attaches data and the model is "complete". Then minimize is called, the model is attached and the OsiSolverInterface is called.
  Note:
    There are variations on adding objectives and maximize/minimize
  See also:
    verbose()
    silent().
    Messenger

Definition at line 89 of file MP_model.hpp.

## Member Typedef Documentation

typedef std::set<MP_variable* >::iterator flopc::MP_model::varIt`[private]`

Definition at line 239 of file MP_model.hpp.

typedef std::set<MP_constraint* >::iterator flopc::MP_model::conIt`[private]`

Definition at line 240 of file MP_model.hpp.

## Member Enumeration Documentation

enum flopc::MP_model::MP_direction

used when calling the solve() method.

Enumerator:

  MINIMIZE |
  MAXIMIZE |

Definition at line 93 of file MP_model.hpp.

enum flopc::MP_model::MP_status

Reflects the state of the solution from solve().

Enumerator:

  OPTIMAL | if the solve method is called and the optimal solution found.
  PRIMAL_INFEASIBLE | if solve is called and solver finds model primal infeasible.
  DUAL_INFEASIBLE | if solve is called and solver finds the model dual infeasible.
  ABANDONED | if solve is called and solver abandons the problem (time?, iter limit?)
  SOLVER_ONLY | A solver is placed in the constructor, but it is not yet attached or solved.
  ATTACHED | A solver is attached, but not yet solved.
  DETACHED | No solver is attached.

Definition at line 97 of file MP_model.hpp.

## Constructor & Destructor Documentation

flopc::MP_model::MP_model | ( | OsiSolverInterface * | s,
|  | Messenger * | m = `new NormalMessenger` |
| ) |  |  |

Constructs an MP_model from an OsiSolverInterface *.

flopc::MP_model::~MP_model | ( |  | ) | `[inline]`

Definition at line 119 of file MP_model.hpp.

flopc::MP_model::MP_model | ( | const MP_model & |  | ) | `[private]`

## Member Function Documentation

MP_status flopc::MP_model::getStatus | ( |  | ) | const`[inline]`

Returns the current status of the model-solver interaction.

This method will return the current understanding of the model in regard to the solver's state.

Note:
  It is not kept up to date if a call is made directly to the solver. Only if the MP_model interface is used.

See also:
  MP_status

Definition at line 130 of file MP_model.hpp.

void flopc::MP_model::silent | ( |  | ) | `[inline]`

used to silence FlopC++

Definition at line 134 of file MP_model.hpp.

void flopc::MP_model::verbose | ( |  | ) | `[inline]`

used to help understanding and debugging FlopC++'s behavior.

Definition at line 139 of file MP_model.hpp.

void flopc::MP_model::setSolver | ( | OsiSolverInterface * | s | ) | `[inline]`

allows for replacement of the solver used.

Definition at line 145 of file MP_model.hpp.

OsiSolverInterface* flopc::MP_model::operator-> | ( |  | ) | `[inline]`

allows access to the OsiSolverInterface *

Definition at line 150 of file MP_model.hpp.

MP_model& flopc::MP_model::add | ( | MP_constraint & | c | ) |

Adds a constrataint block to the model.

void flopc::MP_model::maximize | ( |  | ) |

Binds the data and calls the solver to maximize the current objective expression.

void flopc::MP_model::maximize | ( | const MP_expression & | obj | ) |

Binds the data and calls the solver to maximize the parameter obj objective expression.

void flopc::MP_model::minimize | ( |  | ) |

Binds the data and calls the solver to minimize the current objective expression.

void flopc::MP_model::minimize | ( | const MP_expression & | obj | ) |

Binds the data and calls the solver to minimize the parameter obj objective expression.

void flopc::MP_model::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 expression.

void flopc::MP_model::setObjective | ( | const MP_expression & | o | ) |

sets the "current objective" to the parameter o

void flopc::MP_model::attach | ( | OsiSolverInterface * | solver = `NULL` | ) |

attaches the symantic representation of a model and data to a particular OsiSolverInterface

Note:
  this is called as a part of minimize(), maximize(), and minimize_max(); This takes the symantic representation of the model, generates coefficients for the matrices and adds them into the OsiSolverInterface. The OsiSolverInterface may be specified at construction time, or as late as the call to attach()

void flopc::MP_model::detach | ( |  | ) |

detaches an OsiSolverInterface object from the model.

In essence, this will clean up any intermediate storage. A model may then be attached to another solverInterface.

Note:
  a solver may only be attached to one solver at a time

Todo:
  verify that on "attach", old solver is detached.

MP_model::MP_status flopc::MP_model::solve | ( | const MP_model::MP_direction & | dir | ) |

calls the appropriate solving methods in the OsiSolverInterface.

Note:
  this is called as a part of minimize(), maximize(), and minimize_max() It expects that the object function is already set and only the direction is to be specified.

Todo:
  should the direction be defaulted?

double flopc::MP_model::getInfinity | ( |  | ) | const

Useful for getting an appropriate value to pass in as "infinity".

Note:
  some solvers may be more or less sensitive to the value.

void flopc::MP_model::add | ( | MP_variable * | v | ) |

Adds a variable to the MP_model.

void flopc::MP_model::addRow | ( | const Constraint & | c | ) |

Adds a constraint to the MP_model.

static MP_model& flopc::MP_model::getDefaultModel | ( |  | ) | `[static]`

Can be used to get the default model.

Todo:
  explain the default and current model concepts.

static MP_model* flopc::MP_model::getCurrentModel | ( |  | ) | `[static]`

Can be used to get the current model.

Todo:
  explain the default and current model concepts.

Messenger* flopc::MP_model::getMessenger | ( |  | ) | `[inline]`

Gets the current messenger.

Definition at line 235 of file MP_model.hpp.

MP_model& flopc::MP_model::operator= | ( | const MP_model & |  | ) | `[private]`

static void flopc::MP_model::assemble | ( | std::vector< Coef > & | v,
|  | std::vector< Coef > & | av |
| ) |  |  | `[static, private]`

void flopc::MP_model::add | ( | MP_constraint * | c | ) | `[private]`

## Friends And Related Function Documentation

friend class MP_constraint`[friend]`

Definition at line 90 of file MP_model.hpp.

## Member Data Documentation

const double* flopc::MP_model::solution

Accessors for the results after a call to maximize()/minimize().

Todo:

  should these be private with accessors? What if not set yet?

  what if not a complete result? What if only one LP in the IP?

Definition at line 211 of file MP_model.hpp.

const double* flopc::MP_model::reducedCost

Definition at line 212 of file MP_model.hpp.

const double* flopc::MP_model::rowPrice

Definition at line 213 of file MP_model.hpp.

const double* flopc::MP_model::rowActivity

Definition at line 214 of file MP_model.hpp.

MP_model& flopc::MP_model::default_model`[static, private]`

Definition at line 241 of file MP_model.hpp.

MP_model* flopc::MP_model::current_model`[static, private]`

Definition at line 242 of file MP_model.hpp.

Messenger* flopc::MP_model::messenger`[private]`

Definition at line 246 of file MP_model.hpp.

MP_expression flopc::MP_model::Objective`[private]`

Definition at line 251 of file MP_model.hpp.

std::set<MP_constraint *> flopc::MP_model::Constraints`[private]`

Definition at line 252 of file MP_model.hpp.

std::set<MP_variable *> flopc::MP_model::Variables`[private]`

Definition at line 253 of file MP_model.hpp.

OsiSolverInterface* flopc::MP_model::Solver

Todo:
  should this be private?

Definition at line 256 of file MP_model.hpp.

int flopc::MP_model::m`[private]`

Definition at line 258 of file MP_model.hpp.

int flopc::MP_model::n`[private]`

Definition at line 259 of file MP_model.hpp.

int flopc::MP_model::nz`[private]`

Definition at line 260 of file MP_model.hpp.

int* flopc::MP_model::Cst`[private]`

Definition at line 261 of file MP_model.hpp.

int* flopc::MP_model::Clg`[private]`

Definition at line 262 of file MP_model.hpp.

int* flopc::MP_model::Rnr`[private]`

Definition at line 263 of file MP_model.hpp.

double* flopc::MP_model::Elm`[private]`

Definition at line 264 of file MP_model.hpp.

double* flopc::MP_model::bl`[private]`

Definition at line 265 of file MP_model.hpp.

double* flopc::MP_model::bu`[private]`

Definition at line 266 of file MP_model.hpp.

double* flopc::MP_model::c`[private]`

Definition at line 267 of file MP_model.hpp.

double* flopc::MP_model::l`[private]`

Definition at line 268 of file MP_model.hpp.

double* flopc::MP_model::u`[private]`

Definition at line 269 of file MP_model.hpp.

MP_status flopc::MP_model::mSolverState`[private]`

Definition at line 270 of file MP_model.hpp.

The documentation for this class was generated from the following file:

- /home/coin/svn-release/Smi-0.93.1/FlopCpp/src/MP_model.hpp