Minotaur::BndProcessor Class Reference

Simple node-processor for branch-and-bound. More...

#include <BndProcessor.h>

Inheritance diagram for Minotaur::BndProcessor:

Collaboration diagram for Minotaur::BndProcessor:

Public Member Functions
	BndProcessor ()
	Default constructor.
	BndProcessor (EnvPtr env, EnginePtr engine, HandlerVector handlers_)
	Constructor with a given engine.
	~BndProcessor ()
	Destroy.
bool	foundNewSolution ()
Branches	getBranches ()
	Find branches that will be used to branch at this node. More...
WarmStartPtr	getWarmStart ()
void	process (NodePtr node, RelaxationPtr rel, SolutionPoolPtr s_pool)
void	writeStats (std::ostream &out) const
	Write statistics to a given output stream. More...
void	writeStats () const
	Write statistics to our own logger. More...
Public Member Functions inherited from Minotaur::NodeProcessor
	NodeProcessor ()
	Default constructor.
virtual	~NodeProcessor ()
	Destroy.
virtual void	setBrancher (BrancherPtr brancher)
	Set the brancher that will be used with this node processor.
virtual void	processRootNode (NodePtr node, RelaxationPtr rel, SolutionPoolPtr s_pool)
	Process the root node. More...
virtual void	process (NodePtr node, RelaxationPtr rel, SolutionPoolPtr s_pool)=0
virtual Branches	getBranches ()=0
	Find branches that will be used to branch at this node. More...
virtual bool	foundNewSolution ()=0
virtual WarmStartPtr	getWarmStart ()=0
virtual BrancherPtr	getBrancher ()
	Return brancher.
virtual void	writeStats (std::ostream &) const
	Write statistics to a given output stream. More...
virtual void	writeStats () const
	Write statistics to our own logger. More...
virtual void	setCutManager (CutManager *)

Protected Member Functions
virtual bool	isFeasible_ (NodePtr node, ConstSolutionPtr sol, SolutionPoolPtr s_pool, bool &should_prune)
virtual void	solveRelaxation_ ()
	Solve the relaxation.
virtual bool	shouldPrune_ (NodePtr node, double solval, SolutionPoolPtr s_pool)

Protected Attributes
Branches	branches_
	Branches found by this processor for this node.
bool	contOnErr_
double	cutOff_
	If lb is greater than cutOff_, we can prune this node.
EnginePtr	engine_
	Engine used to process the relaxation.
EngineStatus	engineStatus_
	Status of the engine.
HandlerVector	handlers_
	All the handlers that are used for this processor.
LoggerPtr	logger_
	Log.
UInt	numSolutions_
	How many new solutions were found by the processor.
double	oATol_
	Absolute tolerance for pruning a node on basis of bounds.
double	oRTol_
	Relative tolerance for pruning a node on basis of bounds.
RelaxationPtr	relaxation_
	Relaxation that is processed by this processor.
BPStats	stats_
	Statistics.
WarmStartPtr	ws_
	Warm-start information for start processing the children.
Protected Attributes inherited from Minotaur::NodeProcessor
BrancherPtr	brancher_
	What brancher is used for this processor.

Static Protected Attributes
static const std::string	me_ = "BndProcessor: "
	For logging.

Detailed Description

Simple node-processor for branch-and-bound.

BndProcessor is a derived class of NodeProcessor. It is meant to solve relaxations at each node. It performs only pruning and branching in a node. Does not call any presolving, cutting, or heuristic search.

Member Function Documentation

foundNewSolution()

bool BndProcessor::foundNewSolution ( )

virtual

True if the node processor found at least one feasible solution while processing this node.

Implements Minotaur::NodeProcessor.

getBranches()

Branches BndProcessor::getBranches ( )

virtual

Find branches that will be used to branch at this node.

Implements Minotaur::NodeProcessor.

getWarmStart()

WarmStartPtr BndProcessor::getWarmStart ( )

virtual

Return the warm start information that will be used to start processing children.

Implements Minotaur::NodeProcessor.

isFeasible_()

bool BndProcessor::isFeasible_ ( NodePtr  node, ConstSolutionPtr  sol, SolutionPoolPtr  s_pool, bool &  should_prune  )

protectedvirtual

Check if the solution is feasible to the original problem. In case it is feasible, we can store the solution and update the upper bound. Additionally, if the solution is optimal for the current node, then the node can be pruned.

process()

void BndProcessor::process ( NodePtr  node, RelaxationPtr  rel, SolutionPoolPtr  s_pool  )

virtual

Process relaxation at the given node. If a solution is found, it must be added to the solution pool.

Implements Minotaur::NodeProcessor.

shouldPrune_()

bool BndProcessor::shouldPrune_ ( NodePtr  node, double  solval, SolutionPoolPtr  s_pool  )

protectedvirtual

Check if a node can be pruned either because the relaxation is infeasible or because the cost is too high.

writeStats() [1/2]

void BndProcessor::writeStats ( ) const

virtual

Write statistics to our own logger.

Reimplemented from Minotaur::NodeProcessor.

writeStats() [2/2]

void BndProcessor::writeStats ( std::ostream &  ) const

virtual

Write statistics to a given output stream.

Reimplemented from Minotaur::NodeProcessor.

Member Data Documentation

contOnErr_

bool Minotaur::BndProcessor::contOnErr_

protected

If true, we continue to search, if engine reports error. If false, we assume that the relaxation is infeasible when engine returns error.

---

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

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