Minotaur::qpOASESEngine Class Reference

#include <qpOASESEngine.h>

Inheritance diagram for Minotaur::qpOASESEngine:

Collaboration diagram for Minotaur::qpOASESEngine:

Public Member Functions
	qpOASESEngine ()
	Default constructor.
	qpOASESEngine (EnvPtr env)
	Constructor using given environment options.
EnginePtr	emptyCopy ()
	Return an empty qpOASESEngine pointer.
void	load (ProblemPtr problem)
	Method to read the problem and initialize qpOASES.
void	clear ()
	Method to unload the current problem.
EngineStatus	solve ()
	Solve the problem that was loaded and report the status.
double	getSolutionValue ()
	Report the solution value from the last solve.
ConstSolutionPtr	getSolution ()
	Report the solution.
EngineStatus	getStatus ()
	Report the status of the last solve.
void	changeBound (ConstraintPtr cons, BoundType lu, double new_val)
	Change a bound of a constraint.
void	changeBound (VariablePtr var, BoundType lu, double new_val)
	Change a bound of a variable.
void	changeBound (VariablePtr var, double new_lb, double new_ub)
	Change both bounds of a variable.
void	addConstraint (ConstraintPtr)
	Add a new constraint to the engine.
void	changeObj (FunctionPtr f, double cb)
	Change objective function.
void	negateObj ()
	Negate the objective function. Min f is changed to Min -f.
void	changeConstraint (ConstraintPtr con, LinearFunctionPtr lf, const double &ub)
ConstWarmStartPtr	getWarmStart ()
WarmStartPtr	getWarmStartCopy ()
void	loadFromWarmStart (WarmStartPtr)
void	setIterationLimit (int limit)
int	setDualObjLimit (double)
	Set the dual objective limit.
void	resetIterationLimit ()
	Reset the iteration limit to maximum possible.
void	enableStrBrSetup ()
	Make settings for strong branching.
void	disableStrBrSetup ()
	Restore settings after strong branching.
void	writeStats ()
std::string	getName () const
	Get the name.
	~qpOASESEngine ()
	Destroy.
Public Member Functions inherited from Minotaur::QPEngine
	QPEngine ()
	Constructor. May set default parameters/options here.
Public Member Functions inherited from Minotaur::Engine
	Engine ()
	Default constructor.
virtual	~Engine ()
	Destroy.
virtual void	changeConstraint (ConstraintPtr c, LinearFunctionPtr lf, double lb, double ub)=0
	Change the linear function, and the bounds of a constraint.
virtual void	changeConstraint (ConstraintPtr c, NonlinearFunctionPtr nlf)=0
	Change the nonlinear function, and the bounds of a constraint.
virtual std::string	getStatusString ()
	Return a string that describes the status in simple words.
virtual LoggerPtr	getLogger ()
	Return pointer to the log manager.
virtual void	removeCons (std::vector< ConstraintPtr > &delcons)=0
	Delete constraints from the engine.
virtual void	setLogger (LoggerPtr logger)
	Set a new log manager.
virtual void	setOptionsForSingleSolve ()
virtual void	setOptionsForRepeatedSolve ()
	Set options to solve the NLP repeatedly, with few changes.
virtual void	writeStats (std::ostream &) const
virtual void	fillStats (std::vector< double > &)
	Accumulate statistics from different threads in a common data.

Friends
class	Problem

Additional Inherited Members
Protected Attributes inherited from Minotaur::Engine
EngineStatus	status_
	Status of the last solve.
LoggerPtr	logger_
	Keep log.

Detailed Description

qpOASESEngine is used to solve QP problems using the parametric primal-dual active set code qpOASES. qpOASES finds a KT point for the bounded QP problem

 minimize    f(x) = x'Hx/2 + g'x

 subject to  lb  <=   x <= ub
             lbA <= A.x <= ubA

where x and g are n-vectors, H is a symmetric n*n matrix, and A is an m*n matrix. If H is also positive semi-definite then the KT point is a global solution, else a stationary point.

Member Function Documentation

addConstraint()

void Minotaur::qpOASESEngine::addConstraint ( ConstraintPtr  )

inlinevirtual

Add a new constraint to the engine.

Implements Minotaur::Engine.

changeBound() [1/3]

void qpOASESEngine::changeBound ( ConstraintPtr  cons, BoundType  lu, double  new_val  )

virtual

Change a bound of a constraint.

Implements Minotaur::Engine.

changeBound() [2/3]

void qpOASESEngine::changeBound ( VariablePtr  var, BoundType  lu, double  new_val  )

virtual

Change a bound of a variable.

Implements Minotaur::Engine.

changeBound() [3/3]

void qpOASESEngine::changeBound ( VariablePtr  var, double  new_lb, double  new_ub  )

virtual

Change both bounds of a variable.

Implements Minotaur::Engine.

changeObj()

void qpOASESEngine::changeObj ( FunctionPtr  f, double  cb  )

virtual

Change objective function.

Implements Minotaur::Engine.

clear()

void qpOASESEngine::clear ( )

virtual

Method to unload the current problem.

Implements Minotaur::Engine.

disableStrBrSetup()

void qpOASESEngine::disableStrBrSetup ( )

virtual

Restore settings after strong branching.

Implements Minotaur::Engine.

emptyCopy()

EnginePtr qpOASESEngine::emptyCopy ( )

virtual

Return an empty qpOASESEngine pointer.

Reimplemented from Minotaur::Engine.

enableStrBrSetup()

void qpOASESEngine::enableStrBrSetup ( )

virtual

Make settings for strong branching.

Implements Minotaur::Engine.

getName()

std::string qpOASESEngine::getName ( ) const

virtual

Get the name.

Implements Minotaur::Engine.

getSolution()

ConstSolutionPtr qpOASESEngine::getSolution ( )

virtual

Report the solution.

Implements Minotaur::Engine.

getSolutionValue()

double qpOASESEngine::getSolutionValue ( )

virtual

Report the solution value from the last solve.

Implements Minotaur::Engine.

getStatus()

EngineStatus qpOASESEngine::getStatus ( )

virtual

Report the status of the last solve.

Implements Minotaur::Engine.

getWarmStart()

ConstWarmStartPtr qpOASESEngine::getWarmStart ( )

virtual

Get warm start information from the engine. This warm start information can change if the engine is used to solve something else again.

Implements Minotaur::Engine.

getWarmStartCopy()

WarmStartPtr qpOASESEngine::getWarmStartCopy ( )

virtual

Get a full copy of warm start information from the engine. Does not change even if the engine starts solving something else later on.

Implements Minotaur::Engine.

load()

void qpOASESEngine::load ( ProblemPtr  problem )

virtual

Method to read the problem and initialize qpOASES.

Implements Minotaur::Engine.

loadFromWarmStart()

void qpOASESEngine::loadFromWarmStart ( WarmStartPtr  ws )

virtual

Use warm start information for solving the next problem. May Create a copy of WarmStart and use the copy inside the engine; the copy (but not the original) gets updated after solving a relaxation.

Implements Minotaur::Engine.

negateObj()

void qpOASESEngine::negateObj ( )

virtual

Negate the objective function. Min f is changed to Min -f.

Implements Minotaur::Engine.

resetIterationLimit()

void qpOASESEngine::resetIterationLimit ( )

virtual

Reset the iteration limit to maximum possible.

Implements Minotaur::Engine.

setDualObjLimit()

int Minotaur::qpOASESEngine::setDualObjLimit ( double  )

inlinevirtual

Set the dual objective limit.

Implements Minotaur::Engine.

setIterationLimit()

void qpOASESEngine::setIterationLimit ( int  limit )

virtual

Set a limit on number of iterations. For strong-branching, for instance.

Implements Minotaur::Engine.

solve()

EngineStatus qpOASESEngine::solve ( )

virtual

Solve the problem that was loaded and report the status.

Implements Minotaur::Engine.

---

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

• /home/amahajan/tmp/minotaur-test/src/interfaces/qpOASESEngine.h
• /home/amahajan/tmp/minotaur-test/src/interfaces/qpOASESEngine.cpp