Minotaur::QuadTransformer Class Reference

Class for reformulating a problem using simple rules so that handlers can be applied to it. More...

#include <QuadTransformer.h>

Inheritance diagram for Minotaur::QuadTransformer:

Collaboration diagram for Minotaur::QuadTransformer:

Public Member Functions
	QuadTransformer ()
	Default Constructor.
	QuadTransformer (EnvPtr env, ProblemPtr p)
	Constructor.
	~QuadTransformer ()
	Destroy.
std::string	getName () const
	Get the name of this Transformer.
SolutionPtr	getSolOrig (ConstSolutionPtr sol, int &err)
	Translate the solution of reformulated problem into that of original problem.
SolutionPtr	getSolTrans (ConstSolutionPtr sol, int &err)
	Translate the solution of originial problem into that of reformulated problem.
void	reformulate (ProblemPtr &newp, HandlerVector &handlers, int &status)
	Perform the reformulation, and assign handlers.
Public Member Functions inherited from Minotaur::Transformer
	Transformer ()
	Default Constructor.
	Transformer (EnvPtr env, ProblemPtr oldp)
	Constructor.
virtual	~Transformer ()
	Destroy.

Additional Inherited Members
Protected Member Functions inherited from Minotaur::Transformer
bool	allConsAssigned_ (ProblemPtr p, HandlerVector &handlers)
	Check if all constraints in a problem have been assigned to a handler.
void	assignHandler_ (CGraphPtr cg, ConstraintPtr c)
	Assign an appropriate handler to a nonlinear constraint of the form .
void	clearUnusedHandlers_ (HandlerVector &handlers)
	Delete unused handlers.
void	copyLinear_ (ConstProblemPtr p, ProblemPtr newp)
	Copy all the linear constraints of the problem into the new problem.
void	copyVars_ (ConstProblemPtr p, ProblemPtr newp)
	Copy all the linear constraints of the problem into the new problem.
virtual void	makeObjLin_ ()
void	minObj_ ()
	Convert a maximization objective into minimization.
VariablePtr	newVar_ (VariablePtr iv, double d, ProblemPtr newp)
	Find the auxiliary variable associated with or create a new one.
VariablePtr	newVar_ (LinearFunctionPtr lf, double d, ProblemPtr newp)
	Find the auxiliary variable associated with or create a new one.
VariablePtr	newVar_ (CGraphPtr cg, ProblemPtr newp)
	Find the auxiliary variable associated with or create a new one.
VariablePtr	newVarAbs_ (VariablePtr vl, ProblemPtr newp)
Protected Attributes inherited from Minotaur::Transformer
EnvPtr	env_
	The pointer to environment.
AbsHandlerPtr	absHandler_
	Handler for absolute value constraint.
LinearHandlerPtr	lHandler_
	Handler for linear constraints and variables.
LogHandlerPtr	logHandler_
	Handler for Log Constraints.
ExpHandlerPtr	expHandler_
	Handler for Exponential Constraints.
PowHandlerPtr	powHandler_
	Handler for Power constraints.
RecipHandlerPtr	recipHandler_
	handler for y=1/x constraint
LoggerPtr	logger_
	Logger.
ProblemPtr	newp_
	The transformed problem.
ProblemPtr	p_
	The original problem.
kPowHandlerPtr	kHandler_
	Handler for y = x^k type constraints.
QuadHandlerPtr	qHandler_
	Handler for quadratic terms.
CxUnivarHandlerPtr	uHandler_
	Handler for univariate constraints.
UnivarQuadHandlerPtr	uqHandler_
	Handler for univariate quadratic constraints.
YEqLFs *	yLfs_
	Storage for auxiliary variables defined by relations of the form .
YEqUCGs *	yUniExprs_
	Storage for auxiliary variables defined by relations of the form .
YEqVars *	yVars_
	Storage for auxiliary variables defined by relations of the form .
std::map< VariablePtr, VariablePtr >	absVarCache_
const double	zTol_
	Tolerance for checking if a value is zero.

Detailed Description

Class for reformulating a problem using simple rules so that handlers can be applied to it.

Member Function Documentation

getName()

std::string QuadTransformer::getName ( ) const

virtual

Get the name of this Transformer.

Implements Minotaur::Transformer.

getSolOrig()

SolutionPtr QuadTransformer::getSolOrig ( ConstSolutionPtr  sol, int &  err  )

virtual

Translate the solution of reformulated problem into that of original problem.

Parameters

[in]	sol	Solution of the reformulated problem.
[out]	err	Zero if no error is encountered, nonzero otherwise.

Returns

Solution of original problem.

Implements Minotaur::Transformer.

getSolTrans()

SolutionPtr QuadTransformer::getSolTrans ( ConstSolutionPtr  sol, int &  err  )

virtual

Translate the solution of originial problem into that of reformulated problem.

Parameters

[in]	sol	Solution of the original problem.
[out]	err	Zero if no error is encountered, nonzero otherwise.

Returns

Solution of the reformulated problem.

Implements Minotaur::Transformer.

reformulate()

void QuadTransformer::reformulate ( ProblemPtr &  newp, HandlerVector &  handlers, int &  status  )

virtual

Perform the reformulation, and assign handlers.

Parameters

[out]	newp	The new, reformulated problem.
[out]	handlers	A vector of handlers used to reformulate the problem.
[out]	status	Zero if reformulated successfully. Nonzero otherwise.

Implements Minotaur::Transformer.

---

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

• /home/amahajan/tmp/minotaur-test/src/base/QuadTransformer.h
• /home/amahajan/tmp/minotaur-test/src/base/QuadTransformer.cpp