Base class for handling specific types of constraints or objective. More...

#include <Handler.h>

Inheritance diagram for Minotaur::Handler:

[legend]

Public Member Functions
	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...

Protected Attributes
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

Base class for handling specific types of constraints or objective.

A Handler is used to handle a particular kind of constraint/objective. It provides methods for creating a relaxation, checking if a given point is feasible, separating a given point and providing a branching candidate.

Member Function Documentation

◆ addConstraint()

virtual void Minotaur::Handler::addConstraint ( ConstraintPtr newcon )

inlinevirtual

Add constraint to be handled by this handler.

Parameters

[in] newcon Constraint to be added.

Reimplemented in Minotaur::kPowHandler, Minotaur::QuadHandler, Minotaur::UnivarQuadHandler, and Minotaur::CxUnivarHandler.

◆ consBegin()

virtual ConstraintVector::const_iterator Minotaur::Handler::consBegin ( ) const

inlinevirtual

Returns: The beginning of constraints handled by this handler.

Reimplemented in Minotaur::STOAHandler.

◆ consEnd()

virtual ConstraintVector::const_iterator Minotaur::Handler::consEnd ( ) const

inlinevirtual

Returns: The end of constraints handled by this handler.

Reimplemented in Minotaur::STOAHandler.

◆ fixNodeErr()

int Handler::fixNodeErr	(	RelaxationPtr	,
		ConstSolutionPtr	,
		SolutionPoolPtr	,
		bool &
	)

virtual

This function processes a node further if no branching candidates were found by the brancher. It is only implemented for QuadHandler as of now.

Reimplemented in Minotaur::kPowHandler, and Minotaur::QuadHandler.

◆ getBranches()

virtual Branches Minotaur::Handler::getBranches	(	BrCandPtr	cand,
		DoubleVector &	x,
		RelaxationPtr	rel,
		SolutionPoolPtr	s_pool
	)

pure virtual

Return branches for branching.

Get branches by branching on the given candidate. In the general scheme for branching, we store only bound changes, though we are also capable of storing other mods.

Parameters

[in]	cand	Candidate on which the brancher wants to branch.
[in]	x	The solution of the relaxation at the current node.
[in]	rel	The relaxation at the current node.
[in]	s_pool	Best feasible solutions found so far.

Returns: a vector of branch-objects.

Implemented in Minotaur::CxQuadHandler, Minotaur::CxUnivarHandler, Minotaur::IntVarHandler, Minotaur::kPowHandler, Minotaur::MultilinearHandler, Minotaur::MultilinearTermsHandler, Minotaur::QuadHandler, Minotaur::SOS1Handler, Minotaur::SOS2Handler, Minotaur::UnivarQuadHandler, Minotaur::KnapCovHandler, Minotaur::LinearHandler, Minotaur::NlPresHandler, Minotaur::OAHandler, Minotaur::ParQGHandler, Minotaur::ParQGHandlerAdvance, Minotaur::PerspCutHandler, Minotaur::QGAdvHandler, Minotaur::QGHandler, Minotaur::QGHandler, Minotaur::QGHandlerAdvance, Minotaur::RCHandler, and Minotaur::STOAHandler.

◆ getBranchingCandidates()

virtual void Minotaur::Handler::getBranchingCandidates	(	RelaxationPtr	rel,
		const DoubleVector &	x,
		ModVector &	mods,
		BrVarCandSet &	cands,
		BrCandVector &	gencands,
		bool &	is_inf
	)

pure virtual

find branching candidates.

A brancher will ask each handler by calling this function to list branching candidates.

Parameters

[in]	rel	Relaxation being solved at current node.
[in]	x	Solution of the relaxation.
[out]	mods	Any modifications that the handler found (Unused).
[out]	cands	The set of candidates to which branching candidates must be inserted. This set has candidates that want to branch on a single variable only. Other candidates must go into gencands.
[out]	gencands	The vector of general branching candidates. All candidates that do not want to branch on a variable dichotomy must be added in this vector.
[out]	is_inf	true if the handler finds that the problem is infeasible and the node can be pruned.

Implemented in Minotaur::CxQuadHandler, Minotaur::MultilinearTermsHandler, Minotaur::CxUnivarHandler, Minotaur::IntVarHandler, Minotaur::kPowHandler, Minotaur::MultilinearHandler, Minotaur::QuadHandler, Minotaur::SOS1Handler, Minotaur::SOS2Handler, Minotaur::UnivarQuadHandler, Minotaur::KnapCovHandler, Minotaur::LinearHandler, Minotaur::NlPresHandler, Minotaur::OAHandler, Minotaur::ParQGHandler, Minotaur::ParQGHandlerAdvance, Minotaur::PerspCutHandler, Minotaur::QGAdvHandler, Minotaur::QGHandler, Minotaur::QGHandler, Minotaur::QGHandlerAdvance, Minotaur::RCHandler, and Minotaur::STOAHandler.

◆ getBrMod()

virtual ModificationPtr Minotaur::Handler::getBrMod	(	BrCandPtr	cand,
		DoubleVector &	x,
		RelaxationPtr	rel,
		BranchDirection	dir
	)

pure virtual

Get the modifcation that creates a given (up or down) branch.

If one branch is pruned by the brancher (e.g. strong brancher), then we can apply the modifications of other branch to the relaxation without branching. This routine returns such a modification. This function is also called for obtaining modifications for strong branching on a candidate.

Parameters

[in]	cand	The candidate for which we want the modification.
[in]	x	The solution of relaxation at current node.
[in]	rel	The relaxation at current node.
[in]	dir	The Direction for which we want the modification, Up or Down?.

Returns: Modification that can be applied to the relaxation before re-solving it.

Implemented in Minotaur::CxQuadHandler, Minotaur::CxUnivarHandler, Minotaur::IntVarHandler, Minotaur::kPowHandler, Minotaur::QuadHandler, Minotaur::SOS1Handler, Minotaur::SOS2Handler, Minotaur::KnapCovHandler, Minotaur::LinearHandler, Minotaur::MultilinearHandler, Minotaur::MultilinearTermsHandler, Minotaur::NlPresHandler, Minotaur::OAHandler, Minotaur::ParQGHandler, Minotaur::ParQGHandlerAdvance, Minotaur::PerspCutHandler, Minotaur::QGAdvHandler, Minotaur::QGHandler, Minotaur::QGHandler, Minotaur::QGHandlerAdvance, Minotaur::RCHandler, Minotaur::STOAHandler, and Minotaur::UnivarQuadHandler.

◆ getName()

virtual std::string Minotaur::Handler::getName ( ) const

pure virtual

◆ isFeasible()

virtual bool Minotaur::Handler::isFeasible	(	ConstSolutionPtr	sol,
		RelaxationPtr	rel,
		bool &	should_prune,
		double &	inf_meas
	)

pure 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.

Implemented in Minotaur::CxQuadHandler, Minotaur::CxUnivarHandler, Minotaur::IntVarHandler, Minotaur::KnapCovHandler, Minotaur::kPowHandler, Minotaur::OAHandler, Minotaur::ParQGHandler, Minotaur::ParQGHandlerAdvance, Minotaur::QGAdvHandler, Minotaur::QGHandler, Minotaur::QGHandler, Minotaur::QGHandlerAdvance, Minotaur::QuadHandler, Minotaur::SOS1Handler, Minotaur::SOS2Handler, Minotaur::UnivarQuadHandler, Minotaur::LinearHandler, Minotaur::NlPresHandler, Minotaur::PerspCutHandler, Minotaur::RCHandler, Minotaur::STOAHandler, Minotaur::MultilinearHandler, and Minotaur::MultilinearTermsHandler.

◆ isNeeded()

virtual bool Minotaur::Handler::isNeeded ( )

inlinevirtual

Return true if this handler is needed for the problem.

It is useful to know if a handler is required or not. For example, a handler may be deleted if it is not needed.

Reimplemented in Minotaur::IntVarHandler, Minotaur::LinearHandler, Minotaur::SOS1Handler, and Minotaur::SOS2Handler.

◆ postSolveRootNode()

virtual bool Minotaur::Handler::postSolveRootNode	(	RelaxationPtr	,
		SolutionPoolPtr	,
		ConstSolutionPtr	,
		ModVector &	,
		ModVector &
	)

inlinevirtual

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.

Parameters

[in]	rel	Relaxation at the root node.
[in]	s_pool	Pool of solutions.
[in]	sol	The solution from the LP relaxation
[in]	p_mods	Unused. Modifications to the problem that must be stored in this node so that they are applied to all descendant nodes as well. All modifications must be appended not prepended.
[out]	r_mods	Modifications to the relaxation that must be stored in this node so that they are applied to all descendant nodes as well. All modifications must be appended not prepended. This may be unnecessary in certain algorithms.

Returns: true if the LP solution still remains feasible to the relaxation.

Reimplemented in Minotaur::kPowHandler, and Minotaur::QuadHandler.

◆ presolve()

virtual SolveStatus Minotaur::Handler::presolve	(	PreModQ *	pre_mods,
		bool *	changed,
		Solution **	sol
	)

pure virtual

Initial presolve.

Do the initial presolve. For now we will assume that presolve modifies the given problem. We do not create a new problem. All modifications that require post-processing for getting the solution back are prepended to 'pre_mods' by the handler.

Parameters

[in]	pre_mods	A pointer to a queue of PreMod objects. Modifications made by the presolver must be prepended (not appended) to pre_mods. The order is important for post-solve.
[out]	changed	True if the presolve modified the problem.

Returns: status of presolve.

Parameters

[out] sol Optimal solution found by the handler, if any. The status must be SolvedOptimal if and only if sol is created.

Implemented in Minotaur::IntVarHandler, Minotaur::KnapCovHandler, Minotaur::MultilinearTermsHandler, Minotaur::OAHandler, Minotaur::ParQGHandler, Minotaur::ParQGHandlerAdvance, Minotaur::QGHandler, Minotaur::RCHandler, Minotaur::SOS1Handler, Minotaur::SOS2Handler, Minotaur::STOAHandler, Minotaur::PerspCutHandler, Minotaur::QGAdvHandler, Minotaur::QGHandlerAdvance, Minotaur::MultilinearHandler, Minotaur::UnivarQuadHandler, Minotaur::CxQuadHandler, Minotaur::CxUnivarHandler, Minotaur::kPowHandler, Minotaur::LinearHandler, Minotaur::NlPresHandler, and Minotaur::QuadHandler.

◆ presolveNode()

virtual bool Minotaur::Handler::presolveNode	(	RelaxationPtr	rel,
		NodePtr	node,
		SolutionPoolPtr	s_pool,
		ModVector &	p_mods,
		ModVector &	r_mods
	)

pure virtual

Presolve the problem and its relaxation at a node.

Presolve the problem and its relaxation at a given node. Bound propagation and other simple modifications can be made in this function. It is called after the node relaxation is setup but before it is solved. Both the problem and its relaxation are presolved. Changes to the problem are stored in the tree. Changes to the relaxation are optional and may or may not be stored in the tree.

Parameters

[in]	rel	Relaxation at the current node.
[in]	node	Current node.
[in]	s_pool	Pool of solutions.
[in]	p_mods	Unused. Modifications to the problem that must be stored in this node so that they are applied to all descendant nodes as well. All modifications must be appended not prepended.
[out]	r_mods	Modifications to the relaxation that must be stored in this node so that they are applied to all descendant nodes as well. All modifications must be appended not prepended. This may be unnecessary in certain algorithms.

Returns: true if Node can be pruned because infeasibility is detected.

Implemented in Minotaur::CxUnivarHandler, Minotaur::kPowHandler, Minotaur::LinearHandler, Minotaur::QuadHandler, Minotaur::UnivarQuadHandler, Minotaur::NlPresHandler, Minotaur::CxQuadHandler, Minotaur::IntVarHandler, Minotaur::KnapCovHandler, Minotaur::MultilinearHandler, Minotaur::MultilinearTermsHandler, Minotaur::OAHandler, Minotaur::ParQGHandler, Minotaur::ParQGHandlerAdvance, Minotaur::PerspCutHandler, Minotaur::QGAdvHandler, Minotaur::QGHandler, Minotaur::QGHandler, Minotaur::QGHandlerAdvance, Minotaur::RCHandler, Minotaur::SOS1Handler, Minotaur::SOS2Handler, and Minotaur::STOAHandler.

◆ relaxInitFull()

virtual void Minotaur::Handler::relaxInitFull	(	RelaxationPtr	rel,
		SolutionPool *	sp,
		bool *	is_inf
	)

pure virtual

Create root relaxation if doing full node relaxations.

This method is used to add all the variables and constraints handled by this handler, with the understanding that nodes will also be fully rebuilt. The relaxation is already created, it should not be freed or re-allocated.

Parameters

[in,out]	rel	The relaxation that is being constructed.
[in]	Solution	pool for storing any new solutions found.
[out]	is_inf	is true if the handler finds that the problem is infeasible.

Implemented in Minotaur::kPowHandler, Minotaur::ParQGHandlerAdvance, Minotaur::CxQuadHandler, Minotaur::IntVarHandler, Minotaur::LinearHandler, Minotaur::ParQGHandler, Minotaur::QGHandler, Minotaur::QuadHandler, Minotaur::SOS1Handler, Minotaur::SOS2Handler, Minotaur::UnivarQuadHandler, Minotaur::CxUnivarHandler, Minotaur::KnapCovHandler, Minotaur::MultilinearTermsHandler, Minotaur::NlPresHandler, Minotaur::OAHandler, Minotaur::RCHandler, and Minotaur::STOAHandler.

◆ relaxInitInc()

virtual void Minotaur::Handler::relaxInitInc	(	RelaxationPtr	rel,
		SolutionPool *	sp,
		bool *	is_inf
	)

pure virtual

Create root relaxation if doing incremental node relaxations.

This method is used to add all the variables and constraints handled by this handler, with the understanding that nodes will incrementally relaxed. The relaxation is already created, it should not be freed or re-allocated.

Parameters

[in,out]	rel	The relaxation that is being constructed.
[in]	Solution	pool for storing any new solutions found.
[out]	is_inf	is true if the handler finds that the problem is infeasible.

Implemented in Minotaur::OAHandler, Minotaur::STOAHandler, Minotaur::CxUnivarHandler, Minotaur::kPowHandler, Minotaur::ParQGHandlerAdvance, Minotaur::CxQuadHandler, Minotaur::IntVarHandler, Minotaur::LinearHandler, Minotaur::ParQGHandler, Minotaur::QGHandler, Minotaur::QuadHandler, Minotaur::SOS1Handler, Minotaur::SOS2Handler, Minotaur::UnivarQuadHandler, Minotaur::KnapCovHandler, Minotaur::MultilinearTermsHandler, Minotaur::NlPresHandler, and Minotaur::RCHandler.

◆ relaxNodeFull()

virtual void Minotaur::Handler::relaxNodeFull	(	NodePtr	node,
		RelaxationPtr	rel,
		bool *	is_inf
	)

pure virtual

Create a relaxation for a node, building from scratch.

Create a relaxation of the constraints. Either this method, or relaxNodeInc should be called at each node. Here, we only make minor modifications to the same relaxation.

Parameters

[in]	node	is the node for which relaxation is to be created.
[in]	rel	is the relaxation that is being constructed. Do not allocate or re-allocate space for it. Just add new variables or constraints to it.
[out]	is_inf	is true if the node can be pruned.

Implemented in Minotaur::CxQuadHandler, Minotaur::IntVarHandler, Minotaur::kPowHandler, Minotaur::LinearHandler, Minotaur::ParQGHandler, Minotaur::ParQGHandlerAdvance, Minotaur::QGAdvHandler, Minotaur::QGHandler, Minotaur::QGHandler, Minotaur::QGHandlerAdvance, Minotaur::QuadHandler, Minotaur::SOS1Handler, Minotaur::SOS2Handler, Minotaur::UnivarQuadHandler, Minotaur::CxUnivarHandler, Minotaur::KnapCovHandler, Minotaur::MultilinearHandler, Minotaur::MultilinearTermsHandler, Minotaur::NlPresHandler, Minotaur::OAHandler, Minotaur::PerspCutHandler, Minotaur::RCHandler, and Minotaur::STOAHandler.

◆ relaxNodeInc()

virtual void Minotaur::Handler::relaxNodeInc	(	NodePtr	node,
		RelaxationPtr	rel,
		bool *	is_inf
	)

pure virtual

Create an incremental relaxation for a node.

Create a relaxation of the constraints. Either this method, or nodeRelaxFull relax should be called at root node. Usually we only make minor modifications to the same relaxation.

Parameters

[in]	node	is the node for which relaxation is to be created.
[in]	rel	is the relaxation that is being constructed. Do not allocate or re-allocate space for it. Just add new variables or constraints to it.
[out]	is_inf	is true if the node can be pruned.

Implemented in Minotaur::MultilinearTermsHandler, Minotaur::CxQuadHandler, Minotaur::IntVarHandler, Minotaur::kPowHandler, Minotaur::LinearHandler, Minotaur::ParQGHandler, Minotaur::ParQGHandlerAdvance, Minotaur::QGAdvHandler, Minotaur::QGHandler, Minotaur::QGHandler, Minotaur::QGHandlerAdvance, Minotaur::QuadHandler, Minotaur::SOS1Handler, Minotaur::SOS2Handler, Minotaur::UnivarQuadHandler, Minotaur::CxUnivarHandler, Minotaur::KnapCovHandler, Minotaur::MultilinearHandler, Minotaur::NlPresHandler, Minotaur::OAHandler, Minotaur::PerspCutHandler, Minotaur::RCHandler, and Minotaur::STOAHandler.

◆ removeCuts()

virtual void Minotaur::Handler::removeCuts	(	RelaxationPtr	,
		ConstSolutionPtr
	)

inlinevirtual

Remove optional cuts added by the handler if not required now.

Reimplemented in Minotaur::QuadHandler.

◆ separate()

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

pure virtual

add cuts to separate a given point.

Add cuts to the relaxation to cutoff a solution. We assume that all cuts are globally valid.

Parameters

[in]	sol	The solution that needs to be cut off
[in]	node	The node that we are currently solving.
[in]	rel	The relaxation at this node.
[in]	cutman	The CutManager where cuts should be sent.
[in]	s_pool	The SolutionPool containing solutions found so far.
[out]	sol_found	True if a new solution has been found while separating
[out]	status	SeparationStatus returned by this routine.

Implemented in Minotaur::OAHandler, Minotaur::RCHandler, Minotaur::CxQuadHandler, Minotaur::CxUnivarHandler, Minotaur::kPowHandler, Minotaur::LinearHandler, Minotaur::ParQGHandler, Minotaur::ParQGHandlerAdvance, Minotaur::PerspCutHandler, Minotaur::QGAdvHandler, Minotaur::QGHandler, Minotaur::QGHandler, Minotaur::QGHandlerAdvance, Minotaur::QuadHandler, Minotaur::SOS1Handler, Minotaur::SOS2Handler, Minotaur::UnivarQuadHandler, Minotaur::IntVarHandler, Minotaur::MultilinearTermsHandler, Minotaur::NlPresHandler, Minotaur::STOAHandler, and Minotaur::KnapCovHandler.

◆ setModFlags()

virtual void Minotaur::Handler::setModFlags	(	bool	mod_prob,
		bool	mod_rel
	)

inlinevirtual

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.

Parameters

[in]	mod_prob	If true, modify the problem in branching and presolving
[in]	mod_rel	If true, modify the relaxation in branching and presolving.

◆ simplePresolve()

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

inlinevirtual

Do simple presolve. This may involve quick bound inference and other simple tricks. Can be cheaper than node presolve and root presolve.

Parameters

[in]	p	Problem for which presolving to be done.
[in]	spool	Solution pool.
[out]	t_mods	Modification derived from presolve.
[out]	status	Presolve status.

Reimplemented in Minotaur::NlPresHandler, Minotaur::LinearHandler, and Minotaur::QuadHandler.

◆ undoStrongerMods()

void Handler::undoStrongerMods	(	ProblemPtr	p,
		RelaxationPtr	rel,
		ModVector &	p_mods,
		ModVector &	r_mods
	)

Undo Modifications made during stronger branching.

Parameters

[in]	rel	Relaxation at the current node
[in]	p_mods	Mods for the problem to undo. This vector will be changed in this function.
[in]	r_mods	Mods for the relaxation to undo. This vector will be changed in this function.

◆ writeStats()

virtual void Minotaur::Handler::writeStats ( std::ostream & ) const

inlinevirtual

Write statistics to ostream out.

Reimplemented in Minotaur::KnapCovHandler, Minotaur::RCHandler, Minotaur::kPowHandler, Minotaur::LinearHandler, Minotaur::NlPresHandler, Minotaur::OAHandler, Minotaur::ParQGHandler, Minotaur::ParQGHandlerAdvance, Minotaur::PerspCutHandler, Minotaur::QGAdvHandler, Minotaur::QGHandler, Minotaur::QGHandler, Minotaur::QGHandlerAdvance, Minotaur::QuadHandler, Minotaur::STOAHandler, and Minotaur::UnivarQuadHandler.

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

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

Public Member Functions

Protected Attributes

Detailed Description

Member Function Documentation

◆ addConstraint()

◆ consBegin()

◆ consEnd()

◆ fixNodeErr()

◆ getBranches()

◆ getBranchingCandidates()

◆ getBrMod()

◆ getName()

◆ isFeasible()

◆ isNeeded()

◆ postSolveRootNode()

◆ presolve()

◆ presolveNode()

◆ relaxInitFull()

◆ relaxInitInc()

◆ relaxNodeFull()

◆ relaxNodeInc()

◆ removeCuts()

◆ separate()

◆ setModFlags()

◆ simplePresolve()

◆ undoStrongerMods()

◆ writeStats()