base Directory Reference

Directory dependency graph for base:

Directories
	unused

Files
	ActiveNodeStore.h
	Declare the base class ActiveNodeStore for storing active nodes of the branch-and-bound tree.
	AnalyticalCenter.cpp
	AnalyticalCenter.h
	BndProcessor.cpp
	Implement simple node-processor for branch-and-bound.
	BndProcessor.h
	Define simple node-processor for branch-and-bound.
	Branch.cpp
	Define the class Branch for describing branches in branch-and-bound.
	Branch.h
	Declare the class Branch for describing branches in branch-and-bound.
	BranchAndBound.cpp
	Define BranchAndBound class for a generic branch-and-bound method.
	BranchAndBound.h
	Declare the BranchAndBound class for branch-and-bound-algorithm, BabStats class for statistics and BabOptions class for options.
	Brancher.h
	Declare the base class Brancher for finding and creating branches in Branch-and-Bound.
	BrCand.cpp
	Define the classes BranchCand for storing candidates for branching.
	BrCand.h
	Declare the classes BranchCand storing candidates for branching.
	BrVarCand.cpp
	Define the classes BrVarCand for storing candidates for branching on variables.
	BrVarCand.h
	Declare the classes BrVarCand storing candidates for branching.
	CGraph.cpp
	Define class CGraph for storing computational graph of a nonlinear function.
	CGraph.h
	Declare class CGraph for storing computational graph of a nonlinear function.
	Chol.h
	CNode.cpp
	Define class CNode for representing a node of computational graph of a nonlinear function.
	CNode.h
	Declare class CNode to represent node of a computational graph of a nonlinear function.
	ConBoundMod.cpp
	Implement the Modification class ConBoundMod, that is used to store modifications to a bound on a constraint.
	ConBoundMod.h
	Declare the class ConBoundMod. It is used to save modifications in a bound of a constraint. Also declare ConBoundMod2 that is used to change both bounds of a constraint. Also declare ConMod that is used to change nonlinear part of the constraint.
	Constraint.cpp
	Define the Constraint class.
	Constraint.h
	Get information about a constraint in a given Problem.
	CoverCutGenerator.cpp
	Define base class CoverCutGenerator.
	CoverCutGenerator.h
	Declare base class CoverCutGenerator.
	Cut.cpp
	Update information required by CutManager for each cut.
	Cut.h
	Declare the Cut class of valid inequalities.
	CutInfo.cpp
	Implement the methods of Cut class.
	CutInfo.h
	Define the Cut class for valid inequalities and additional information.
	CutMan1.cpp
	Implement the methods of CutMan1 class.
	CutMan1.h
	Manages addition and deletion of cuts to problem.
	CutMan2.cpp
	Implement the methods of CutMan2 class.
	CutMan2.h
	Manages addition and deletion of cuts to problem.
	CutManager.h
	Manages addition and deletion of cuts to problem.
	CutPool.h
	Declare class CutPool for storing cuts.
	CxQuadHandler.cpp
	Implement the handler for functions of the general quadratic form , where may be indefinite.
	CxQuadHandler.h
	Define the CxQuadHandler class for handling convex quadratic objective functions and constraints.
	CxUnivarHandler.cpp
	Implement the handler for functions of the general univariate convex form y=g(x).
	CxUnivarHandler.h
	Define the CxUnivarHandler class for handling convex univariate functions.
	DistParBranchAndBound.cpp
	Define DistParBranchAndBound class for a distributed memory parallel branch-and-bound.
	DistParBranchAndBound.h
	Declare the distributed memory parallel branch-and-bound-algorithm.
	Eigen.cpp
	Define class Eigen for computing eigen values and vectors of a matrix.
	Eigen.h
	Declare methods and data structures of Eigen class for computing eigen values and vectors of a matrix.
	Engine.h
	Define the base class Engine.
	Environment.cpp
	Implement the Environment class.
	Environment.h
	Define the Environment class.
	Exception.h
	FeasibilityPump.cpp
	Define the Feasibility Pump class for generating a feasible solution using FP heuristic for MINLPs.
	FeasibilityPump.h
	Declare the class FeasibilityPump derived from base class Heuristic.
	FixVarsHeur.cpp
	Define the FixVarsHeur class for diving heuristics for MINLPs.
	FixVarsHeur.h
	Define the class FixVarsHeur derived from base class Heuristics.
	Function.h
	Get information about a Function.
	Gradient.h
	Get information about gradient of a function.
	Handler.h
	Define abstract base class for handlers of various kinds.
	HessianOfLag.h
	Declare class HessianOfLag to get information about hessian of Lagrangean of a Problem.
	Heuristic.h
	Define abstract base class for heuristics of various kinds.
	HybridBrancher.cpp
	Define methods for Hybrid branching.
	HybridBrancher.h
	Declare methods and data structures for Hybrid branching.
	IntVarHandler.cpp
	Define the IntVarHandler class for handling integer constrained variables. It checks integrality and provides branching candidates. Does not do any presolving and cut-generation.
	IntVarHandler.h
	Declare the IntVarHandler class for handling integer constrained variables. It checks integrality and provides branching candidates. Does not do any presolving and cut-generation.
	Iterate.h
	Jacobian.h
	Get information about Jacobian of a given Problem.
	KnapCovHandler.h
	Declare the KnapCovHandler class for handling knapsack cover constraints. It generates the cuts whenever they are needed.
	KnapsackList.cpp
	Define base class KnapsackList.
	KnapsackList.h
	Declare base class KnapsackList.
	kPowHandler.cpp
	Implement a handler for k power constraints of the form , where ,.
	kPowHandler.h
	Declare a handler for simple Quadratic constraints of the form , and , It does not handle any other Quadratic constraints.
	LexicoBrancher.cpp
	Define methods for Lexicographic branching.
	LexicoBrancher.h
	Declare methods and data structures for lexicographic branching.
	LGCIGenerator.cpp
	Declare base class LGCIGenerator.
	LGCIGenerator.h
	Declare base class KnapsackList.
	LinBil.cpp
	Implement routines to store and modify linear constraints obtained by relexing bilinear constraints of the form ,.
	LinBil.h
	Declare a class for storing linear under and overestimators of bilinear functions ,.
	LinConMod.cpp
	Implement the Modification class LinConMod, that is used to store modifications to the linear parts and rhs of a constraint.
	LinConMod.h
	Declare the class LinConMod. It is used to save modifications in the linear functions of constraints.
	LinearCut.cpp
	Implement the methods of LinearCut class.
	LinearCut.h
	Define the class of valid inequalities of the form .
	LinearFunction.h
	Declare the class LinearFunction for storing and modifying a linear function.
	LinearHandler.cpp
	Handle linear contraints, including simple bound constraints on variables. Implements methods for relaxing, presolving and separating. Should not be used for checking integrality or branching on variables.
	LinearHandler.h
	Declare the LinearHandler class for handling integer and continuous variables.
	Linearizations.cpp
	Linearizations.h
	LinFeasPump.cpp
	Implements the class Feasibility Pump.
	LinFeasPump.h
	Feasibility pump using Linear relaxation.
	LinMods.cpp
	Implement the Modification class LinMods, that is used to store modifications to the linear parts and rhs of a constraint.
	LinMods.h
	Declare the class LinMods. It is used to save several modifications in the linear functions of constraints and changes in bounds of variables.
	Logger.h
	Declare class for creating logs.
	LPEngine.h
	Declare the class LPEngine for solving LPs and getting solution.
	LPRelaxation.h
	MaxFreqBrancher.cpp
	Define methods for maximum-frequency branching.
	MaxFreqBrancher.h
	Declare methods and data structures for maximum-frequency branching.
	MaxInfBrancher.cpp
	Define methods for hybrid-inference branching name as maxinf.
	MaxInfBrancher.h
	Declare methods and data structures for hybrid-inference score branching.
	MaxVioBrancher.cpp
	Define methods for maximum violation branching candidate.
	MaxVioBrancher.h
	Declare methods and data structures for maximum violation branching.
	MILPEngine.h
	Declare the class MILPEngine for solving MILPs and getting solution.
	MINLPDiving.cpp
	Define the MINLPDiving class for diving heuristics for MINLPs.
	MINLPDiving.h
	Define the class MINLPDiving derived from base class Heuristics.
	MinotaurCFortran.h
	MinotaurDeconfig.h
	Modification.h
	MsProcessor.cpp
	Implement simple multi-start node-processor for branch-and-bound.
	MsProcessor.h
	Define multi-start node-processor for branch-and-bound.
	MultilinearHandler.cpp
	Handles Multilinear Constraints.
	MultilinearHandler.h
	Declare the MultilinearHandler class for handling Multilinear constraints.
	MultilinearTermsHandler.cpp
	Handles Multilinear Terms. Each term must appear as equal to some auxiliary variable.
	MultilinearTermsHandler.h
	A Handler for a general collection of MultilinearTerms.
	MultiSolHeur.cpp
	Define the MultiSolHeur class for generating a feasible solution using NLP and MILP solves for MINLPs.
	MultiSolHeur.h
	Declare the class MultiSolHeur derived from base class Heuristic.
	NLPEngine.h
	Declare NLPEngine Class for solving nonlinear problems using a nonlinear solver.
	NLPMultiStart.cpp
	Multi start heuristic for continuous NLPs.
	NLPMultiStart.h
	Define a derived class from class Heuristic for multistart heuristic.
	NLPRelaxation.cpp
	Implement methods and functions of an NLP Relaxation.
	NLPRelaxation.h
	NlPresHandler.cpp
	Presolve nonlinear contraints.
	NlPresHandler.h
	Declare the NlPresHandler class for try some NLP presolve ideas.
	NlWriter.cpp
	write an nl file
	NlWriter.h
	Declare class NlWriter for writing nl files.
	Node.cpp
	Define class Node for storing information about nodes.
	Node.h
	Define base class Node.
	NodeFullRelaxer.cpp
	Define the class NodeFullRelaxer.
	NodeFullRelaxer.h
	Declare the NodeFullRelaxer class. It creates relaxation by fully recreating the relaxation at each node.
	NodeHeap.cpp
	Define class NodeHeap for storing active nodes.
	NodeHeap.h
	Define the class NodeHeap for storing active nodes of the branch-and-bound tree on a heap.
	NodeIncRelaxer.cpp
	Define the class NodeIncRelaxer.
	NodeIncRelaxer.h
	Declare the NodeIncRelaxer class. It creates relaxation by only incrementing changes made in ancestor nodes.
	NodeProcessor.cpp
	Define two functions of NodeProcessor class.
	NodeProcessor.h
	Define the NodeProcessor class for processing nodes in the branch-and-bound algorithm.
	NodeRelaxer.h
	Define the NodeRelaxer class for creating relaxation for nodes in the branch-and-bound algorithm.
	NodeStack.cpp
	Implement the class NodeStack for storing active nodes of the branch-and-bound tree on a stack data structure.
	NodeStack.h
	Define the class NodeStack for storing active nodes of the branch-and-bound tree on a stack data structure.
	NonlinearFunction.cpp
	Define some basic functions for abstract base class NonlinearFunction.
	NonlinearFunction.h
	Declare abstract base class NonlinearFunction.
	OAHandler.cpp
	OAHandler.h
	Objective.cpp
	Define the Objective class for storing and manipulating objective function.
	Objective.h
	Declare the Objective class for storing and manipulating objective function.
	OpCode.h
	Declare the OpCodes used in Minotaur.
	Operations.cpp
	Define some commonly used functions.
	Operations.h
	Declare some commonly used functions.
	Option.h
	Declare the Option class for managing options for Minotaur.
	ParBndProcessor.cpp
	Implement simple node-processor for parallel branch-and-bound.
	ParBndProcessor.h
	Define simple node-processor for parallel branch-and-bound.
	ParBranchAndBound.cpp
	Define ParBranchAndBound class for a generic parallel branch-and-bound method.
	ParBranchAndBound.h
	Declare the default branch-and-bound-algorithm.
	ParCutMan.cpp
	Implement the methods of ParCutMan class.
	ParCutMan.h
	Manages storage, addition and deletion of cuts to problem.
	ParMINLPDiving.cpp
	Define the ParMINLPDiving class for diving heuristics for MINLPs. This is a parallel extension of MINLPDiving heuristic in MINOTAUR.
	ParMINLPDiving.h
	Define the class ParMINLPDiving derived from base class Heuristics. This is a parallel extension of MINLPDiving heuristic in MINOTAUR.
	ParNodeIncRelaxer.cpp
	Define the class ParNodeIncRelaxer.
	ParNodeIncRelaxer.h
	Declare the ParNodeIncRelaxer class. It creates relaxation by only incrementing changes made in ancestor nodes. All modifications to be applied while creating the relaxation are fist translated appropriately.
	ParPCBProcessor.cpp
	Define the derived class of NodeProcessor that solves LP or NLP relaxations for parallel algorithms.
	ParPCBProcessor.h
	Define the derived class of NodeProcessor that solves LP relaxations.
	ParQGBranchAndBound.cpp
	Define ParQGBranchAndBound class for a generic parallel branch-and-bound method.
	ParQGBranchAndBound.h
	Declare the default branch-and-bound-algorithm.
	ParQGHandler.cpp
	ParQGHandler.h
	ParQGHandlerAdvance.cpp
	ParQGHandlerAdvance.h
	ParReliabilityBrancher.cpp
	Define methods for reliability branching in a parallel framework.
	ParReliabilityBrancher.h
	ParTreeManager.cpp
	Define class ParTreeManager for managing tree for parallel Branch-and-Bound.
	ParTreeManager.h
	PCBProcessor.cpp
	Define the derived class of NodeProcessor that solves LP or NLP relaxations.
	PCBProcessor.h
	Define the derived class of NodeProcessor that solves LP or NLP relaxations.
	PerspCon.cpp
	Define base class for finding constraints amenable to perspective reformulation (PR) in the given problem. \Author Meenarli Sharma, Indian Institute of Technology Bombay.
	PerspCon.h
	Declare a base class PerspCon for identifying structures amenable to perspective reformulation (PR) (mention the paper)
	PerspCutGenerator.cpp
	Declare PerspCutGenerator class.
	PerspCutGenerator.h
	PerspCutHandler.cpp
	Declare PerspCutHandler class to generate perspective cuts.
	PerspCutHandler.h
	Declare PerspCutHandler class for perspective reformulation (PR). It detects constraints amenable to perspective reformulation and generates perspective cuts whenever needed.
	PerspList.cpp
	Define base class that determines perspective constraints..
	PerspList.h
	Declare base class PerspList.
	PolynomialFunction.h
	Define the PolynomialFunction class for handling polynomial constraints.
	PreAuxVars.cpp
	Define the PreAuxVars class for saving additional variables variables added during presolve.
	PreAuxVars.h
	Declare the PreAuxVars class for saving additional variables variables added during presolve.
	PreDelVars.cpp
	Postsolver for substituted variables.
	PreDelVars.h
	Declare the PreDelVars class for saving and restoring variables in presolve.
	PreMod.h
	Declare the PreMod class for saving changes in presolve.
	Presolver.cpp
	Define Presolver class for presolving.
	Presolver.h
	Declare Presolver class for presolving.
	PreSubstVars.cpp
	Postsolver for substituted variables.
	PreSubstVars.h
	Declare the PreSubstVars class for saving and restoring variables substituted during presolve.
	Problem.cpp
	Define base class Problem.
	Problem.h
	Declare the base class Modification.
	ProblemSize.h
	Declare structure ProblemSize for storing statistics about the problem.
	ProbStructure.cpp
	Define base class for Problem structure.
	ProbStructure.h
	Declare base class ProbStructure.
	QGAdvHandler.cpp
	QGAdvHandler.h
	QGHandler.cpp
	QGHandler.h
	QGHandler.MotivationStats.h
	QGHandlerAdvance.cpp
	QGHandlerAdvance.h
	QPDProcessor.cpp
	Define base class QPDProcessor.
	QPDProcessor.h
	Define the derived class of QPDProcessor that solves QPs and NLP relaxations.
	QPEngine.h
	QuadHandler.cpp
	Implement a handler for simple quadratic constraints of the form , and ,.
	QuadHandler.h
	Declare a handler for simple quadratic constraints of the form , and , It does not handle any other quadratic constraints.
	QuadraticFunction.cpp
	Define class QuadraticFunction for storing quadratic functions.
	QuadraticFunction.h
	Construct and manage quadratic functions.
	QuadTransformer.cpp
	Define class for reformulations a quadratic problem to make it suitable for handlers.
	QuadTransformer.h
	Declare class for transformation of quadraic problem.
	RandomBrancher.cpp
	Define methods for Random branching.
	RandomBrancher.h
	Declare methods and data structures for Random branching.
	RCHandler.cpp
	RCHandler.h
	Used for tightening lower and upper bound of variables using reduced costs.
	Reader.cpp
	Define Reader class for reading MPS files.
	Reader.h
	Reader for MPS files.
	Relaxation.cpp
	Define base class Relaxation.
	Relaxation.h
	Declare the class Relaxation for storing and manipulating relaxations.
	ReliabilityBrancher.cpp
	Define methods for reliability branching.
	ReliabilityBrancher.h
	Declare methods and data structures for reliability branching.
	SamplingHeur.cpp
	Define the SamplingHeur class for diving heuristics for MINLPs.
	SamplingHeur.h
	Define the class SamplingHeur derived from base class Heuristics.
	SecantMod.h
	SimpleCutMan.cpp
	Implement the methods of SimpleCutMan class.
	SimpleCutMan.h
	Very simple implementation of a cut manager.
	SimpleTransformer.cpp
	Define class for simple reformulations a problem to make it suitable for handlers.
	SimpleTransformer.h
	Declare class for simple transformation of problem.
	SimplexQuadCutGen.h
	Define class for generating cuts for quadratic constraints from the simplex tableau.
	Solution.h
	Implement base class Solution.
	SolutionPool.cpp
	Define SolutionPool class for a storing solutions.
	SolutionPool.h
	Declare a container for storing solutions and their qualities.
	SOS.cpp
	SOS class stores data regarding SOS1 and SOS2 constraints.
	SOS.h
	Declare data structures for an SOS-I and SOS-II constraint.
	SOS1Handler.cpp
	Declare the SOS1Handler class for handling SOS type I constraints. It checks integrality and provides branching candidates. Does not do any presolving and cut-generation.
	SOS1Handler.h
	Declare the SOS1Handler class for handling SOS type I constraints. It checks integrality and provides branching candidates. Does not do any presolving and cut-generation.
	SOS2Handler.cpp
	Declare the SOS2Handler class for handling SOS type II constraints. It checks integrality and provides branching candidates. Does not do any presolving and cut-generation.
	SOS2Handler.h
	Declare the SOS2Handler class for handling SOS type II constraints. It checks integrality and provides branching candidates. Does not do any presolving and cut-generation.
	SOSBrCand.cpp
	Define methods for SOS branching candidates (both Type 1 and 2).
	SOSBrCand.h
	Declare the classes SOSBrCand for storing candidates for branching based upon SOS constraints.
	SppHeur.cpp
	Define the SppHeur class for heuristics for set partitioning.
	SppHeur.h
	Define the class SppHeur for finding solutions to set partitioning.
	STOAHandler.cpp
	STOAHandler.h
	Timer.h
	Define the TimerFactory and varios Timer classes.
	Transformer.cpp
	Define class for reformulating a problem suitable for handlers.
	Transformer.h
	Declare base class for transforming problems.
	TransPoly.cpp
	Define class for reformulating a polynomial problem.
	TransPoly.h
	Declare class for reformulating a polynomial problem.
	TransSep.cpp
	Declare TransSep class for detecting nonlinear function separability. It checks whether the given nonlinear objective and constraint functions are separable. If separable, then it reformulates the original problem.
	TransSep.h
	Declare TransSep class for detecting separable nonlinear constraints in the problem. It considers nonlinear constraints of a problem and checks whether they are separable. If a nonlinear constraint is separable, then it reformulates original problem by introducing extra variables. Original nonlinear constraint becomes linear and each separable part constitutes a nonlinear constraint. This class also gives computational graphs of nonlinear constraints corresponding separable parts of separable constraints. \Author Meenarli Sharma, Indian Institute of Technology Bombay.
	TreeManager.cpp
	Define class TreeManager for managing tree for Branch-and-Bound.
	TreeManager.h
	Declare class ParTreeManager for managing tree for parallel Branch-and-Bound.
	Types.cpp
	Define methods specific to Types.h (like compare functions for sorting etc.)
	Types.h
	Declare important 'types' used in Minotaur.
	UnambRelBrancher.cpp
	Define methods for unambiguous reliability branching.
	UnambRelBrancher.h
	Declare methods and data structures for unambiguous reliability branching.
	UnivarQuadHandler.h
	Declare a handler for quadratic constraints of the form , , and , It does not handle any other quadratic constraints.
	VarBoundMod.cpp
	Implement the Modification class VarBoundMod, that is used to store modifications to a bound on a variable.
	VarBoundMod.h
	Declare the class VarBoundMod. It is used to save modifications in a bound of a variable. Also declare VarBoundMod2 that is used to change both bounds of a variable.
	Variable.cpp
	Define Variables class for storing variables of a problem.
	Variable.h
	Define the Variable class.
	WarmStart.h
	WeakBrancher.cpp
	Define methods for Weak branching.
	WeakBrancher.h
	Declare methods and data structures for weak branching.
	YEqBivar.cpp
	Define class for storing auxiliary variables equivalent to a bivar.
	YEqBivar.h
	Declare class for storing auxiliary variables equivalent to a bivar.
	YEqCGs.cpp
	Define class for storing auxiliary variables for nonlinear functions that are expressed as computational graphs.
	YEqCGs.h
	Declare the class for storing auxiliary variables for nonlinear functions that are expressed as computational graphs.
	YEqLFs.h
	Declare the class for storing auxiliary variables for linear functions.
	YEqMonomial.cpp
	Define class for storing auxiliary variables for monomial expressions.
	YEqMonomial.h
	Declare class for storing auxiliary variables for monomial expressions.
	YEqQfBil.cpp
	Define class for storing auxiliary variables equivalebt to a product of two variables.
	YEqQfBil.h
	Declare class for storing auxiliary variables equivalent to a product of two variables.
	YEqUCGs.cpp
	Define class for storing auxiliary variables for univariate nonlinear functions that are expressed as computational graphs.
	YEqUCGs.h
	Declare the class for storing auxiliary variables for univariate nonlinear functions that are expressed as computational graphs.
	YEqUnivar.cpp
	Define class for storing auxiliary variables equivalent to a bivar.
	YEqUnivar.h
	Declare class for storing auxiliary variables equivalent to a univar.
	YEqVars.cpp
	Define class for storing auxiliary variables equivalent to a sum of a variable and a constant.
	YEqVars.h
	Declare class for storing auxiliary variables equivalent to a sum of a variable and a constant.