Handler for convex constraints, based on quesada-grossmann algorithm. More...

#include <ParQGHandlerAdvance.h>

Inheritance diagram for Minotaur::ParQGHandlerAdvance:

Collaboration diagram for Minotaur::ParQGHandlerAdvance:

Public Member Functions
	ParQGHandlerAdvance (EnvPtr env, ProblemPtr minlp, EnginePtr nlpe)
	Default Constructor. More...

	~ParQGHandlerAdvance ()
	Destroy.

Branches	getBranches (BrCandPtr, DoubleVector &, RelaxationPtr, SolutionPoolPtr)
	Does nothing. More...

void	getBranchingCandidates (RelaxationPtr, const DoubleVector &, ModVector &, BrVarCandSet &, BrCandVector &, bool &)
	Does nothing. More...

ModificationPtr	getBrMod (BrCandPtr, DoubleVector &, RelaxationPtr, BranchDirection)
	Does nothing. More...

std::string	getName () const
	Return the name of the handler. More...

ParQGStats *	getStats ()

void	nlCons ()

void	loadProbToEngine ()

void	setRelaxation (RelaxationPtr rel)

bool	isFeasible (ConstSolutionPtr sol, RelaxationPtr relaxation, bool &should_prune, double &inf_meas)
	Check if a solution is feasible. More...

SolveStatus	presolve (PreModQ , bool , Solution **)
	Does nothing. More...

bool	presolveNode (RelaxationPtr, NodePtr, SolutionPoolPtr, ModVector &, ModVector &)
	Does nothing. More...

void	postsolveGetX (const double , UInt, DoubleVector )
	Does nothing.

void	relaxInitFull (RelaxationPtr rel, SolutionPool , bool is_inf)
	Base class method. calls relax_(). More...

void	relaxInitInc (RelaxationPtr rel, SolutionPool , bool is_inf)
	Base class method. calls relax_(). More...

void	relaxNodeFull (NodePtr node, RelaxationPtr rel, bool *is_inf)
	Base class method. Does nothing. More...

void	relaxNodeInc (NodePtr node, RelaxationPtr rel, bool *is_inf)
	Base class method. Does nothing. More...

void	separate (ConstSolutionPtr sol, NodePtr node, RelaxationPtr rel, CutManager cutman, SolutionPoolPtr s_pool, ModVector &p_mods, ModVector &r_mods, bool sol_found, SeparationStatus *status)
	Base class method. Find cuts. More...

void	setObjVar ()
	Set oNl_ to true and objVar_ when problem objective is nonlinear.

void	solveCenterNLP_ (EnginePtr nlpe)

void	writeStats (std::ostream &out) const
	Show statistics. More...

Public Member Functions inherited from Minotaur::Handler
	Handler ()
	Default constructor.

virtual	~Handler ()
	Destroy.

virtual void	addConstraint (ConstraintPtr newcon)
	Add constraint to be handled by this handler. More...

virtual ConstraintVector::const_iterator	consBegin () const

virtual ConstraintVector::const_iterator	consEnd () const

virtual int	fixNodeErr (RelaxationPtr, ConstSolutionPtr, SolutionPoolPtr, bool &)

virtual Branches	getBranches (BrCandPtr cand, DoubleVector &x, RelaxationPtr rel, SolutionPoolPtr s_pool)=0
	Return branches for branching. More...

virtual void	getBranchingCandidates (RelaxationPtr rel, const DoubleVector &x, ModVector &mods, BrVarCandSet &cands, BrCandVector &gencands, bool &is_inf)=0
	find branching candidates. More...

virtual ModificationPtr	getBrMod (BrCandPtr cand, DoubleVector &x, RelaxationPtr rel, BranchDirection dir)=0
	Get the modifcation that creates a given (up or down) branch. More...

virtual std::string	getName () const =0
	Return the name of the handler. More...

bool	getStrongerMods (RelaxationPtr rel, NodePtr node, SolutionPoolPtr s_pool, ModVector &p_mods, ModVector &r_mods)
	do node presolve to get mods for stronger branching All params are presolveNode params.

virtual bool	isFeasible (ConstSolutionPtr sol, RelaxationPtr rel, bool &should_prune, double &inf_meas)=0
	Check if a solution is feasible. More...

virtual bool	isNeeded ()
	Return true if this handler is needed for the problem. More...

virtual SolveStatus	presolve (PreModQ pre_mods, bool changed, Solution **sol)=0
	Initial presolve. More...

virtual bool	presolveNode (RelaxationPtr rel, NodePtr node, SolutionPoolPtr s_pool, ModVector &p_mods, ModVector &r_mods)=0
	Presolve the problem and its relaxation at a node. More...

virtual bool	postSolveRootNode (RelaxationPtr, SolutionPoolPtr, ConstSolutionPtr, ModVector &, ModVector &)
	At the root node post solve the problem and its relaxation. LP based bound tightening (OBBT) is employed here after filtering variables for which no OBBT is required. More...

virtual void	relaxInitFull (RelaxationPtr rel, SolutionPool sp, bool is_inf)=0
	Create root relaxation if doing full node relaxations. More...

virtual void	relaxInitInc (RelaxationPtr rel, SolutionPool sp, bool is_inf)=0
	Create root relaxation if doing incremental node relaxations. More...

virtual void	relaxNodeFull (NodePtr node, RelaxationPtr rel, bool *is_inf)=0
	Create a relaxation for a node, building from scratch. More...

virtual void	relaxNodeInc (NodePtr node, RelaxationPtr rel, bool *is_inf)=0
	Create an incremental relaxation for a node. More...

virtual void	removeCuts (RelaxationPtr, ConstSolutionPtr)

virtual void	separate (ConstSolutionPtr sol, NodePtr node, RelaxationPtr rel, CutManager cutman, SolutionPoolPtr s_pool, ModVector &p_mods, ModVector &r_mods, bool sol_found, SeparationStatus *status)=0
	add cuts to separate a given point. More...

virtual void	setModFlags (bool mod_prob, bool mod_rel)
	Tell the handler whether the problem will be modified or the relaxation will be modified or both. These modifications will be saved in the tree as well. More...

virtual void	simplePresolve (ProblemPtr, SolutionPoolPtr, ModVector &, SolveStatus &status)

void	undoStrongerMods (ProblemPtr p, RelaxationPtr rel, ModVector &p_mods, ModVector &r_mods)
	Undo Modifications made during stronger branching. More...

virtual void	writeStats (std::ostream &) const
	Write statistics to ostream out. More...

Additional Inherited Members
Protected Attributes inherited from Minotaur::Handler
ConstraintVector	cons_

bool	modProb_
	If true, modify the original (or transformed) problem.

bool	modRel_
	If true, modify the relaxation of original (or transformed) problem.

Detailed Description

Handler for convex constraints, based on quesada-grossmann algorithm.

ParQGHandlerAdvance is a derived class of Handler. It adds cuts generated by solving an NLP whenever an integer (but infeasible) solution of LP relaxation is found. It considers nonlinear constraints in the form f(x) <= b.

Constructor & Destructor Documentation

◆ ParQGHandlerAdvance()

ParQGHandlerAdvance::ParQGHandlerAdvance	(	EnvPtr	env,
		ProblemPtr	minlp,
		EnginePtr	nlpe
	)

Default Constructor.

Parameters

[in]	env	Environment pointer.
[in]	minlp	The minlp for which cuts are generated (Not the relaxation.)
[in]	nlpe	The engine to solve nonlinear continuous problem.

Member Function Documentation

◆ getBranches()

Branches Minotaur::ParQGHandlerAdvance::getBranches	(	BrCandPtr	,
		DoubleVector &	,
		RelaxationPtr	,
		SolutionPoolPtr
	)

inlinevirtual

Does nothing.

Implements Minotaur::Handler.

◆ getBranchingCandidates()

void Minotaur::ParQGHandlerAdvance::getBranchingCandidates	(	RelaxationPtr	,
		const DoubleVector &	,
		ModVector &	,
		BrVarCandSet &	,
		BrCandVector &	,
		bool &
	)

inlinevirtual

Does nothing.

Implements Minotaur::Handler.

◆ getBrMod()

ModificationPtr Minotaur::ParQGHandlerAdvance::getBrMod	(	BrCandPtr	,
		DoubleVector &	,
		RelaxationPtr	,
		BranchDirection
	)

inlinevirtual

Does nothing.

Implements Minotaur::Handler.

◆ getName()

std::string ParQGHandlerAdvance::getName ( ) const

virtual

Return the name of the handler.

Implements Minotaur::Handler.

◆ isFeasible()

bool ParQGHandlerAdvance::isFeasible	(	ConstSolutionPtr	sol,
		RelaxationPtr	rel,
		bool &	should_prune,
		double &	inf_meas
	)

virtual

Check if a solution is feasible.

Check if a given solution is feasible for the constraints that are handled by this handler. should_prune is true if the handler finds that the problem itself is infeasible and the current node can be pruned (which is different from a solution not being feasible).

Parameters

[in]	sol	The solution of the relaxation whose feasibility we want to test.
[in]	rel	The relaxation.
[out]	should_prune	True if the relaxation is infeasible and we can prune the node associated.
[out]	inf_meas	A measure of infeasibility. It may be used by heuristics and other code to make the tree-search faster. Computing this value is optional.

Returns: True if sol is feasible for constraints/objective asociated with this handler. False if sol is not feasible.

Implements Minotaur::Handler.

◆ presolve()

SolveStatus Minotaur::ParQGHandlerAdvance::presolve	(	PreModQ *	,
		bool *	,
		Solution **
	)

inlinevirtual

Does nothing.

Implements Minotaur::Handler.

◆ presolveNode()

bool Minotaur::ParQGHandlerAdvance::presolveNode	(	RelaxationPtr	,
		NodePtr	,
		SolutionPoolPtr	,
		ModVector &	,
		ModVector &
	)

inlinevirtual

Does nothing.

Implements Minotaur::Handler.

◆ relaxInitFull()

void ParQGHandlerAdvance::relaxInitFull	(	RelaxationPtr	rel,
		SolutionPool *	,
		bool *	is_inf
	)

virtual

Base class method. calls relax_().

Implements Minotaur::Handler.

◆ relaxInitInc()

void ParQGHandlerAdvance::relaxInitInc	(	RelaxationPtr	rel,
		SolutionPool *	,
		bool *	is_inf
	)

virtual

Base class method. calls relax_().

Implements Minotaur::Handler.

◆ relaxNodeFull()

void ParQGHandlerAdvance::relaxNodeFull	(	NodePtr	node,
		RelaxationPtr	rel,
		bool *	is_inf
	)

virtual

Base class method. Does nothing.

Implements Minotaur::Handler.

◆ relaxNodeInc()

void ParQGHandlerAdvance::relaxNodeInc	(	NodePtr	node,
		RelaxationPtr	rel,
		bool *	is_inf
	)

virtual

Base class method. Does nothing.

Implements Minotaur::Handler.

◆ separate()

void ParQGHandlerAdvance::separate	(	ConstSolutionPtr	sol,
		NodePtr	node,
		RelaxationPtr	rel,
		CutManager *	cutman,
		SolutionPoolPtr	s_pool,
		ModVector &	p_mods,
		ModVector &	r_mods,
		bool *	sol_found,
		SeparationStatus *	status
	)

virtual

Base class method. Find cuts.

Implements Minotaur::Handler.

◆ writeStats()

void ParQGHandlerAdvance::writeStats ( std::ostream & out ) const

virtual

Show statistics.

Reimplemented from Minotaur::Handler.

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

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

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ParQGHandlerAdvance()

Member Function Documentation

◆ getBranches()

◆ getBranchingCandidates()

◆ getBrMod()

◆ getName()

◆ isFeasible()

◆ presolve()

◆ presolveNode()

◆ relaxInitFull()

◆ relaxInitInc()

◆ relaxNodeFull()

◆ relaxNodeInc()

◆ separate()

◆ writeStats()