Classes
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	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 $y \leq x^2$ . 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 $y \leq x^2$ . More...

struct	LinStats

struct	LinUnivar
	A structure to save information about constraints of the form . More...

class	Logger

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 $\prod_ia_ix_i^{b_i}$ where $a_i \in \mathbb{R}, b_i \in \mathbb{N}$ . 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 $\sum_jm_j$ , where is a MonomialFunction. More...

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	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 $y \leq x^2$ . 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 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 $y \leq x^2$ .

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

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

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 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 Logger *	LoggerPtr

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 Environment *	EnvPtr

typedef Problem *	ProblemPtr

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 $ y = x^2 $ .

◆ LinSqrMap

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

‍Iterator for LinSqr

Map of 'x' and the LinSqr that is used for $ y = x^2 $ .

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 $ y = x_0x_1 $ . 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 $ y = x_0x_1 $ . 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 $ y = x1*x2 $ and $y \in [l0, u0]$ ,and $x \in [l1, u1]$ .

Classes

Typedefs

Enumerations

Functions

Detailed Description

Typedef Documentation

◆ LinkPowMap

◆ LinSqrMap

Enumeration Type Documentation

◆ ConsSrcType

◆ ConsState

◆ ConsType

◆ Convexity

◆ Direction [1/2]

◆ Direction [2/2]

◆ MpiMessageTag

◆ ObjectiveType

◆ ObjState

◆ Order [1/2]

◆ Order [2/2]

◆ Scoretype [1/2]

◆ Scoretype [2/2]

◆ SeparationStatus

◆ TreeSearchOrder

◆ VariableType

◆ VarSrcType

◆ VarState

◆ VbcColors

Function Documentation

◆ BoundsOnProduct() [1/2]

◆ BoundsOnProduct() [2/2]

◆ BoundsOnSquare()

◆ CompareLen()

◆ Gcd()

◆ getDistance()

◆ minArray()

◆ RevBoundsOnMult()