Minotaur::LogHandler Class Reference

Inheritance diagram for Minotaur::LogHandler:

Collaboration diagram for Minotaur::LogHandler:

Public Member Functions
	LogHandler (EnvPtr env, ProblemPtr problem)
	Constructor.
	~LogHandler ()
	Destructor.
void	addConstraint (ConstraintPtr newcon, ConstVariablePtr ivar, ConstVariablePtr ovar, char sense='E')
void	addConstraint (ConstraintPtr)
	Add constraint to be handled by this handler.
BranchPtr	doBranch_ (BranchDirection UpOrDown, ConstVariablePtr v, double bvalue)
void	relaxInitFull (RelaxationPtr, SolutionPool *, bool *)
	Full relaxation (unused)
void	relaxInitInc (RelaxationPtr rel, SolutionPool *, bool *is_inf)
	Create initial incremental relaxation.
bool	isFeasible (ConstSolutionPtr sol, RelaxationPtr relaxation, bool &should_prune, double &inf_meas)
	Check feasibility.
void	separate (ConstSolutionPtr sol, NodePtr node, RelaxationPtr rel, CutManager *cutman, SolutionPoolPtr s_pool, ModVector &p_mods, ModVector &r_mods, bool *sol_found, SeparationStatus *status)
	Separation (cuts) — not implemented yet.
void	relaxNodeFull (NodePtr, RelaxationPtr, bool *)
	Full relaxation at a node (unused for LogHandler)
void	relaxNodeInc (NodePtr node, RelaxationPtr rel, bool *isInfeasible)
	Incremental relaxation at a node.
void	getBranchingCandidates (RelaxationPtr rel, const DoubleVector &x, ModVector &mods, BrVarCandSet &cands, BrCandVector &gencands, bool &is_inf)
	Branching candidates.
ModificationPtr	getBrMod (BrCandPtr cand, DoubleVector &x, RelaxationPtr rel, BranchDirection dir)
	Branch modification for a variable.
Branches	getBranches (BrCandPtr cand, DoubleVector &x, RelaxationPtr rel, SolutionPoolPtr s_pool)
	Generate branches.
SolveStatus	presolve (PreModQ *pre_mods, bool *changed, Solution **sol)
	Top-level presolve.
bool	presolveNode (RelaxationPtr p, NodePtr node, SolutionPoolPtr s_pool, ModVector &p_mods, ModVector &r_mods)
	Node-level presolve.
std::string	getName () const override
	Name of the handler.
void	writeStats (std::ostream &out) const override
	Stats.
Public Member Functions inherited from Minotaur::Handler
	Handler ()
	Default constructor.
virtual	~Handler ()
	Destroy.
virtual ConstraintVector::const_iterator	consBegin () const
virtual ConstraintVector::const_iterator	consEnd () const
virtual int	fixNodeErr (RelaxationPtr, ConstSolutionPtr, SolutionPoolPtr, bool &)
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	isNeeded ()
	Return true if this handler is needed for the problem.
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.
virtual void	removeCuts (RelaxationPtr, ConstSolutionPtr)
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.
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.

Public Attributes
double	aTol_
	Absolute feasibility tolerance.
double	rTol_
	Relative feasibility tolerance.
double	eTol_
	Tolerances for log constraints.
double	vTol_
ProblemPtr	p_
	Problem pointer.
LoggerPtr	log_
	Logger.
DoubleVector	tmpX_
	Temporary vectors for evaluations.
DoubleVector	grad_

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.

Member Function Documentation

addConstraint() [1/2]

void LogHandler::addConstraint	(	ConstraintPtr	newcon,
		ConstVariablePtr	ivar,
		ConstVariablePtr	ovar,
		char	sense = 'E'
	)

Register a log constraint with the handler.

• ivar: input variable x
• ovar: output variable y
• sense: 'L', 'G', or 'E'

addConstraint() [2/2]

void Minotaur::LogHandler::addConstraint ( ConstraintPtr  newcon )

inlinevirtual

Add constraint to be handled by this handler.

Parameters

[in]

newcon

Constraint to be added.

Reimplemented from Minotaur::Handler.

getBranches()

Branches LogHandler::getBranches ( BrCandPtr  cand, DoubleVector &  x, RelaxationPtr  rel, SolutionPoolPtr  s_pool  )

virtual

Generate branches.

Implements Minotaur::Handler.

getBranchingCandidates()

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

virtual

Branching candidates.

Implements Minotaur::Handler.

getBrMod()

ModificationPtr LogHandler::getBrMod ( BrCandPtr  cand, DoubleVector &  x, RelaxationPtr  rel, BranchDirection  dir  )

virtual

Branch modification for a variable.

Implements Minotaur::Handler.

getName()

std::string LogHandler::getName ( ) const

overridevirtual

Name of the handler.

Implements Minotaur::Handler.

isFeasible()

bool LogHandler::isFeasible ( ConstSolutionPtr  sol, RelaxationPtr  relaxation, bool &  should_prune, double &  inf_meas  )

virtual

Check feasibility.

Implements Minotaur::Handler.

presolve()

SolveStatus LogHandler::presolve ( PreModQ *  pre_mods, bool *  changed, Solution **  sol  )

virtual

Top-level presolve.

Implements Minotaur::Handler.

presolveNode()

bool LogHandler::presolveNode ( RelaxationPtr  p, NodePtr  node, SolutionPoolPtr  s_pool, ModVector &  p_mods, ModVector &  r_mods  )

virtual

Node-level presolve.

Implements Minotaur::Handler.

relaxInitFull()

void Minotaur::LogHandler::relaxInitFull ( RelaxationPtr  , SolutionPool *  , bool *    )

inlinevirtual

Full relaxation (unused)

Implements Minotaur::Handler.

relaxInitInc()

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

virtual

Create initial incremental relaxation.

Implements Minotaur::Handler.

relaxNodeFull()

void Minotaur::LogHandler::relaxNodeFull ( NodePtr  , RelaxationPtr  , bool *    )

inlinevirtual

Full relaxation at a node (unused for LogHandler)

Implements Minotaur::Handler.

relaxNodeInc()

void LogHandler::relaxNodeInc ( NodePtr  node, RelaxationPtr  rel, bool *  isInfeasible  )

virtual

Incremental relaxation at a node.

Implements Minotaur::Handler.

separate()

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

virtual

Separation (cuts) — not implemented yet.

Implements Minotaur::Handler.

writeStats()

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

overridevirtual

Stats.

Reimplemented from Minotaur::Handler.

---

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

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