Minotaur Namespace Reference

Classes
struct	AbsCons
	Stores data for a single y = |x| constraint. More...
class	AbsHandler
class	ActiveNodeStore
	Save and retrieve active nodes. More...
class	AnalyticalCenter
struct	BabOptions
	Different options and parameters that control branch-and-bound. More...
struct	BabStats
	Statistics about the branch-and-bound. More...
class	Bnb
class	BnbDistPar
class	BnbPar
class	BndProcessor
	Simple node-processor for branch-and-bound. More...
struct	BPStats
class	BqpdData
	Information for restarting from the previous optimal solution. More...
class	BqpdEngine
struct	BqpdStats
class	Branch
	Base class for storing branching modifications. More...
class	BranchAndBound
	Implement a generic branch-and-bound algorithm on a single cpu. More...
class	Brancher
	A brancher is used to find suitable branches for a given node. e.g. LexicoBrancher. This class is abstract. More...
class	BrCand
	Base class for describing candidates for branching on a node in branch-and-bound. More...
class	BrVarCand
	Derived class of BrCand, it defines candidates for branching on bounds of a variable. More...
class	CbcEngine
	The CbcEngine class can be called to solve MILP problems. More...
struct	CbcStats
	Statistics. More...
class	CGraph
class	CholCalculator
class	ClockTimer
class	CNode
	CNode denotes a node in the computational graph. It stores the op-code, children, parents and other auxiliary information to evaluate the function and its derivative, check its properties etc. More...
struct	CompareCNodes
struct	CompareCNodesR
struct	CompareIntDouble
struct	CompareLinBil
struct	CompareMcCormick
struct	CompareValueVariablePair
struct	CompareValueVarInc
struct	CompareVarBrCand
struct	CompareVariablePair
struct	CompareVariablePtr
class	ConBoundMod
	Modification of a single bound on a constraint. More...
class	ConBoundMod2
	Modification of a both bounds on a constraint. More...
class	ConMod
	Modification of a both bounds on a constraint. More...
class	Constraint
	The Constraint class is used to manage a constraint. More...
struct	ConstraintStats
	The Problem that needs to be solved. More...
struct	CovCutGenStats
class	CoverCutGenerator
class	CplexLPEngine
	The CplexLPEngine class can be called to solve LP problems. More...
struct	CplexLPStats
	Statistics. More...
class	CplexMILPEngine
	The CplexMILPEngine class can be called to solve MILP problems. More...
struct	CplexMILPStats
	Statistics. More...
class	CpxLPWarmStart
	Class for saving and using Warm-start information in Cplex LP engine. More...
class	CQIter2
class	Cut
	Store function, bounds and other information about a cut. More...
class	CutInfo
class	CutMan1
	Derived class for managing cuts. Add and remove cuts based on priority and violation. More...
class	CutMan2
class	CutManager
	Abstract base class to manage cuts in the relaxation. More...
class	CutPool
struct	CutStat
struct	CutStats
class	CxQuadHandler
class	CxUnivarConstraintData
class	CxUnivarHandler
struct	DistParBabOptions
	Different options and parameters that control branch-and-bound. More...
struct	DistParBabStats
	Statistics about the branch-and-bound. More...
class	DistParBranchAndBound
	Implement a generic parallel branch-and-bound algorithm on a multicore cpu. More...
struct	DivingheurStats
	A statistic struct for MINLP Diving heuristic. More...
class	Eigen
class	EigenCalculator
class	Engine
class	EngineFactory
class	Environment
class	Exception
class	ExpHandler
class	FeasibilityPump
	Feasibility Pump for MINLPs. More...
struct	FeasPumpStats
	statistics for Feasibility Pump heuristic More...
class	FilterSQPEngine
struct	FilterSQPStats
class	FilterSQPWarmStart
class	FixVarsHeur
struct	FixVarsHeurStats
	A statistic struct for trivial heuristic. More...
class	Function
class	Glob
class	Gradient
class	Handler
	Base class for handling specific types of constraints or objective. More...
class	HessianOfLag
class	Heuristic
class	HybridBrancher
class	Hypergraph
struct	impliVarsInfo
class	InterfaceFactory
class	IntVarHandler
class	IpoptEngine
class	IpoptSolution
struct	IpoptStats
class	IpoptWarmStart
	Class for saving and using Warm-start information in Ipopt. More...
class	Iterate
class	Jacobian
struct	KCStats
class	KnapCovHandler
class	KnapsackList
class	kPowHandler
	‍Iterator for LinkPowMap More...
class	LexicoBrancher
struct	LexicoBrStats
class	LGCIGenerator
struct	LGCIGenStats
class	LinBil
struct	LinBivar
	‍Iterator for LinUnivar More...
class	LinConMod
class	LinearCut
class	LinearFunction
	The base class linear function is of the form c'x. More...
class	LinearHandler
class	Linearizations
class	LinFeasPump
	Linear Feasibility Pump for MINLPs. More...
struct	LinFeasStats
	statistics for Linear Feasibility Pump More...
struct	LinkPow
	A structure to save information about constraints of the form . More...
class	LinMods
struct	LinPresolveOpts
	Options for presolve. More...
struct	LinPresolveStats
	Store statistics of presolving. More...
struct	LinSqr
	A structure to save information about constraints of the form . More...
struct	LinStats
struct	LinUnivar
	A structure to save information about constraints of the form . More...
class	Logger
class	LogHandler
class	LPEngine
class	LPRelaxation
struct	LTHessStor
class	MaxFreqBrancher
	A class to select a variable for branching using maximum-frequency branching. More...
struct	MaxFreqBrStats
class	MaxInfBrancher
	A class to select a variable for branching using maximum-inference branching. More...
struct	MaxInfBrStats
class	MaxVioBrancher
	A class to select a variable for branching using maximum-violated branching. More...
struct	MaxVioBrStats
struct	MBPStats
class	McCormick
class	MILPEngine
class	MINLPDiving
	Diving heuristif for MINLPs. More...
class	Modification
class	MonomialFunction
	MonomialFunction represents functions of the form of the form where . More...
struct	MSHeurStats
	Statistic for Multistart heuristic. More...
class	MsProcessor
	Simple multi-start node-processor for branch-and-bound. More...
class	MultilinearHandler
	A MultilinearHandler handles terms like . More...
class	MultilinearTermsHandler
class	MultiSolHeur
struct	MultiSolHeurStats
	statistics for heuristic More...
class	MultiStart
class	NLPEngine
class	NLPMultiStart
	Multistart heuristic for continuous NLPs. More...
class	NLPRelaxation
class	NlPresHandler
struct	NlPresOpts
	Options for presolve. More...
struct	NlPresStats
	Store statistics of presolving. More...
class	NlWriter
	Writes a problem to a .nl file. The nonlinear functions must be stored in using native cgraphs for this class to work. More...
class	Node
class	NodeFullRelaxer
class	NodeHeap
class	NodeIncRelaxer
class	NodeProcessor
class	NodeRelaxer
class	NodeStack
struct	NodeStats
class	NonlinearFunction
	Base class for nonlinear functions. More...
class	OAHandler
	Handler for convex constraints, based on quesada-grossmann algorithm. More...
struct	OAStats
class	Objective
class	Option
class	OptionDB
class	OsiLPEngine
	The OsiLPEngine engine uses the OSI interface to CLP solver. More...
struct	OsiLPStats
	Statistics. More...
class	OsiLPWarmStart
	Actual implementation of warm start for OsiLP Engine. More...
struct	ParBabOptions
	Different options and parameters that control branch-and-bound. More...
struct	ParBabStats
	Statistics about the branch-and-bound. More...
class	ParBndProcessor
	Simple node-processor for branch-and-bound. More...
struct	ParBPStats
class	ParBranchAndBound
	Implement a generic parallel branch-and-bound algorithm on a multicore cpu. More...
class	ParCutMan
	Derived class for managing cuts. Add and remove cuts based on priority and violation. More...
class	ParMINLPDiving
	Parallel Diving heuristic for MINLPs. More...
class	ParNodeIncRelaxer
struct	ParNodeStats
class	ParPCBProcessor
	Default node processor used in solver for now. More...
struct	ParQGBabOptions
	Different options and parameters that control branch-and-bound. More...
struct	ParQGBabStats
	Statistics about the branch-and-bound. More...
class	ParQGBranchAndBound
	Implement a generic parallel branch-and-bound algorithm on a multicore cpu. More...
class	ParQGHandler
	Handler for convex constraints, based on quesada-grossmann algorithm. More...
class	ParQGHandlerAdvance
	Handler for convex constraints, based on quesada-grossmann algorithm. More...
struct	ParQGStats
struct	ParRelBrStats
class	ParReliabilityBrancher
	A class to select a variable for branching using reliability branching. More...
class	ParTreeManager
	Base class for managing the branch-and-bound tree. More...
class	PCBProcessor
	Default node processor used in solver for now. More...
class	PerspCon
class	PerspCutGenerator
class	PerspCutHandler
class	PerspList
struct	PerspListStats
class	PolynomialFunction
	PolynomialFunction represents functions of the form , where is a MonomialFunction. More...
class	PowHandler
struct	prConsInfo
class	PreAuxVars
class	PreDelVars
class	PreMod
class	Presolver
struct	PreSubstVarData
class	PreSubstVars
struct	prObjInfo
class	Problem
struct	ProblemSize
	ProblemSize stores several statistics on the size of the Problem. More...
struct	ProbStructStats
class	ProbStructure
struct	PRStats
class	QG
class	QGAdvHandler
	Handler for convex constraints, based on quesada-grossmann algorithm. More...
class	QGHandler
	Handler for convex constraints, based on quesada-grossmann algorithm. More...
class	QGHandlerAdvance
	Handler for convex constraints, based on quesada-grossmann algorithm. More...
class	QGPar
struct	QGStats
class	QPDProcessor
struct	QPDStats
class	QPEngine
class	qpOASESData
class	qpOASESEngine
class	qpOASESPoint
class	qpOASESStats
class	qpOASESWarmStart
class	QuadHandler
	‍Iterator for LinSqrMap More...
class	QuadraticFunction
class	QuadTransformer
	Class for reformulating a problem using simple rules so that handlers can be applied to it. More...
class	RandomBrancher
	A class to select random branching candidate from the available ones. More...
struct	RandomBrStats
class	RCHandler
	Handler for reduced cost strengthening. More...
struct	RCStats
class	Reader
	Read an LP or MILP instance from an MPS file. More...
class	RecipHandler
class	Relaxation
struct	RelBrStats
class	ReliabilityBrancher
	A class to select a variable for branching using reliability branching. More...
class	SamplingHeur
struct	SamplingHeurStats
	A statistic struct for trivial heuristic. More...
struct	Secant
	Save information about constraints of the form . More...
class	SecantMod
class	SimpleCutMan
	Derived class for managing cuts. Adds all violated cuts from the storage to the relaxation and never removes any. If a new cut is reported but not violated by the current solution then it is added to storage. This manager does not check for duplicacy or any other numerical problems in cuts. More...
class	SimpleTransformer
	Class for reformulating a problem using simple rules so that handlers can be applied to it. More...
struct	SimplexCut
class	SimplexQuadCutGen
class	SolCheck
class	Solution
class	SolutionPool
class	Solver
class	SOS
class	SOS1Handler
class	SOS2Handler
class	SOSBrCand
	Derived class of BrCand, it defines candidates for branching on bounds SOS type 1 and 2 constraints. More...
class	SppHeur
struct	SppHeurMods
struct	SppHeurStats
class	STOAHandler
	Handler for convex constraints, based on quesada-grossmann algorithm. More...
struct	STOAStats
struct	StrBrStats
struct	TableauInfo
	A structure to store info from the simplex tableau. More...
class	Timer
class	TimerFactory
	The TimerFactory should be used to get the approrpriate Timer. More...
class	Transformer
	Abstract base class for reformulating a problem so that handlers can be applied to it. More...
class	TransPoly
	Base class for reformulating a general nonconvex mixed-integer problem into one that has univariate constraints and multilinear constraints. More...
class	TransSep
class	TreeManager
	Base class for managing the branch-and-bound tree. More...
class	UnambRelBrancher
	A class to select a variable for branching using unambiguous reliability branching. More...
struct	UnambRelBrStats
class	UnivarQuadHandler
	‍Iterator for LinBivar More...
class	UnoEngine
class	UnoSolution
struct	UnoStats
class	UnoWarmStart
	Class for saving and using Warm-start information in Uno. More...
class	VarBoundMod
	Modification of a single bound on a variable. More...
class	VarBoundMod2
	Modification of a both bounds on a variable. More...
class	Variable
struct	vioInterval
class	WarmStart
class	WeakBrancher
struct	WeakBrStats
class	YEqBivar
class	YEqCGs
class	YEqLFs
class	YEqMonomial
class	YEqQfBil
class	YEqUCGs
class	YEqUnivar
class	YEqVars

Typedefs
typedef Environment *	EnvPtr
typedef Problem *	ProblemPtr
typedef Logger *	LoggerPtr
typedef AbsCons *	AbsConsPtr
typedef std::vector< AbsConsPtr >	AbsConsVector
typedef AbsConsVector::iterator	AbsConsIter
typedef AbsConsVector::const_iterator	AbsConsConstIter
typedef AbsHandler *	AbsHandlerPtr
typedef ActiveNodeStore *	ActiveNodeStorePtr
typedef AnalyticalCenter *	AnalyticalCenterPtr
typedef Engine *	EnginePtr
typedef const Solution *	ConstSolutionPtr
typedef BndProcessor *	BndProcessorPtr
typedef BabOptions *	BabOptionsPtr
typedef BranchAndBound *	BranchAndBoundPtr
typedef Relaxation *	RelaxationPtr
typedef SolutionPool *	SolutionPoolPtr
typedef Brancher *	BrancherPtr
typedef CGraph *	CGraphPtr
typedef std::deque< CNode * >	CNodeQ
typedef std::vector< CNode * >	CNodeVector
typedef std::map< ConstVariablePtr, CNode *, CompareVariablePtr >	VarNodeMap
typedef std::set< CNode *, CompareCNodes >	CNodeSet
typedef std::set< CNode *, CompareCNodesR >	CNodeRSet
typedef ConBoundMod *	ConBoundModPtr
typedef std::vector< ConBoundModPtr >	ConBoundModVector
typedef ConBoundModVector::iterator	ConBoundModIter
typedef ConBoundModVector::const_iterator	ConBoundModConstIter
typedef ConBoundMod2 *	ConBoundMod2Ptr
typedef const ConBoundMod2 *	ConstConBoundMod2Ptr
typedef std::vector< ConBoundMod2Ptr >	ConBoundMod2Vector
typedef ConBoundMod2Vector::iterator	ConBoundMod2Iter
typedef ConBoundMod2Vector::const_iterator	ConBoundMod2ConstIter
typedef ConMod *	ConModPtr
typedef const ConMod *	ConstConModPtr
typedef std::vector< ConModPtr >	ConModVector
typedef ConModVector::iterator	ConModIter
typedef ConModVector::const_iterator	ConModConstIter
typedef std::set< std::pair< VariablePtr, FunctionType > >::const_iterator	VariableFunIterator
typedef const Cut *	ConstCutPtr
typedef CovCutGenStats *	CovCutGenStatsPtr
typedef CovCutGenStats const *	ConstCovCutGenStatsPtr
typedef ofstream *	OfstreamPtr
typedef std::vector< CutPtr >	CutVector
typedef CutVector::iterator	CutIterator
typedef CutVector::const_iterator	CutConstIterator
typedef CutInfo *	CutInfoPtr
typedef std::vector< CutInfoPtr >	CutInfoVector
typedef CutInfoVector::iterator	CutInfoIterator
typedef CutInfoVector::const_iterator	CutInfoConstIterator
typedef Constraint *	ConstraintPtr
typedef std::list< CutPtr >	cutList
typedef CutMan2 *	CutMan2Ptr
typedef CutManager *	CutManagerPtr
typedef Environment *	EnvironmentPtr
typedef Cut *	CutPtr
typedef Solution *	SolutionPtr
typedef std::deque< CutPtr >	CutQ
typedef LinearFunction *	LinearFunctionPtr
typedef QuadraticFunction *	QuadraticFunctionPtr
typedef Secant *	SecantPtr
	Pointer to Secant.
typedef std::vector< SecantPtr >::iterator	SecantIterator
	Vector-iterator for Secant.
typedef std::map< VariablePtr, SecantPtr, CompareVariablePtr >	VarSecantMap
	Map of 'x' and the secant that is used for .
typedef VarSecantMap::iterator	VarSecantMapIter
	Iterator for VarSecantMap.
typedef McCormick *	McCormickPtr
	shared pointer to McCormick object.
typedef std::set< McCormickPtr, CompareMcCormick >	McCormickSet
	A set of McCormick objects.
typedef McCormickSet::iterator	McCormickSetIter
	Iterator of McCormick objects over a set.
typedef CxQuadHandler *	CxQuadHandlerPtr
	Shared pointer to CxQuadHandler.
typedef const CxQuadHandler *	CxQuadConstHandlerPtr
	Shared pointer to const CxQuadHandler.
typedef Objective *	ObjectivePtr
typedef CxUnivarConstraintData *	CxUnivarConstraintDataPtr
	Shared pointer to CxUnivarHandler.
typedef std::vector< CxUnivarConstraintDataPtr >	CxUnivarConstraintDataVector
typedef CxUnivarConstraintDataVector::iterator	CxUnivarConstraintIterator
typedef const CxUnivarConstraintData *	CxUnivarConstConstraintDataPtr
	Shared pointer to const CxUnivarHandler.
typedef CxUnivarHandler *	CxUnivarHandlerPtr
	Shared pointer to CxUnivarHandler.
typedef const CxUnivarHandler *	CxUnivarConstHandlerPtr
	Shared pointer to const CxUnivarHandler.
typedef DistParBabOptions *	DistParBabOptionsPtr
typedef NodeProcessor *	NodeProcessorPtr
typedef NodeRelaxer *	NodeRelaxerPtr
typedef ParNodeIncRelaxer *	ParNodeIncRelaxerPtr
typedef ParPCBProcessor *	ParPCBProcessorPtr
typedef ParTreeManager *	ParTreeManagerPtr
typedef WarmStart *	WarmStartPtr
typedef DistParBranchAndBound *	DistParBranchAndBoundPtr
typedef const QuadraticFunction *	ConstQuadraticFunctionPtr
typedef std::pair< double, LinearFunctionPtr >	EigenPair
typedef std::vector< EigenPair >::const_iterator	EigenPairConstIterator
typedef Eigen *	EigenPtr
typedef const Engine *	ConstEnginePtr
typedef const WarmStart *	ConstWarmStartPtr
typedef FeasibilityPump *	FeasPumpPtr
typedef FixVarsHeur *	FixVarsHeurPtr
typedef Gradient *	GradientPtr
typedef const Gradient *	ConstGradientPtr
typedef PreMod *	PreModPtr
typedef std::deque< PreModPtr >	PreModQ
typedef PreModQ::iterator	PreModQIter
typedef PreModQ::const_iterator	PreModQConstIter
typedef HessianOfLag *	HessianOfLagPtr
typedef const HessianOfLag *	ConstHessianOfLagPtr
typedef HybridBrancher *	HybridBrancherPtr
typedef IntVarHandler *	IntVarHandlerPtr
typedef const IntVarHandler *	ConstIntVarHandlerPtr
typedef Jacobian *	JacobianPtr
typedef KnapCovHandler *	KnapCovHandlerPtr
typedef const KnapCovHandler *	ConstKnapCovHandler
typedef LPEngine *	LPEnginePtr
typedef LinkPow *	LinkPowPtr
typedef std::vector< LinkPowPtr >	LinkPowVec
	‍Pointer to LinkPow
typedef LinkPowVec::iterator	LinkPowVecIter
	‍Vector of LinkPow
typedef std::map< VariablePtr, LinkPowPtr, CompareVariablePtr >	LinkPowMap
	‍Iterator for LinkPow
typedef LinkPowMap::iterator	LinkPowMapIter
typedef kPowHandler *	kPowHandlerPtr
	Shared pointer to kPowHandler.
typedef LexicoBrancher *	LexicoBrancherPtr
typedef LGCIGenerator *	LGCIGeneratorPtr
typedef const LGCIGenerator *	ConstLGCIGeneratorPtr
typedef LGCIGenStats *	LGCIGenStatsPtr
typedef LGCIGenStats const *	ConstLGCIGenStatsPtr
typedef const LinearFunction *	ConstLinearFunctionPtr
typedef std::map< ConstVariablePtr, ConstVariablePtr >	OrigLiftVars
typedef OrigLiftVars *	OrigLiftVarsPtr
typedef std::set< LinBil *, CompareLinBil >	LinBilSet
	A set of bilinear objects.
typedef LinBilSet::iterator	LinBilSetIter
	Iterator of LinBil objects over a set.
typedef LinConMod *	LinConModPtr
typedef const LinConMod *	ConstLinConModPtr
typedef std::vector< LinConModPtr >	LinConModVector
typedef LinConModVector::iterator	LinConModIter
typedef LinConModVector::const_iterator	LinConModConstIter
typedef LinearCut *	LinearCutPtr
typedef std::vector< LinearCutPtr >	LinearCutVector
typedef CutVector::iterator	LinearCutIterator
typedef CutVector::const_iterator	LinearCutConstIterator
typedef LinearHandler *	LinearHandlerPtr
typedef const LinearHandler *	ConstLinearHandlerPtr
typedef Linearizations *	LinearizationsPtr
typedef LinearHandler *	LinHandlerPtr
typedef QGHandler *	QGHandlerPtr
typedef LinFeasPump *	LinFeasPumpPtr
typedef LinMods *	LinModsPtr
typedef const LinMods *	ConstLinModsPtr
typedef const Logger *	ConstLoggerPtr
typedef LPRelaxation *	LPRelaxationPtr
typedef const LPRelaxation *	ConstLPRelaxationPtr
typedef MaxFreqBrancher *	MaxFreqBrancherPtr
typedef MaxInfBrancher *	MaxInfBrancherPtr
typedef MaxVioBrancher *	MaxVioBrancherPtr
typedef MILPEngine *	MILPEnginePtr
typedef VarBoundMod *	VarBoundModPtr
typedef MINLPDiving *	MINLPDivingPtr
typedef MsProcessor *	MsProcessorPtr
typedef PolynomialFunction *	PolyFunPtr
typedef MultilinearHandler *	MultilinearHandlerPtr
typedef const MultilinearHandler *	MultilinearConstHandlerPtr
typedef std::set< ConstVariablePtr >	SetOfVars
typedef std::set< SetOfVars >	SetOfSetOfVars
typedef Hypergraph *	HypergraphPtr
typedef const Hypergraph *	HypergraphConstPtr
typedef MultilinearTermsHandler *	MultilinearTermsHandlerPtr
typedef MultiSolHeur *	MultiSolHeurPtr
typedef NLPEngine *	NLPEnginePtr
typedef NLPMultiStart *	NLPMSPtr
typedef NLPRelaxation *	NLPRelaxationPtr
typedef const NLPRelaxation *	ConstNLPRelaxationPtr
typedef PreAuxVars *	PreAuxVarsPtr
typedef NlPresHandler *	NlPresHandlerPtr
typedef NonlinearFunction *	NonlinearFunctionPtr
typedef const Node *	ConstNodePtr
typedef NodeFullRelaxer *	NodeFullRelaxerPtr
typedef NodeHeap *	NodeHeapPtr
typedef NodeIncRelaxer *	NodeIncRelaxerPtr
typedef std::deque< NodePtr >	NodePtrStack
typedef NodePtrStack::iterator	NodeStackIter
typedef NodePtrStack::const_iterator	NodeStackConstIter
typedef NodeStack *	NodeStackPtr
typedef std::vector< VarBoundModPtr >	VarBoundModVector
typedef VarBoundModVector::iterator	VarBoundModIter
typedef const NonlinearFunction *	ConstNonlinearFunctionPtr
typedef OAHandler *	OAHandlerPtr
typedef OptionDB *	OptionDBPtr
typedef ParBndProcessor *	ParBndProcessorPtr
typedef ParBabOptions *	ParBabOptionsPtr
typedef ParBranchAndBound *	ParBranchAndBoundPtr
typedef ParMINLPDiving *	ParMINLPDivingPtr
typedef ParQGBabOptions *	ParQGBabOptionsPtr
typedef ParQGBranchAndBound *	ParQGBranchAndBoundPtr
typedef ParQGHandler *	ParQGHandlerPtr
typedef ParQGHandlerAdvance *	ParQGHandlerAdvancePtr
typedef ParReliabilityBrancher *	ParReliabilityBrancherPtr
typedef PCBProcessor *	PCBProcessorPtr
typedef PerspCon *	PerspConPtr
typedef const PerspCon *	ConstPerspConPtr
typedef struct Minotaur::impliVarsInfo	impliVar
typedef struct Minotaur::prConsInfo	prCons
typedef struct Minotaur::prObjInfo	prObj
typedef PerspCutGenerator *	PerspCutGeneratorPtr
typedef const PerspCutGenerator *	ConstPerspCutGeneratorPtr
typedef PerspCutHandler *	PerspCutHandlerPtr
typedef const PerspCutHandler *	ConstPerspCutHandlerPtr
typedef PerspList *	PerspListPtr
typedef const PerspList *	ConstPerspListPtr
typedef PerspListStats *	PerspListStatsPtr
typedef PerspListStats const *	ConstPerspListStatsPtr
typedef std::map< VariablePtr, std::pair< ConstConstraintPtr, ConstConstraintPtr > >	VarUbLb
typedef VarUbLb *	VarUbLbPtr
typedef std::pair< ConstConstraintPtr, ConstVariablePtr >	ConsVar
typedef std::map< ConsVar, VarUbLbPtr >	PerspCons
typedef PerspCons *	PerspConsPtr
typedef const PerspCons *	ConstPerspConsPtr
typedef MonomialFunction *	MonomialFunPtr
typedef const MonomialFunction *	ConstMonomialFunPtr
typedef std::vector< MonomialFunPtr >	MonomialVector
typedef MonomialVector::iterator	MonomialIter
typedef MonomialVector::const_iterator	MonomialConstIter
typedef const PolynomialFunction *	ConstPolyFunPtr
typedef PreDelVars *	PreDelVarsPtr
typedef const PreDelVars *	ConstPreDelVarsPtr
typedef PreModQ::reverse_iterator	PreModQRIter
typedef Presolver *	PresolverPtr
typedef PreSubstVars *	PreSubstVarsPtr
typedef ProblemSize *	ProblemSizePtr
typedef const ProblemSize *	ConstProblemSizePtr
typedef const ProbStructure *	ConstProbStructPtr
typedef ProbStructure *	ProbStructPtr
typedef ProbStructStats *	ProbStructStatsPtr
typedef ProbStructStats const *	ConstProbStructStatsPtr
typedef std::pair< ConstVariablePtr, ConstConstraintVectorPtr >	VarConsPair
typedef std::map< ConstVariablePtr, ConstConstraintVectorPtr >	VarCons
typedef VarCons *	VarConsPtr
typedef VarCons::iterator	VarConsIterator
typedef VarCons::const_iterator	VarConsConstIterator
typedef QGAdvHandler *	QGAdvHandlerPtr
typedef QGHandlerAdvance *	QGHandlerAdvancePtr
typedef QPDProcessor *	QPDProcessorPtr
typedef QPEngine *	QPEnginePtr
typedef LinSqr *	LinSqrPtr
typedef std::vector< LinSqrPtr >	LinSqrVec
	‍Pointer to LinSqr
typedef LinSqrVec::iterator	LinSqrVecIter
	‍Vector of LinSqr
typedef std::map< VariablePtr, LinSqrPtr, CompareVariablePtr >	LinSqrMap
	‍Iterator for LinSqr
typedef LinSqrMap::iterator	LinSqrMapIter
typedef QuadHandler *	QuadHandlerPtr
	Shared pointer to QuadHandler.
typedef std::vector< QuadraticFunctionPtr >	QfVector
typedef UnivarQuadHandler *	UnivarQuadHandlerPtr
	Shared pointer to UnivarQuadHandler.
typedef QuadTransformer *	QuadTranPtr
typedef const QuadTransformer *	ConstQuadTranPtr
typedef RandomBrancher *	RandomBrancherPtr
typedef RCHandler *	RCHandlerPtr
typedef const Relaxation *	ConstRelaxationPtr
typedef ReliabilityBrancher *	ReliabilityBrancherPtr
typedef SamplingHeur *	SamplingHeurPtr
typedef SecantMod *	SecantModPtr
typedef const SecantMod *	ConstSecantModPtr
typedef SimpleTransformer *	SimpTranPtr
typedef const SimpleTransformer *	ConstSimpTranPtr
typedef std::map< int, std::pair< double, double > >	SlackBound
typedef SimplexCut *	SimplexCutPtr
typedef std::vector< SimplexCutPtr >	SimplexCutVector
typedef SimplexQuadCutGen *	SimplexQuadCutGenPtr
typedef std::vector< SolutionPtr >	SolutionPtrVector
typedef std::vector< SolutionPtr >::iterator	SolutionIterator
typedef SOS1Handler *	SOS1HandlerPtr
typedef const SOS1Handler *	ConstSOS1HandlerPtr
typedef SOS2Handler *	SOS2HandlerPtr
typedef const SOS2Handler *	ConstSOS2HandlerPtr
typedef SOSBrCand *	SOSBrCandPtr
typedef STOAHandler *	STOAHandlerPtr
typedef PowHandler *	PowHandlerPtr
typedef RecipHandler *	RecipHandlerPtr
typedef LogHandler *	LogHandlerPtr
typedef ExpHandler *	ExpHandlerPtr
typedef Transformer *	TransformerPtr
typedef const Transformer *	ConstTransformerPtr
typedef TransSep *	TransSepPtr
typedef const TransSep *	ConstTransSepPtr
typedef TreeManager *	TreeManagerPtr
typedef unsigned int	UInt
	Unsigned integer.
typedef std::deque< UInt >	UIntQ
	Containers for standard types.
typedef std::vector< bool >	BoolVector
typedef std::vector< double >	DoubleVector
typedef std::vector< int >	IntVector
typedef std::vector< UInt >	UIntVector
typedef std::set< UInt >	UIntSet
typedef Variable *	VariablePtr
typedef Variable *	ConstVariablePtr
typedef std::vector< VariablePtr >	VarVector
typedef std::deque< VariablePtr >	VarQueue
typedef VarVector::const_iterator	VariableConstIterator
typedef VarVector::iterator	VariableIterator
typedef std::vector< ConstVariablePtr >::iterator	ConstVarIter
typedef VarQueue::const_iterator	VarQueueConstIter
typedef VarQueue::iterator	VarQueueIter
typedef std::set< ConstVariablePtr, CompareVariablePtr >	VariableSet
typedef VariableSet::const_iterator	VarSetConstIterator
typedef std::set< VariablePtr >	VarSet
typedef const Objective *	ConstObjPtr
typedef const Constraint *	ConstConstraintPtr
typedef std::vector< ConstraintPtr >	ConstraintVector
typedef ConstraintVector::iterator	ConstraintIterator
typedef ConstraintVector::const_iterator	ConstraintConstIterator
typedef SOS *	SOSPtr
typedef std::vector< SOS * >	SOSVector
typedef SOSVector::iterator	SOSIterator
typedef SOSVector::const_iterator	SOSConstIterator
typedef ConstraintVector *	ConstraintVectorPtr
typedef std::vector< ConstConstraintPtr >	ConstConstraintVector
typedef ConstConstraintVector *	ConstConstraintVectorPtr
typedef ConstConstraintVector::iterator	ConstConstraintIterator
typedef std::set< ConstraintPtr >	ConstrSet
typedef std::deque< ConstraintPtr >	ConstrQ
typedef VarSet *	VarSetPtr
typedef const VarSet *	ConstVarSetPtr
typedef std::map< ConstVariablePtr, UInt, CompareVariablePtr >	VarIntMap
typedef VarIntMap::const_iterator	VarIntMapConstIterator
typedef VarIntMap::iterator	VarIntMapIterator
typedef VarSet::iterator	VarSetIter
typedef VarSet::const_iterator	VarSetConstIter
typedef std::set< ConstVariablePtr >	ConstVarSet
typedef VarSet::const_iterator	ConstVarSetIter
typedef Node *	NodePtr
typedef std::vector< NodePtr >	NodePtrVector
typedef std::vector< NodePtr >::iterator	NodePtrIterator
typedef Handler *	HandlerPtr
typedef const Handler *	ConstHandlerPtr
typedef std::vector< HandlerPtr >	HandlerVector
typedef HandlerVector::iterator	HandlerIterator
typedef HandlerVector::const_iterator	HandlerConstIterator
typedef const Problem *	ConstProblemPtr
typedef Modification *	ModificationPtr
typedef const Modification *	ConstModificationPtr
typedef std::vector< ModificationPtr >	ModVector
typedef std::vector< ModificationPtr >::const_iterator	ModificationConstIterator
typedef std::vector< ModificationPtr >::const_reverse_iterator	ModificationRConstIterator
typedef std::deque< ModificationPtr >	ModQ
typedef std::stack< ModificationPtr >	ModStack
typedef Branch *	BranchPtr
typedef const Branch *	ConstBranchPtr
typedef std::vector< BranchPtr >	BranchPtrVector
typedef BranchPtrVector *	Branches
typedef std::vector< BranchPtr >::const_iterator	BranchConstIterator
typedef BrCand *	BrCandPtr
typedef const BrCand *	ConstBrCandPtr
typedef std::vector< BrCandPtr >	BrCandVector
typedef BrCandVector::iterator	BrCandVIter
typedef BrVarCand *	BrVarCandPtr
typedef const BrVarCand *	ConstBrVarCandPtr
typedef std::set< BrVarCandPtr, CompareVarBrCand >	BrVarCandSet
typedef BrVarCandSet::iterator	BrVarCandIter
typedef std::vector< BrVarCandPtr >::iterator	BrVarCandVIter
typedef std::pair< int, double >	id
typedef std::pair< ConstVariablePtr, double >	VariableValuePair
typedef VariableValuePair *	VariableValuePairPtr
typedef std::map< ConstVariablePtr, double, CompareValueVarInc >	VariableValueMap
typedef std::vector< VariableValuePair >	VariableValuePairVector
typedef VariableValuePairVector *	VariableValuePairVectorPtr
typedef std::vector< VariableValuePair >::iterator	VariableValuePairVectorIterator
typedef std::vector< VariableValuePair >::const_iterator	VariableValuePairVectorConstIterator
typedef VariableValuePairVector	CoverSet
typedef CoverSet *	CoverSetPtr
typedef const CoverSet *	ConstCoverSetPtr
typedef CoverSet::iterator	CoverSetIterator
typedef CoverSet::const_iterator	CoverSetConstIterator
typedef KnapsackList *	KnapsackListPtr
typedef const KnapsackList *	ConstKnapsackListPtr
typedef CutVector::iterator	CutVectorIter
typedef CutVector::const_iterator	CutVectorConstIter
typedef std::list< CutPtr >	CutList
typedef CutList::iterator	CutListIter
typedef Problem	LiftingProblem
typedef ProblemPtr	LiftingProblemPtr
typedef CoverCutGenerator *	CoverCutGeneratorPtr
typedef Function *	FunctionPtr
typedef const Function *	ConstFunctionPtr
typedef Option< bool >	BoolOption
typedef Option< int >	IntOption
typedef Option< double >	DoubleOption
typedef Option< std::string >	StringOption
typedef BoolOption *	BoolOptionPtr
typedef IntOption *	IntOptionPtr
typedef DoubleOption *	DoubleOptionPtr
typedef StringOption *	StringOptionPtr
typedef BoolOptionPtr	FlagOptionPtr
typedef std::set< BoolOptionPtr >	BoolOptionSet
typedef std::set< IntOptionPtr >	IntOptionSet
typedef std::set< DoubleOptionPtr >	DoubleOptionSet
typedef std::set< StringOptionPtr >	StringOptionSet
typedef BoolOptionSet	FlagOptionSet
typedef BoolOptionSet::iterator	BoolOptionSetIter
typedef IntOptionSet::iterator	IntOptionSetIter
typedef DoubleOptionSet::iterator	DoubleOptionSetIter
typedef StringOptionSet::iterator	StringOptionSetIter
typedef BoolOptionSetIter	FlagOptionSetIter
typedef std::map< ConstVariablePtr, double, CompareVariablePtr >	VariableGroup
	Variables should always be constant within a group.
typedef std::map< ConstVariablePtr, double >::iterator	VariableGroupIterator
typedef std::map< ConstVariablePtr, double >::const_iterator	VariableGroupConstIterator
typedef std::pair< ConstVariablePtr, ConstVariablePtr >	VariablePair
	Pairs of variables are used in quadratic functions.
typedef std::pair< ConstVariablePtr, ConstVariablePtr >	ConstVariablePair
typedef std::map< ConstVariablePair, double, CompareVariablePair >	VariablePairGroup
	Again, Variables should always be constant within a group.
typedef std::map< ConstVariablePair, UInt, CompareVariablePair >	VarPairIntMap
typedef std::map< VariablePair, double >::iterator	VariablePairGroupIterator
typedef std::map< ConstVariablePair, double >::const_iterator	VariablePairGroupConstIterator
typedef std::map< ConstVariablePtr, ConstVariablePtr, CompareVariablePtr >	VarVarMap
typedef VarVarMap::const_iterator	VarVarMapConstIterator
typedef const std::map< ConstVariablePtr, UInt, CompareVariablePtr >	VarCountConstMap
typedef Heuristic *	HeurPtr
typedef std::vector< HeurPtr >	HeurVector
typedef UnambRelBrancher *	UnambRelBrancherPtr
typedef LinUnivar *	LinUnivarPtr
typedef std::vector< LinUnivarPtr >	LinUnivarVec
	‍Pointer to LinUnivar
typedef LinUnivarVec::iterator	LinUnivarVecIter
	‍Vector of LinUnivar
typedef LinBivar *	LinBivarPtr
typedef std::vector< LinBivarPtr >	LinBivarVec
	‍Pointer to LinBivar
typedef LinBivarVec::iterator	LinBivarVecIter
	‍Vector of LinBivar
typedef VarBoundModVector::const_iterator	VarBoundModConstIter
typedef VarBoundMod2 *	VarBoundMod2Ptr
typedef const VarBoundMod2 *	ConstVarBoundMod2Ptr
typedef std::vector< VarBoundMod2Ptr >	VarBoundMod2Vector
typedef VarBoundMod2Vector::iterator	VarBoundMod2Iter
typedef VarBoundMod2Vector::const_iterator	VarBoundMod2ConstIter
typedef std::set< std::pair< ConstraintPtr, FunctionType > >::const_iterator	ConstraintFunIterator
typedef WeakBrancher *	WeakBrancherPtr
typedef BqpdEngine *	BqpdEnginePtr
typedef CbcEngine *	CbcEnginePtr
typedef CpxLPWarmStart *	CpxLPWarmStartPtr
typedef const CpxLPWarmStart *	ConstCpxLPWarmStartPtr
typedef CplexLPEngine *	CplexLPEnginePtr
typedef CplexMILPEngine *	CplexMILPEnginePtr
typedef FilterSQPWarmStart *	FilterWSPtr
typedef const FilterSQPWarmStart *	ConstFilterWSPtr
typedef FilterSQPEngine *	FilterSQPEnginePtr
typedef IpoptEngine *	IpoptEnginePtr
typedef IpoptSolution *	IpoptSolPtr
typedef const IpoptSolution *	ConstIpoptSolPtr
typedef IpoptWarmStart *	IpoptWarmStartPtr
typedef const IpoptWarmStart *	ConstIpoptWarmStartPtr
typedef OsiLPWarmStart *	OsiLPWarmStartPtr
typedef const OsiLPWarmStart *	ConstOsiLPWarmStartPtr
typedef OsiLPEngine *	OsiLPEnginePtr
typedef qpOASESEngine *	qpOASESEnginePtr
typedef UnoEngine *	UnoEnginePtr
typedef UnoSolution *	UnoSolPtr
typedef const UnoSolution *	ConstUnoSolPtr
typedef UnoWarmStart *	UnoWarmStartPtr
typedef const UnoWarmStart *	ConstUnoWarmStartPtr

Enumerations
enum	PrintType {   Cover = 0 , Cons , Obj , Set ,   Cover = 0 , Cons , Obj , Set }
enum	KnapCovType {   Totalcuts = 0 , Cuts , Violated , Extended ,   Simple , Gns , Singlectwo , Basic ,   Noviol , Noinitcover }
enum	PrintType {   Cover = 0 , Cons , Obj , Set ,   Cover = 0 , Cons , Obj , Set }
enum	LGCIType {   Totalcuts = 0 , Cuts , Violated , Gns ,   Noviol , Noinitcover }
enum	CutFail { Duplicate = 0 , NotViolated }
enum	Direction {   Floor , Ceil , Nearest , Farthest ,   Floor , Ceil , Nearest , Farthest }
	Direction of rounding. More...
enum	Order { Least , Most , Least , Most }
	Order of rounding: least fractional or most fractional. More...
enum	Scoretype {   Fractional , VectorLength , LexBound , ReducedCost ,   Fractional , VectorLength , LexBound , ReducedCost }
	Type of score evaluation for fractional variable. More...
enum	OpCode {   OpAbs , OpAcos , OpAcosh , OpAsin ,   OpAsinh , OpAtan , OpAtanh , OpCeil ,   OpCos , OpCosh , OpCPow , OpDiv ,   OpExp , OpFloor , OpInt , OpIntDiv ,   OpLog , OpLog10 , OpMinus , OpMult ,   OpNone , OpNum , OpPlus , OpPow ,   OpPowK , OpRound , OpSin , OpSinh ,   OpSqr , OpSqrt , OpSumList , OpTan ,   OpTanh , OpUMinus , OpVar }
enum	Direction {   Floor , Ceil , Nearest , Farthest ,   Floor , Ceil , Nearest , Farthest }
	Direction of rounding. More...
enum	Order { Least , Most , Least , Most }
	Order of rounding: least fractional or most fractional. More...
enum	Scoretype {   Fractional , VectorLength , LexBound , ReducedCost ,   Fractional , VectorLength , LexBound , ReducedCost }
	Type of score evaluation for fractional variable. More...
enum	FileType { MPS , NL , FileTypeNone }
	Different types of files for reading/writing.
enum	ProblemType {   LP , MILP , QP , MIQP ,   QCQP , MIQCQP , POLYP , MIPOLYP ,   NLP , MINLP , OtherProblemType }
	The different classes of problems.
enum	ObjectiveType { Minimize , Maximize }
enum	FunctionType {   Constant , Linear , Multilinear , Quadratic ,   Nonlinear , Polynomial , OtherFunctionType }
	Different types of functions in Minotaur.
enum	VariableType {   Binary , Integer , ImplBin , ImplInt ,   Continuous }
	Different types of variables. More...
enum	VarSrcType {   VarOrig , VarTran , VarSep , VarHand ,   VarOtherSrc }
	Where did the variable originate from? More...
enum	ConsSrcType {   ConsOrig , ConsTran , ConsTranOrig , ConsHand ,   ConsCut }
	Where did the constraint originate from? More...
enum	ConsType {   Aggregation , Precedence , VariableBound , SetPartition ,   SetPack , SetCover , Cardinality , InvariantKnapsack ,   EquationKnapsack , BinPack , Knapsack , IntegerKnapsack ,   MixedBinary , General , Quad , DiagQuad ,   SimpleBall , Ellipsoid , ComplementSimpleBall , ComplementEllipsoid ,   PureBilinear , SOCRepresentableQuad , NonLin }
enum	BoundType { Lower , Upper }
	Different types of variable-bounds.
enum	SOSType { SOS1 , SOS2 }
	SOS types.
enum	VarState { DeletedVar , FixedVar , FreeVar , NormalVar }
	Different states a variable can be in. More...
enum	ConsState { DeletedCons , FreeCons , NormalCons }
	Different states a constraint can be in. More...
enum	ObjState { DeletedObj , NormalObj }
	Different states an objective can be in. More...
enum	SolveStatus {   NotStarted , Started , Restarted , SolvedOptimal ,   SolvedInfeasible , SolvedUnbounded , SolvedGapLimit , SolvedSolsLimit ,   IterationLimitReached , Interrupted , TimeLimitReached , SolLimitReached ,   SolveError , Finished }
	Different states an algorithm like branch-and-bound can be in.
enum	EngineStatus {   ProvenOptimal , ProvenLocalOptimal , ProvenInfeasible , ProvenLocalInfeasible ,   ProvenUnbounded , ProvenObjectiveCutOff , EngineIterationLimit , ProvenFailedCQFeas ,   ProvenFailedCQInfeas , FailedFeas , FailedInfeas , EngineError ,   EngineUnknownStatus }
	Different status that an external engine may report.
enum	BrancherStatus { ModifiedByBrancher , PrunedByBrancher , NoCandToBranch , NotModifiedByBrancher }
	What can a brancher do to a node in branch-and-bound.
enum	BranchDirection { DownBranch , UpBranch , OtherBranchDir }
	Two directions for branching.
enum	NodeStatus {   NodeNotProcessed , NodeInfeasible , NodeHitUb , NodeDominated ,   NodeOptimal , NodeContinue , NodeStopped }
	Status of a node in branch-and-bound.
enum	SeparationStatus {   SepaContinue , SepaResolve , SepaPrune , SepaNone ,   SepaError }
	Status from separation routine: More...
enum	LogLevel {   LogNone , LogError , LogInfo , LogExtraInfo ,   LogDebug , LogDebug1 , LogDebug2 }
	Levels of verbosity.
enum	TreeSearchOrder { DepthFirst , BestFirst , BestThenDive }
	Order of tree search. More...
enum	Convexity { Convex , Concave , Nonconvex , Unknown }
	Convexity of a function or a constraint. More...
enum	VbcColors {   VbcActive = 4 , VbcFeas = 2 , VbcInf = 11 , VbcSolved = 9 ,   VbcSolving = 8 , VbcSubInf = 13 , VbcSubOpt = 6 }
	Colors for tree-visualization using vbc. More...
enum	MpiMessageTag {   Terminate = 0 , NodeFound = 1 , Wait = 2 , UB = 3 ,   LB = 4 }
	Tags (int) for messages for distributed-memory (MPI) parallel tree-search. More...
enum	OsiLPEngineName {   OsiClpEngine , OsiGlpkEngine , OsiGrbEngine , OsiMskEngine ,   OsiSpxEngine , OsiXprEngine , OsiUndefEngine }

Functions
bool	CompareScore (BrCandPtr c1, BrCandPtr c2)
	Comparison function to sort candidates in the decreasing order of their score.
bool	valueGreaterThan (ConstNodePtr n1, ConstNodePtr n2)
bool	depthGreaterThan (ConstNodePtr n1, ConstNodePtr n2)
bool	isInt (double v, double tol=1e-12)
double	InnerProduct (const VariableGroup &g1, const VariableGroup &g2)
double	InnerProduct (const std::vector< double > &x, const VariableGroup &g2)
double	InnerProduct (const double *x, const double *a, int n)
	Inner product of two arrays, x and a, each of size n.
void	symMatDotV (UInt nz, const double *mat, const UInt *irow, const UInt *jcol, const double *v, double *prod)
void	BoundsOnDiv (double l0, double u0, double l1, double u1, double &lb, double &ub)
void	RevBoundsOnMult (double l0, double u0, double l1, double u1, double &lb, double &ub)
double	round (double v)
	return the nearest integer to the given double value
void	BoundsOnProduct (bool zero_x_inf_zero, ConstVariablePtr x0, ConstVariablePtr x1, double &lb, double &ub)
void	BoundsOnProduct (bool zero_x_inf_zero, double l0, double u0, double l1, double u1, double &lb, double &ub)
void	BoundsOnRecip (double l0, double u0, double &lb, double &ub)
void	BoundsOnSquare (ConstVariablePtr x1, double &lb, double &ub)
	Get lower and upper bounds on a square of variable.
void	BoundsOnSquare (const double x_lb, const double y_lb, double &lb, double &ub)
bool	CompareLen (Constraint *c1, Constraint *c2)
double	Gcd (double d1, double d2, const double &etol=1e-9)
double	getDistance (const double *Pointa, const double *Pointb, UInt n)
double	minArray (const double *A, UInt n)
void	displayArray (const double *point, UInt n, std::ostream &out)
	To display the initial point.
void	sort (VarVector &vvec, double *x, bool ascend=true)
	Sort a vector of variables according to values of x.
void	sortRec (VarVector &vvec, double *x, int left, int right, int pivotind)
void	toLowerCase (std::string &str)
	Convert a string to lower case.
std::string	toClockTime (double t)
	Convert a double representing seconds into wall clock time HH:MM:SS:mm.
FunctionType	funcTypesAdd (FunctionType f1, FunctionType f2)
	What is the function type on adding two functions f1 and f2?
FunctionType	funcTypesMult (FunctionType f1, FunctionType f2)
	What is the function type on multiplying two functions f1 and f2?
std::string	getProblemTypeString (ProblemType p)
	Get the string equivalent of ProblemType.
std::string	getFunctionTypeString (FunctionType f)
	Get the string equivalent of FunctionType.
std::string	getSolveStatusString (SolveStatus s)
	Get the string equivalent of SolveStatus.

Detailed Description

This class handles all output. Attached to each message is the level and only output requested by the user is generated. Formation of C-style output is delayed until after the level is checked. C++-style output requires that a string be written and passed to the logger; the code needs to check if the output would be used prior to constructing it.

Note GAMS will create a derived class that differentiates where to send the output (log, listing, or status files) based on the level. A FORTRAN derived class will create a string and send it to a wrapper that writes the string using FORTRAN calls.

We may want to describe the output levels in this section.

Typedef Documentation

LinkPowMap

typedef std::map<VariablePtr, LinkPowPtr, CompareVariablePtr> Minotaur::LinkPowMap

‍Iterator for LinkPow

Map of 'x' and the LinkPow that is used for .

LinSqrMap

typedef std::map<VariablePtr, LinSqrPtr, CompareVariablePtr> Minotaur::LinSqrMap

‍Iterator for LinSqr

Map of 'x' and the LinSqr that is used for .

Enumeration Type Documentation

ConsSrcType

enum Minotaur::ConsSrcType

Where did the constraint originate from?

Enumerator
ConsTran	‍Constraint was part of the original problem
ConsTranOrig	‍Constraint added by Transformer
ConsHand	‍Constraint added by Transformer as a reformulation of original constraint
ConsCut	‍Constraint added by Handler ‍Constraint added as a cut

ConsState

enum Minotaur::ConsState

Different states a constraint can be in.

Enumerator
DeletedCons	Marked for deletion.
FreeCons	Doesn't have bounds. Implies redundant.
NormalCons	Not in any other category.

ConsType

enum Minotaur::ConsType

What type of constraint is this. Add enum items here if more constraint types are identified.

Enumerator
Precedence	‍ax + by = c
VariableBound	‍ax - ay \leq b, x & y have the same type
SetPartition	‍ax + by \leq c, x is Binary
SetPack	‍\sum_{i=1}^n x_i = 1, x_i is Binary
SetCover	‍\sum_{i=1}^n x_i \leq 1, x_i is Binary
Cardinality	‍\sum_{i=1}^n x_i \geq 1, x_i is Binary
InvariantKnapsack	‍\sum_{i=1}^n x_i = k, x_i is Binary, k \geq 2
EquationKnapsack	‍\sum_{i=1}^n x_i \leq b, x_i is Binary, b \in \mathbb{N} \geq 2
BinPack	‍\sum_{i=1}^n a_i*x_i = b, x_i is Binary, b \in \mathbb{N} \geq 2
Knapsack	‍\sum_{i=1}^n a_i*x_i + by = b, x_i, y is Binary, b \in \mathbb{N} \geq 2
IntegerKnapsack	‍\sum_{i=1}^n a_i*x_i \leq b, x_i is Binary
MixedBinary	‍\sum_{i=1}^n a_i*x_i \leq b, x_i is Integer
General	‍Linear combination of at least one binary variable with continuous variables
Quad	‍No specific structure identififed
DiagQuad	‍Quadratic
SimpleBall	‍Purely Quadratic with all zero elements of hessian except diagonal elements
Ellipsoid	‍\sum_{i=1}^n x_i^2 \leq b, b \geq 0
ComplementSimpleBall	‍\sum_{i=1}^n a_i*x_i^2 \leq b, b \geq 0, a_i \geq 0
ComplementEllipsoid	‍Complement of SimpleBall
PureBilinear	‍Complement of Ellipse
SOCRepresentableQuad	‍\sum_{i=1}^n x_i*x_{i+a} \leq b or \geq b, where a \in \mathbb{Z}^{+}
NonLin	‍Quadratic constraint which can be represented as SOC constraint >Non-linear

Convexity

enum Minotaur::Convexity

Convexity of a function or a constraint.

Enumerator
Nonconvex	Constraint can't be concave only functions can be concave.

Direction [1/2]

enum Minotaur::Direction

Direction of rounding.

Enumerator
Ceil	Round to the smallest integer.
Nearest	Round to the largest integer.
Farthest	Round to the nearest integer. Round to the farthest integer
Ceil	Round to the smallest integer.
Nearest	Round to the largest integer.
Farthest	Round to the nearest integer. Round to the farthest integer

Direction [2/2]

enum Minotaur::Direction

Direction of rounding.

Enumerator
Ceil	Round to the smallest integer.
Nearest	Round to the largest integer.
Farthest	Round to the nearest integer. Round to the farthest integer
Ceil	Round to the smallest integer.
Nearest	Round to the largest integer.
Farthest	Round to the nearest integer. Round to the farthest integer

MpiMessageTag

enum Minotaur::MpiMessageTag

Tags (int) for messages for distributed-memory (MPI) parallel tree-search.

Enumerator
NodeFound	Tree fully solved, terminate.
Wait	Node is available, receive it.
UB	Wait untill further notice.
LB	Upper bound is shared.

ObjectiveType

enum Minotaur::ObjectiveType

Objective sense. Minotaur minimizes. Always. If the sense is to Maximize, then Minotaur converts the objective.

ObjState

enum Minotaur::ObjState

Different states an objective can be in.

Enumerator
DeletedObj	Marked for deletion.
NormalObj	Not in any other category.

Order [1/2]

enum Minotaur::Order

Order of rounding: least fractional or most fractional.

Enumerator
Most	Select the variable with Least fractional part. Select the variable with Most fractional part
Most	Select the variable with Least fractional part. Select the variable with Most fractional part

Order [2/2]

enum Minotaur::Order

Order of rounding: least fractional or most fractional.

Enumerator
Most	Select the variable with Least fractional part. Select the variable with Most fractional part
Most	Select the variable with Least fractional part. Select the variable with Most fractional part

Scoretype [1/2]

enum Minotaur::Scoretype

Type of score evaluation for fractional variable.

Enumerator
VectorLength	Score of variable is the fractional part`.
LexBound	Score of variable is the Vector Length.
ReducedCost	Score of variable is the index of the variable. Score of variable is the reduced cost
VectorLength	Score of variable is the fractional part`.
LexBound	Score of variable is the Vector Length.
ReducedCost	Score of variable is the index of the variable. Score of variable is the reduced cost

Scoretype [2/2]

enum Minotaur::Scoretype

Type of score evaluation for fractional variable.

Enumerator
VectorLength	Score of variable is the fractional part`.
LexBound	Score of variable is the Vector Length.
ReducedCost	Score of variable is the index of the variable. Score of variable is the reduced cost
VectorLength	Score of variable is the fractional part`.
LexBound	Score of variable is the Vector Length.
ReducedCost	Score of variable is the index of the variable. Score of variable is the reduced cost

SeparationStatus

enum Minotaur::SeparationStatus

Status from separation routine:

Enumerator
SepaContinue	Separation routine wants nothing.
SepaResolve	Separation routine wants the relaxation resolved.
SepaPrune	No need to further solve the subproblem.
SepaNone	No separation found.
SepaError	Problem separating a point.

TreeSearchOrder

enum Minotaur::TreeSearchOrder

Order of tree search.

Enumerator
BestThenDive	First find the best bound, then dive until pruned.

VariableType

enum Minotaur::VariableType

Different types of variables.

Enumerator
Binary	Variable is constrained to be binary.
Integer	Variable is constrained to be integer.
ImplBin	Variable is continuous, but will take binary values only.
ImplInt	Variable is continuous, but will take integer values only.
Continuous	Variable is continuous.

VarSrcType

enum Minotaur::VarSrcType

Where did the variable originate from?

Enumerator
VarTran	‍Variable was part of the original problem
VarSep	‍Variable created by Transformer
VarHand	‍Variable created by TransSep for separable constraints
VarOtherSrc	‍Variable created by Handler ‍Variable created by some other source

VarState

enum Minotaur::VarState

Different states a variable can be in.

Enumerator
DeletedVar	Marked for deletion.
FixedVar	Fixed to a value.
FreeVar	Doesn't have bounds. Same as superbasic in LP.
NormalVar	Not in any other category.

VbcColors

enum Minotaur::VbcColors

Colors for tree-visualization using vbc.

Enumerator
VbcFeas	Unsolved, open.
VbcInf	incumbent.
VbcSolved	infeasible.
VbcSolving	solved.
VbcSubInf	currently being solved.
VbcSubOpt	subtree is infeasible.

Function Documentation

BoundsOnProduct() [1/2]

void Minotaur::BoundsOnProduct	(	bool	zero_x_inf_zero,
		ConstVariablePtr	x0,
		ConstVariablePtr	x1,
		double &	lb,
		double &	ub
	)

Get bounds on y, where . If zero_x_inf_zero is true, then product of 0 and infinity is taken as zero.

BoundsOnProduct() [2/2]

void Minotaur::BoundsOnProduct	(	bool	zero_x_inf_zero,
		double	l0,
		double	u0,
		double	l1,
		double	u1,
		double &	lb,
		double &	ub
	)

Get bounds on y, where . If zero_x_inf_zero is true, then product of 0 and infinity is taken as zero.

BoundsOnSquare()

void Minotaur::BoundsOnSquare	(	const double	x_lb,
		const double	y_lb,
		double &	lb,
		double &	ub
	)

Get lower and upper bounds on a square of variable whose bounds are provided.

CompareLen()

bool Minotaur::CompareLen	(	Constraint *	c1,
		Constraint *	c2
	)

Comparison to sort constraints in the increasing number of number of variables they have.

Gcd()

double Minotaur::Gcd	(	double	d1,
		double	d2,
		const double &	etol = 1e-9
	)

Get gcd(d1, d2). Returns d2 if d1 is zero. Returns d1 if d2 is zero. Otherwise, returns largest x > 0 s.t. d1/x and d2/x are integers. e.g. Gcd(10.5, 7.0) = 3.5. If d1 is zero, returns abs(d2), if d2 is zero, returns abs(d1).

getDistance()

double Minotaur::getDistance	(	const double *	Pointa,
		const double *	Pointb,
		UInt	n
	)

Get distance(a,b,n). Returns the Euclidian distance between point a and point b which in n-dimensional space.

minArray()

double Minotaur::minArray	(	const double *	A,
		UInt	n
	)

Get minArray. Returns the minimum element of a dynamic array.

RevBoundsOnMult()

void Minotaur::RevBoundsOnMult	(	double	l0,
		double	u0,
		double	l1,
		double	u1,
		double &	lb,
		double &	ub
	)

Get bounds on x2, where and ,and .